blocks|key|1424047|text|从角度计算单位向量，并取其平均值的角度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424048|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Compute unit vectors from the angles and take the angle of their average.

blocks|key|1424111|text|我看到了问题--例如，如果你有一个45‘的角度和一个315’的角度，那么“自然”的平均值应该是180'，但你想要的值实际上是0‘。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424112|我觉得星蓝说对了。只需计算每个角度的(x，y)笛卡尔坐标，并将得到的向量相加。最终向量的角度偏移量应该是您需要的结果。|1424113|x+=+y+=+0
foreach+angle+{
++++x+%2B=+cos(angle)
++++y+%2B=+sin(angle)
}
average_angle+=+atan2(y,+x)|code-block|syntax|javascript|1424114|我现在忽略了指南针方向从北开始，顺时针方向，而“正常”笛卡尔坐标沿着X轴从零开始，然后逆时针方向。不管怎样，数学应该以同样的方式计算出来。|1424115|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I see the problem - for example, if you have a 45' angle and a 315' angle, the "natural" average would be 180', but the value you want is actually 0'.

I think Starblue is onto something. Just calculate the (x, y) cartesian coordinates for each angle, and add those resulting vectors together. The angular offset of the final vector should be your required result.

<pre><code>x = y = 0
foreach angle {
 x += cos(angle)
 y += sin(angle)
}
average_angle = atan2(y, x)
</code></pre>

I'm ignoring for now that a compass heading starts at north, and goes clockwise, whereas "normal" cartesian coordinates start with zero along the X axis, and then go anti-clockwise. The maths should work out the same way regardless.

blocks|key|1639088|text|这里有一个想法:通过总是计算最接近的角度的平均值来迭代地构建平均值，保持权重。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1639089|另一个想法:找出给定角度之间的最大间隙。找到将其一分为二的点，然后拾取圆上的相反点作为计算平均值的参考零点。|1639090|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Here's an idea: build the average iteratively by always calculating the average of the angles that are closest together, keeping a weight. 

Another idea: find the largest gap between the given angles. Find the point that bisects it, and then pick the opposite point on the circle as the reference zero to calculate the average from.

blocks|key|1639174|text|让我们用圆周上的点来表示这些角度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1639175|我们能假设所有这些点都落在圆的同一半个点上吗？(否则，没有明显的方法来定义“平均角度”。想想直径上的两个点，例如0度和180度-平均是90度还是270度？当我们有3个或更多均匀分布的点时会发生什么？)|1639176|在这个假设下，我们选择半圆上的任意点作为“原点”，并测量相对于这个原点的给定角度集(称为“相对角度”)。请注意，相对角度的绝对值严格小于180度。最后，取这些相对角度的平均值以获得所需的平均角度(当然是相对于我们的原点)。|1639177|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Let's represent these angles with points on the circumference of the circle.

Can we assume that all these points fall on the same half of the circle? (Otherwise, there is no obvious way to define the "average angle". Think of two points on the diameter, e.g. 0 deg and 180 deg --- is the average 90 deg or 270 deg? What happens when we have 3 or more evenly spread out points?)

With this assumption, we pick an arbitrary point on that semicircle as the "origin", and measure the given set of angles with respect to this origin (call this the "relative angle"). Note that the relative angle has an absolute value strictly less than 180 deg. Finally, take the mean of these relative angles to get the desired average angle (relative to our origin of course).

blocks|key|1424368|text|这个问题在布鲁斯·卡什在http://catless.ncl.ac.uk/Risks/7.44.html#subj4上提到的“球体上的统计”一书中进行了详细的研究，杰弗里·S·沃森，阿肯色大学数学科学讲座笔记，1983年约翰·威利父子公司。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1424369|从一组角度测量值ai+0<=i估计平均角度A的好方法|1424370|+++++++++++++++++++sum_i_from_1_to_N+sin(a[i])
a+=+arctangent+---------------------------
+++++++++++++++++++sum_i_from_1_to_N+cos(a[i])|code-block|syntax|javascript|1424371|starblue给出的方法在计算上是等价的，但他的理由更清晰，可能在编程上更有效，而且在零的情况下也能很好地工作，所以称赞他。|1424372|现在对这个主题进行了更详细的on+Wikipedia探索，并结合其他用途，如小数部分。|1424373|entityMap|0|LINK|mutability|MUTABLE|url|http://catless.ncl.ac.uk/Risks/7.44.html#subj4|1|http://en.wikipedia.org/wiki/Circular_mean^0|C|1A|0|0|0|0|0|E|C|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

This question is examined in detail in the book: 
"Statistics On Spheres", Geoffrey S. Watson, University of Arkansas Lecture
Notes in the Mathematical Sciences, 1983 John Wiley &amp; Sons, Inc. as mentioned at <a href="http://catless.ncl.ac.uk/Risks/7.44.html#subj4" rel="noreferrer">http://catless.ncl.ac.uk/Risks/7.44.html#subj4</a> by Bruce Karsh.

A good way to estimate an average angle, A, from a set of angle measurements
a[i] 0&lt;=i

<pre><code> sum_i_from_1_to_N sin(a[i])
a = arctangent ---------------------------
 sum_i_from_1_to_N cos(a[i])
</code></pre>

The method given by starblue is computationally equivalent, but his reasons are clearer and probably programmatically more efficient, and also work well in the zero case, so kudos to him.

The subject is now explored in more detail <a href="http://en.wikipedia.org/wiki/Circular_mean" rel="noreferrer">on Wikipedia</a>, and with other uses, like fractional parts.

blocks|key|1424505|text|Alnitak有正确的解决方案。Nick+Fortescue的解决方案在功能上是相同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424506|对于where的特殊情况|1424507|(+sum(x_component)+=+0.0+&&+sum(y_component)+=+0.0+)+//例如10和190的两个角度。ea学位。|1424508|使用0.0度作为总和|1424509|从计算上讲，您必须测试这种情况，因为atan2(0。，0。)是未定义的，并将生成错误。|1424510|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Alnitak has the right solution. Nick Fortescue's solution is functionally the same. 

For the special case of where

( sum(x_component) = 0.0 &amp;&amp; sum(y_component) = 0.0 ) // e.g. 2 angles of 10. and 190. degrees ea.

use 0.0 degrees as the sum

Computationally you have to test for this case since atan2(0. , 0.) is undefined and will generate an error.

blocks|key|1639641|text|ackb是正确的，这些基于矢量的解决方案不能被认为是角度的真实平均值，它们只是单位矢量对应的平均值。然而，从数学角度看，ackb提出的解决方案似乎并不合理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1639642|下面的解决方案是从最小化(anglei+-+avgAngle)%5E2+(如果需要的话，差异被纠正)的目标数学推导出来的，这使得它成为角度的真正算术平均值。|1639643|首先，我们需要看看在哪些情况下，角度之间的差异与其正常数对应物之间的差异是不同的。考虑x和y角，如果y角x-+180和y角x%2B+180，那么我们可以直接使用差值(x-y)。否则，如果不满足第一个条件，则我们必须在计算中使用(y%2B360)而不是y。相应地，如果不满足第二个条件，则必须使用(+y+-360)而不是y。由于曲线方程仅在这些不等式从真变为假或反之亦然的点处发生变化，因此我们可以将整个[0,360]范围分成一组线段，由这些点分隔。然后，我们只需要找到每个片段的最小值，然后找到每个片段的最小值，即平均值。|1639644|这张图片展示了在计算角度差异时出现问题的地方。如果x位于灰色区域，那么就会有问题。|1639645|​|1639646|📷|atomic|offset|length|1639647|1639648|为了最小化一个变量，取决于曲线，我们可以取我们想要最小化的东西的导数，然后我们找到转折点(导数=+0)。|1639649|这里我们将应用最小化平方差的思想来推导出常见的算术平均值公式:+sum(ai)/n。曲线y=+sum((ai-x)%5E2)可以这样最小化：|1639650|y+=+sum((a[i]-x)%5E2)
=+sum(a[i]%5E2+-+2*a[i]*x+%2B+x%5E2)
=+sum(a[i]%5E2)+-+2*x*sum(a[i])+%2B+n*x%5E2

dy\dx+=+-2*sum(a[i])+%2B+2*n*x

for+dy/dx+=+0:
-2*sum(a[i])+%2B+2*n*x+=+0
->+n*x+=+sum(a[i])
->+x+=+sum(a[i])/n|code-block|syntax|javascript|1639651|现在将其应用于具有调整后的差异的曲线：|1639652|B=a的子集，其中校正(角度)差ai-x+c=a的子集，其中校正(角度)差(ai-360)-x+cn+=c的大小d=a的子集其中校正(角度)差(ai%2B360)-x+dn+=d的大小|1639653|y+=+sum((b[i]-x)%5E2)+%2B+sum(((c[i]-360)-b)%5E2)+%2B+sum(((d[i]%2B360)-c)%5E2)
=+sum(b[i]%5E2+-+2*b[i]*x+%2B+x%5E2)
++%2B+sum((c[i]-360)%5E2+-+2*(c[i]-360)*x+%2B+x%5E2)
++%2B+sum((d[i]%2B360)%5E2+-+2*(d[i]%2B360)*x+%2B+x%5E2)
=+sum(b[i]%5E2)+-+2*x*sum(b[i])
++%2B+sum((c[i]-360)%5E2)+-+2*x*(sum(c[i])+-+360*cn)
++%2B+sum((d[i]%2B360)%5E2)+-+2*x*(sum(d[i])+%2B+360*dn)
++%2B+n*x%5E2
=+sum(b[i]%5E2)+%2B+sum((c[i]-360)%5E2)+%2B+sum((d[i]%2B360)%5E2)
++-+2*x*(sum(b[i])+%2B+sum(c[i])+%2B+sum(d[i]))
++-+2*x*(360*dn+-+360*cn)
++%2B+n*x%5E2
=+sum(b[i]%5E2)+%2B+sum((c[i]-360)%5E2)+%2B+sum((d[i]%2B360)%5E2)
++-+2*x*sum(x[i])
++-+2*x*360*(dn+-+cn)
++%2B+n*x%5E2

dy/dx+=+2*n*x+-+2*sum(x[i])+-+2*360*(dn+-+cn)

for+dy/dx+=+0:
2*n*x+-+2*sum(x[i])+-+2*360*(dn+-+cn)+=+0
n*x+=+sum(x[i])+%2B+360*(dn+-+cn)
x+=+(sum(x[i])+%2B+360*(dn+-+cn))/n|1639654|这本身并不足以得到最小值，尽管它适用于具有无界集合的正常值，因此结果肯定会在集合的范围内，因此是有效的。我们需要一个范围内的最小值(由细分定义)。如果最小值小于我们分段的下界，那么该分段的最小值必须在下界(因为二次曲线只有一个转折点)，如果最小值大于我们分段的上界，则该分段的最小值位于上限。在我们有了每个段的最小值之后，我们只需找到我们要最小化的值最小的那个(sum((bi-x)%5E2)+%2Bsum((ci-360)-b)%5E2)%2Bsum((di%2B360)-c)%5E2)。|1639655|这是曲线的图像，它显示了在x=(ai%2B180)%25360的点上它是如何变化的。有问题的数据集是{65,92,230,320,250}。|1639656|1639657|1639658|1639659|这是一个用Java实现的算法，包括一些优化，它的复杂度是O(nlogn)。如果您将基于比较的排序替换为非基于比较的排序，例如基数排序，则可以将其减少到O(n)。|1639660|static+double+varnc(double+_mean,+int+_n,+double+_sumX,+double+_sumSqrX)
{
++++return+_mean*(_n*_mean+-+2*_sumX)+%2B+_sumSqrX;
}
//with+lower+correction
static+double+varlc(double+_mean,+int+_n,+double+_sumX,+double+_sumSqrX,+int+_nc,+double+_sumC)
{
++++return+_mean*(_n*_mean+-+2*_sumX)+%2B+_sumSqrX
++++++++++++%2B+2*360*_sumC+%2B+_nc*(-2*360*_mean+%2B+360*360);
}
//with+upper+correction
static+double+varuc(double+_mean,+int+_n,+double+_sumX,+double+_sumSqrX,+int+_nc,+double+_sumC)
{
++++return+_mean*(_n*_mean+-+2*_sumX)+%2B+_sumSqrX
++++++++++++-+2*360*_sumC+%2B+_nc*(2*360*_mean+%2B+360*360);
}

static+double[]+averageAngles(double[]+_angles)
{
++++double+sumAngles;
++++double+sumSqrAngles;

++++double[]+lowerAngles;
++++double[]+upperAngles;

++++{
++++++++List<Double>+lowerAngles_+=+new+LinkedList<Double>();
++++++++List<Double>+upperAngles_+=+new+LinkedList<Double>();

++++++++sumAngles+=+0;
++++++++sumSqrAngles+=+0;
++++++++for(double+angle+:+_angles)
++++++++{
++++++++++++sumAngles+%2B=+angle;
++++++++++++sumSqrAngles+%2B=+angle*angle;
++++++++++++if(angle+<+180)
++++++++++++++++lowerAngles_.add(angle);
++++++++++++else+if(angle+>+180)
++++++++++++++++upperAngles_.add(angle);
++++++++}


++++++++Collections.sort(lowerAngles_);
++++++++Collections.sort(upperAngles_,Collections.reverseOrder());


++++++++lowerAngles+=+new+double[lowerAngles_.size()];
++++++++Iterator<Double>+lowerAnglesIter+=+lowerAngles_.iterator();
++++++++for(int+i+=+0;+i+<+lowerAngles_.size();+i%2B%2B)
++++++++++++lowerAngles[i]+=+lowerAnglesIter.next();

++++++++upperAngles+=+new+double[upperAngles_.size()];
++++++++Iterator<Double>+upperAnglesIter+=+upperAngles_.iterator();
++++++++for(int+i+=+0;+i+<+upperAngles_.size();+i%2B%2B)
++++++++++++upperAngles[i]+=+upperAnglesIter.next();
++++}

++++List<Double>+averageAngles+=+new+LinkedList<Double>();
++++averageAngles.add(180d);
++++double+variance+=+varnc(180,_angles.length,sumAngles,sumSqrAngles);

++++double+lowerBound+=+180;
++++double+sumLC+=+0;
++++for(int+i+=+0;+i+<+lowerAngles.length;+i%2B%2B)
++++{
++++++++//get+average+for+a+segment+based+on+minimum
++++++++double+testAverageAngle+=+(sumAngles+%2B+360*i)/_angles.length;
++++++++//minimum+is+outside+segment+range+(therefore+not+directly+relevant)
++++++++//since+it+is+greater+than+lowerAngles[i],+the+minimum+for+the+segment
++++++++//must+lie+on+the+boundary+lowerAngles[i]
++++++++if(testAverageAngle+>+lowerAngles[i]%2B180)
++++++++++++testAverageAngle+=+lowerAngles[i];

++++++++if(testAverageAngle+>+lowerBound)
++++++++{
++++++++++++double+testVariance+=+varlc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,i,sumLC);

++++++++++++if(testVariance+<+variance)
++++++++++++{
++++++++++++++++averageAngles.clear();
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++++++++++variance+=+testVariance;
++++++++++++}
++++++++++++else+if(testVariance+==+variance)
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++}

++++++++lowerBound+=+lowerAngles[i];
++++++++sumLC+%2B=+lowerAngles[i];
++++}
++++//Test+last+segment
++++{
++++++++//get+average+for+a+segment+based+on+minimum
++++++++double+testAverageAngle+=+(sumAngles+%2B+360*lowerAngles.length)/_angles.length;
++++++++//minimum+is+inside+segment+range
++++++++//we+will+test+average+0+(360)+later
++++++++if(testAverageAngle+<+360+&&+testAverageAngle+>+lowerBound)
++++++++{
++++++++++++double+testVariance+=+varlc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,lowerAngles.length,sumLC);

++++++++++++if(testVariance+<+variance)
++++++++++++{
++++++++++++++++averageAngles.clear();
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++++++++++variance+=+testVariance;
++++++++++++}
++++++++++++else+if(testVariance+==+variance)
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++}
++++}


++++double+upperBound+=+180;
++++double+sumUC+=+0;
++++for(int+i+=+0;+i+<+upperAngles.length;+i%2B%2B)
++++{
++++++++//get+average+for+a+segment+based+on+minimum
++++++++double+testAverageAngle+=+(sumAngles+-+360*i)/_angles.length;
++++++++//minimum+is+outside+segment+range+(therefore+not+directly+relevant)
++++++++//since+it+is+greater+than+lowerAngles[i],+the+minimum+for+the+segment
++++++++//must+lie+on+the+boundary+lowerAngles[i]
++++++++if(testAverageAngle+<+upperAngles[i]-180)
++++++++++++testAverageAngle+=+upperAngles[i];

++++++++if(testAverageAngle+<+upperBound)
++++++++{
++++++++++++double+testVariance+=+varuc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,i,sumUC);

++++++++++++if(testVariance+<+variance)
++++++++++++{
++++++++++++++++averageAngles.clear();
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++++++++++variance+=+testVariance;
++++++++++++}
++++++++++++else+if(testVariance+==+variance)
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++}

++++++++upperBound+=+upperAngles[i];
++++++++sumUC+%2B=+upperBound;
++++}
++++//Test+last+segment
++++{
++++++++//get+average+for+a+segment+based+on+minimum
++++++++double+testAverageAngle+=+(sumAngles+-+360*upperAngles.length)/_angles.length;
++++++++//minimum+is+inside+segment+range
++++++++//we+test+average+0+(360)+now+++++++++++
++++++++if(testAverageAngle+<+0)
++++++++++++testAverageAngle+=+0;

++++++++if(testAverageAngle+<+upperBound)
++++++++{
++++++++++++double+testVariance+=+varuc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,upperAngles.length,sumUC);

++++++++++++if(testVariance+<+variance)
++++++++++++{
++++++++++++++++averageAngles.clear();
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++++++++++variance+=+testVariance;
++++++++++++}
++++++++++++else+if(testVariance+==+variance)
++++++++++++++++averageAngles.add(testAverageAngle);
++++++++}
++++}


++++double[]+averageAngles_+=+new+double[averageAngles.size()];
++++Iterator<Double>+averageAnglesIter+=+averageAngles.iterator();
++++for(int+i+=+0;+i+<+averageAngles_.length;+i%2B%2B)
++++++++averageAngles_[i]+=+averageAnglesIter.next();


++++return+averageAngles_;
}|1639661|一组角度的算术平均值可能与您对平均值应为多少的直观想法不一致。例如，集合{179,179,0,181,181}的算术平均值是216+(和144)。您立即想到的答案可能是180，但是众所周知，算术平均值受边缘值的影响很大。您还应该记住，角度不是向量，尽管有时在处理角度时看起来很吸引人。|1639662|当然，这个算法也适用于所有遵循模算术(只需最小调整)的量，例如一天中的时间。|1639663|我还想强调的是，尽管这是角度的真实平均值，但与矢量解决方案不同，这并不意味着它就是您应该使用的解决方案，相应单位矢量的平均值很可能就是您实际应该使用的值。|1639664|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/1e0350dfad1c70a5472f99d4d5b37119.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/baac36ccfc4e2ee78a3e2d411a810e91.png^0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|1|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|20|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|21|8|@]|9|@$M|22|N|23|1|24]]|A|$]]|$1|O|3|I|5|6|7|25|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|26|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|27|8|@]|9|@]|A|$]]|$1|T|3|U|5|V|7|28|8|@]|9|@]|A|$W|X]]|$1|Y|3|Z|5|6|7|29|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2A|8|@]|9|@]|A|$]]|$1|12|3|13|5|V|7|2B|8|@]|9|@]|A|$W|X]]|$1|14|3|15|5|6|7|2C|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2D|8|@]|9|@]|A|$]]|$1|18|3|I|5|6|7|2E|8|@]|9|@]|A|$]]|$1|19|3|K|5|L|7|2F|8|@]|9|@$M|2G|N|2H|1|2I]]|A|$]]|$1|1A|3|I|5|6|7|2J|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|V|7|2L|8|@]|9|@]|A|$W|X]]|$1|1F|3|1G|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1L|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]]|1M|$1N|$5|1O|1P|1Q|A|$1R|1S|1T|-4]]|1U|$5|1O|1P|1Q|A|$1R|1V|1T|-4]]]]

ackb is right that these vector based solutions cannot be considered true averages of angles, they are only an average of the unit vector counterparts. However, ackb's suggested solution does not appear to mathematically sound.

The following is a solution that is mathematically derived from the goal of minimising (angle[i] - avgAngle)^2 (where the difference is corrected if necessary), which makes it a true arithmetic mean of the angles.

First, we need to look at exactly which cases the difference between angles is different to the difference between their normal number counterparts. Consider angles x and y, if y >= x - 180 and y &lt;= x + 180, then we can use the difference (x-y) directly. Otherwise, if the first condition is not met then we must use (y+360) in the calculation instead of y. Corresponding, if the second condition is not met then we must use (y-360) instead of y. Since the equation of the curve we are minimising only changes at the points where these inequalities change from true to false or vice versa, we can separate the full [0,360) range into a set of segments, separated by these points. Then, we only need to find the minimum of each of these segments, and then the minimum of each segment's minimum, which is the average.

Here's an image demonstrating where the problems occur in calculating angle differences. If x lies in the gray area then there will be a problem.

<a href="https://i.stack.imgur.com/Gcdf9.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Gcdf9.png" alt="Angle comparisons"></a>

To minimise a variable, depending on the curve, we can take the derivative of what we want to minimise and then we find the turning point (which is where the derivative = 0).

Here we will apply the idea of minimise the squared difference to derive the common arithmetic mean formula: sum(a[i])/n. The curve y = sum((a[i]-x)^2) can be minimised in this way:

<pre><code>y = sum((a[i]-x)^2)
= sum(a[i]^2 - 2*a[i]*x + x^2)
= sum(a[i]^2) - 2*x*sum(a[i]) + n*x^2

dy\dx = -2*sum(a[i]) + 2*n*x

for dy/dx = 0:
-2*sum(a[i]) + 2*n*x = 0
-&gt; n*x = sum(a[i])
-&gt; x = sum(a[i])/n
</code></pre>

Now applying it to curves with our adjusted differences:

b = subset of a where the correct (angular) difference a[i]-x
c = subset of a where the correct (angular) difference (a[i]-360)-x
cn = size of c
d = subset of a where the correct (angular) difference (a[i]+360)-x
dn = size of d

<pre><code>y = sum((b[i]-x)^2) + sum(((c[i]-360)-b)^2) + sum(((d[i]+360)-c)^2)
= sum(b[i]^2 - 2*b[i]*x + x^2)
 + sum((c[i]-360)^2 - 2*(c[i]-360)*x + x^2)
 + sum((d[i]+360)^2 - 2*(d[i]+360)*x + x^2)
= sum(b[i]^2) - 2*x*sum(b[i])
 + sum((c[i]-360)^2) - 2*x*(sum(c[i]) - 360*cn)
 + sum((d[i]+360)^2) - 2*x*(sum(d[i]) + 360*dn)
 + n*x^2
= sum(b[i]^2) + sum((c[i]-360)^2) + sum((d[i]+360)^2)
 - 2*x*(sum(b[i]) + sum(c[i]) + sum(d[i]))
 - 2*x*(360*dn - 360*cn)
 + n*x^2
= sum(b[i]^2) + sum((c[i]-360)^2) + sum((d[i]+360)^2)
 - 2*x*sum(x[i])
 - 2*x*360*(dn - cn)
 + n*x^2

dy/dx = 2*n*x - 2*sum(x[i]) - 2*360*(dn - cn)

for dy/dx = 0:
2*n*x - 2*sum(x[i]) - 2*360*(dn - cn) = 0
n*x = sum(x[i]) + 360*(dn - cn)
x = (sum(x[i]) + 360*(dn - cn))/n
</code></pre>

This alone is not quite enough to get the minimum, while it works for normal values, that has an unbounded set, so the result will definitely lie within set's range and is therefore valid. We need the minimum within a range (defined by the segment). If the minimum is less than our segment's lower bound then the minimum of that segment must be at the lower bound (because quadratic curves only have 1 turning point) and if the minimum is greater than our segment's upper bound then the segment's minimum is at the upper bound. After we have the minimum for each segment, we simply find the one that has the lowest value for what we're minimising (sum((b[i]-x)^2) + sum(((c[i]-360)-b)^2) + sum(((d[i]+360)-c)^2)).

Here is an image to the curve, which shows how it changes at the points where x=(a[i]+180)%360. The data set is in question is {65,92,230,320,250}.

<a href="https://i.stack.imgur.com/bN15O.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/bN15O.png" alt="Curve"></a>

Here is an implementation of the algorithm in Java, including some optimisations, its complexity is O(nlogn). It can be reduced to O(n) if you replace the comparison based sort with a non comparison based sort, such as radix sort.

<pre><code>static double varnc(double _mean, int _n, double _sumX, double _sumSqrX)
{
 return _mean*(_n*_mean - 2*_sumX) + _sumSqrX;
}
//with lower correction
static double varlc(double _mean, int _n, double _sumX, double _sumSqrX, int _nc, double _sumC)
{
 return _mean*(_n*_mean - 2*_sumX) + _sumSqrX
 + 2*360*_sumC + _nc*(-2*360*_mean + 360*360);
}
//with upper correction
static double varuc(double _mean, int _n, double _sumX, double _sumSqrX, int _nc, double _sumC)
{
 return _mean*(_n*_mean - 2*_sumX) + _sumSqrX
 - 2*360*_sumC + _nc*(2*360*_mean + 360*360);
}

static double[] averageAngles(double[] _angles)
{
 double sumAngles;
 double sumSqrAngles;

 double[] lowerAngles;
 double[] upperAngles;

 {
 List&lt;Double&gt; lowerAngles_ = new LinkedList&lt;Double&gt;();
 List&lt;Double&gt; upperAngles_ = new LinkedList&lt;Double&gt;();

 sumAngles = 0;
 sumSqrAngles = 0;
 for(double angle : _angles)
 {
 sumAngles += angle;
 sumSqrAngles += angle*angle;
 if(angle &lt; 180)
 lowerAngles_.add(angle);
 else if(angle &gt; 180)
 upperAngles_.add(angle);
 }


 Collections.sort(lowerAngles_);
 Collections.sort(upperAngles_,Collections.reverseOrder());


 lowerAngles = new double[lowerAngles_.size()];
 Iterator&lt;Double&gt; lowerAnglesIter = lowerAngles_.iterator();
 for(int i = 0; i &lt; lowerAngles_.size(); i++)
 lowerAngles[i] = lowerAnglesIter.next();

 upperAngles = new double[upperAngles_.size()];
 Iterator&lt;Double&gt; upperAnglesIter = upperAngles_.iterator();
 for(int i = 0; i &lt; upperAngles_.size(); i++)
 upperAngles[i] = upperAnglesIter.next();
 }

 List&lt;Double&gt; averageAngles = new LinkedList&lt;Double&gt;();
 averageAngles.add(180d);
 double variance = varnc(180,_angles.length,sumAngles,sumSqrAngles);

 double lowerBound = 180;
 double sumLC = 0;
 for(int i = 0; i &lt; lowerAngles.length; i++)
 {
 //get average for a segment based on minimum
 double testAverageAngle = (sumAngles + 360*i)/_angles.length;
 //minimum is outside segment range (therefore not directly relevant)
 //since it is greater than lowerAngles[i], the minimum for the segment
 //must lie on the boundary lowerAngles[i]
 if(testAverageAngle &gt; lowerAngles[i]+180)
 testAverageAngle = lowerAngles[i];

 if(testAverageAngle &gt; lowerBound)
 {
 double testVariance = varlc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,i,sumLC);

 if(testVariance &lt; variance)
 {
 averageAngles.clear();
 averageAngles.add(testAverageAngle);
 variance = testVariance;
 }
 else if(testVariance == variance)
 averageAngles.add(testAverageAngle);
 }

 lowerBound = lowerAngles[i];
 sumLC += lowerAngles[i];
 }
 //Test last segment
 {
 //get average for a segment based on minimum
 double testAverageAngle = (sumAngles + 360*lowerAngles.length)/_angles.length;
 //minimum is inside segment range
 //we will test average 0 (360) later
 if(testAverageAngle &lt; 360 &amp;&amp; testAverageAngle &gt; lowerBound)
 {
 double testVariance = varlc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,lowerAngles.length,sumLC);

 if(testVariance &lt; variance)
 {
 averageAngles.clear();
 averageAngles.add(testAverageAngle);
 variance = testVariance;
 }
 else if(testVariance == variance)
 averageAngles.add(testAverageAngle);
 }
 }


 double upperBound = 180;
 double sumUC = 0;
 for(int i = 0; i &lt; upperAngles.length; i++)
 {
 //get average for a segment based on minimum
 double testAverageAngle = (sumAngles - 360*i)/_angles.length;
 //minimum is outside segment range (therefore not directly relevant)
 //since it is greater than lowerAngles[i], the minimum for the segment
 //must lie on the boundary lowerAngles[i]
 if(testAverageAngle &lt; upperAngles[i]-180)
 testAverageAngle = upperAngles[i];

 if(testAverageAngle &lt; upperBound)
 {
 double testVariance = varuc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,i,sumUC);

 if(testVariance &lt; variance)
 {
 averageAngles.clear();
 averageAngles.add(testAverageAngle);
 variance = testVariance;
 }
 else if(testVariance == variance)
 averageAngles.add(testAverageAngle);
 }

 upperBound = upperAngles[i];
 sumUC += upperBound;
 }
 //Test last segment
 {
 //get average for a segment based on minimum
 double testAverageAngle = (sumAngles - 360*upperAngles.length)/_angles.length;
 //minimum is inside segment range
 //we test average 0 (360) now 
 if(testAverageAngle &lt; 0)
 testAverageAngle = 0;

 if(testAverageAngle &lt; upperBound)
 {
 double testVariance = varuc(testAverageAngle,_angles.length,sumAngles,sumSqrAngles,upperAngles.length,sumUC);

 if(testVariance &lt; variance)
 {
 averageAngles.clear();
 averageAngles.add(testAverageAngle);
 variance = testVariance;
 }
 else if(testVariance == variance)
 averageAngles.add(testAverageAngle);
 }
 }


 double[] averageAngles_ = new double[averageAngles.size()];
 Iterator&lt;Double&gt; averageAnglesIter = averageAngles.iterator();
 for(int i = 0; i &lt; averageAngles_.length; i++)
 averageAngles_[i] = averageAnglesIter.next();


 return averageAngles_;
}
</code></pre>

The arithmetic mean of a set of angles may not agree with your intuitive idea of what the average should be. For example, the arithmetic mean of the set {179,179,0,181,181} is 216 (and 144). The answer you immediately think of is probably 180, however it is well known that the arithmetic mean is heavily affected by edge values. You should also remember that angles are not vectors, as appealing as that may seem when dealing with angles sometimes.

This algorithm does of course also apply to all quantities that obey modular arithmetic (with minimal adjustment), such as the time of day.

I would also like to stress that even though this is a true average of angles, unlike the vector solutions, that does not necessarily mean it is the solution you should be using, the average of the corresponding unit vectors may well be the value you actually should to be using.

blocks|key|1424752|text|与所有平均值一样，答案取决于度量标准的选择。对于给定的度量M，一些角度a_k在-pi中的平均值，pi对于k在1，N中是角度a_M，它最小化平方距离的和d%5E2_M(a_M，a_k)。对于加权平均值，只需在和中包括权重w_k+(使得sum_k+w_k+=+1)。那是,|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424753|a_M+=+arg+min_x+sum_k+w_k+d%5E2_M(x，a_k)|1424754|两个常见的度量选择是Frobenius和Riemann度量。对于Frobenius度量，存在一个直接公式，该公式对应于循环统计中通常的平均方位概念。具体见Maher+Moakher的"Means+and+Averaging+in+the+Group+of+Rotation“，SIAM+Journal+on+Matrix+Analysis+and+Applications，卷24,2002年第1期。|1424755|http://link.aip.org/link/?SJMAEL/24/1/1|offset|length|1424756|下面是GNU+Octave+3.2.4的一个函数，它执行计算：|1424757|function+ma=meanangleoct(a,w,hp,ntype)
%25+++ma=meanangleoct(a,w,hp,ntype)+returns+the+average+of+angles+a
%25+++given+weights+w+and+half-period+hp+using+norm+type+ntype
%25+++Ref:+"Means+and+Averaging+in+the+Group+of+Rotations",
%25+++Maher+Moakher,+SIAM+Journal+on+Matrix+Analysis+and+Applications,
%25+++Volume+24,+Issue+1,+2002.

if+(nargin<1)+%7C+(nargin>4),+help+meanangleoct,+return,+end+
if+isempty(a),+error('no+measurement+angles'),+end
la=length(a);+sa=size(a);+
if+prod(sa)~=la,+error('a+must+be+a+vector');+end
if+(nargin<4)+%7C%7C+isempty(ntype),+ntype='F';+end
if+~sum(ntype==['F'+'R']),+error('ntype+must+be+F+or+R'),+end
if+(nargin<3)+%7C%7C+isempty(hp),+hp=pi;+end
if+(nargin<2)+%7C%7C+isempty(w),+w=1/la%2B0*a;+end
lw=length(w);+sw=size(w);+
if+prod(sw)~=lw,+error('w+must+be+a+vector');+end
if+lw~=la,+error('length+of+w+must+equal+length+of+a'),+end
if+sum(w)~=1,+warning('resumming+weights+to+unity'),+w=w/sum(w);+end

a=a(:);+++++%25+make+column+vector
w=w(:);+++++%25+make+column+vector
a=mod(a%2Bhp,2*hp)-hp;++++%25+reduce+to+central+period
a=a/hp*pi;++++++++++++++%25+scale+to+half+period+pi
z=exp(i*a);+%25+U(1)+elements

%25+%25+NOTA+BENE:
%25+%25+fminbnd+can+get+hung+up+near+the+boundaries.
%25+%25+If+that+happens,+shift+the+input+angles+a
%25+%25+forward+by+one+half+period,+then+shift+the
%25+%25+resulting+mean+ma+back+by+one+half+period.
%25+X=fminbnd(@meritfcn,-pi,pi,[],z,w,ntype);

%25+%25+seems+to+work+better
x0=imag(log(sum(w.*z)));
X=fminbnd(@meritfcn,x0-pi,x0%2Bpi,[],z,w,ntype);

%25+X=real(X);++++++++++++++%25+truncate+some+roundoff
X=mod(X%2Bpi,2*pi)-pi;++++%25+reduce+to+central+period
ma=X*hp/pi;+++++++++++++%25+scale+to+half+period+hp

return
%25%25%25%25%25%25

function+d2=meritfcn(x,z,w,ntype)
x=exp(i*x);
if+ntype=='F'
++++y=x-z;
else+%25+ntype=='R'
++++y=log(x'*z);
end
d2=y'*diag(w)*y;
return
%25%25%25%25%25%25

%25+%25+++test+script
%25+%25+
%25+%25+NOTA+BENE:+meanangleoct(a,[],[],'R')+will+equal+mean(a)+
%25+%25+when+all+abs(a-b)+<+pi/2+for+some+value+b
%25+%25+
%25+na=3,+a=sort(mod(randn(1,na)%2B1,2)-1)*pi;
%25+da=diff([a+a(1)%2B2*pi]);+[mda,ndx]=min(da);
%25+a=circshift(a,[0+2-ndx])++++%25+so+that+diff(a(2:3))+is+smallest
%25+A=exp(i*a),+B1=expm(a(1)*[0+-1;+1+0]),+
%25+B2=expm(a(2)*[0+-1;+1+0]),+B3=expm(a(3)*[0+-1;+1+0]),
%25+masimpl=[angle(mean(exp(i*a)))+mean(a)]
%25+Bsum=B1%2BB2%2BB3;+BmeanF=Bsum/sqrt(det(Bsum));+
%25+%25+this+expression+for+BmeanR+should+be+correct+for+ordering+of+a+above
%25+BmeanR=B1*(B1'*B2*(B2'*B3)%5E(1/2))%5E(2/3);
%25+mamtrx=real([[0+1]*logm(BmeanF)*[1+0]'+[0+1]*logm(BmeanR)*[1+0]'])
%25+manorm=[meanangleoct(a,[],[],'F')+meanangleoct(a,[],[],'R')]
%25+polar(a,1%2B0*a,'b*'),+axis+square,+hold+on
%25+polar(manorm(1),1,'rs'),+polar(manorm(2),1,'gd'),+hold+off

%25+++++Meanangleoct+Version+1.0
%25+++++Copyright+(C)+2011+Alphawave+Research,+robjohnson@alphawaveresearch.com
%25+++++Released+under+GNU+GPLv3+--+see+file+COPYING+for+more+info.
%25
%25+++++Meanangle+is+free+software:+you+can+redistribute+it+and/or+modify
%25+++++it+under+the+terms+of+the+GNU+General+Public+License+as+published+by
%25+++++the+Free+Software+Foundation,+either+version+3+of+the+License,+or+(at
%25+++++your+option)+any+later+version.
%25
%25+++++Meanangle+is+distributed+in+the+hope+that+it+will+be+useful,+but
%25+++++WITHOUT+ANY+WARRANTY;+without+even+the+implied+warranty+of
%25+++++MERCHANTABILITY+or+FITNESS+FOR+A+PARTICULAR+PURPOSE.++See+the+GNU
%25+++++General+Public+License+for+more+details.
%25
%25+++++You+should+have+received+a+copy+of+the+GNU+General+Public+License
%25+++++along+with+this+program.++If+not,+see+`http://www.gnu.org/licenses/'.|code-block|syntax|javascript|1424758|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|13|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@$H|11|I|12|1|13]]|A|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|15|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|G]]]]

Like all averages, the answer depends upon the choice of metric. For a given metric M, the average of some angles a_k in [-pi,pi] for k in [1,N] is that angle a_M which minimizes the sum of squared distances d^2_M(a_M,a_k). For a weighted mean, one simply includes in the sum the weights w_k (such that sum_k w_k = 1). That is,

a_M = arg min_x sum_k w_k d^2_M(x,a_k)

Two common choices of metric are the Frobenius and the Riemann metrics. For the Frobenius metric, a direct formula exists that corresponds to the usual notion of average bearing in circular statistics. See "Means and Averaging in the Group of Rotations", Maher Moakher, SIAM Journal on Matrix Analysis and Applications, Volume 24, Issue 1, 2002, for details. 
<a href="http://link.aip.org/link/?SJMAEL/24/1/1" rel="nofollow">http://link.aip.org/link/?SJMAEL/24/1/1</a>

Here's a function for GNU Octave 3.2.4 that does the computation:

<pre><code>function ma=meanangleoct(a,w,hp,ntype)
% ma=meanangleoct(a,w,hp,ntype) returns the average of angles a
% given weights w and half-period hp using norm type ntype
% Ref: "Means and Averaging in the Group of Rotations",
% Maher Moakher, SIAM Journal on Matrix Analysis and Applications,
% Volume 24, Issue 1, 2002.

if (nargin&lt;1) | (nargin&gt;4), help meanangleoct, return, end 
if isempty(a), error('no measurement angles'), end
la=length(a); sa=size(a); 
if prod(sa)~=la, error('a must be a vector'); end
if (nargin&lt;4) || isempty(ntype), ntype='F'; end
if ~sum(ntype==['F' 'R']), error('ntype must be F or R'), end
if (nargin&lt;3) || isempty(hp), hp=pi; end
if (nargin&lt;2) || isempty(w), w=1/la+0*a; end
lw=length(w); sw=size(w); 
if prod(sw)~=lw, error('w must be a vector'); end
if lw~=la, error('length of w must equal length of a'), end
if sum(w)~=1, warning('resumming weights to unity'), w=w/sum(w); end

a=a(:); % make column vector
w=w(:); % make column vector
a=mod(a+hp,2*hp)-hp; % reduce to central period
a=a/hp*pi; % scale to half period pi
z=exp(i*a); % U(1) elements

% % NOTA BENE:
% % fminbnd can get hung up near the boundaries.
% % If that happens, shift the input angles a
% % forward by one half period, then shift the
% % resulting mean ma back by one half period.
% X=fminbnd(@meritfcn,-pi,pi,[],z,w,ntype);

% % seems to work better
x0=imag(log(sum(w.*z)));
X=fminbnd(@meritfcn,x0-pi,x0+pi,[],z,w,ntype);

% X=real(X); % truncate some roundoff
X=mod(X+pi,2*pi)-pi; % reduce to central period
ma=X*hp/pi; % scale to half period hp

return
%%%%%%

function d2=meritfcn(x,z,w,ntype)
x=exp(i*x);
if ntype=='F'
 y=x-z;
else % ntype=='R'
 y=log(x'*z);
end
d2=y'*diag(w)*y;
return
%%%%%%

% % test script
% % 
% % NOTA BENE: meanangleoct(a,[],[],'R') will equal mean(a) 
% % when all abs(a-b) &lt; pi/2 for some value b
% % 
% na=3, a=sort(mod(randn(1,na)+1,2)-1)*pi;
% da=diff([a a(1)+2*pi]); [mda,ndx]=min(da);
% a=circshift(a,[0 2-ndx]) % so that diff(a(2:3)) is smallest
% A=exp(i*a), B1=expm(a(1)*[0 -1; 1 0]), 
% B2=expm(a(2)*[0 -1; 1 0]), B3=expm(a(3)*[0 -1; 1 0]),
% masimpl=[angle(mean(exp(i*a))) mean(a)]
% Bsum=B1+B2+B3; BmeanF=Bsum/sqrt(det(Bsum)); 
% % this expression for BmeanR should be correct for ordering of a above
% BmeanR=B1*(B1'*B2*(B2'*B3)^(1/2))^(2/3);
% mamtrx=real([[0 1]*logm(BmeanF)*[1 0]' [0 1]*logm(BmeanR)*[1 0]'])
% manorm=[meanangleoct(a,[],[],'F') meanangleoct(a,[],[],'R')]
% polar(a,1+0*a,'b*'), axis square, hold on
% polar(manorm(1),1,'rs'), polar(manorm(2),1,'gd'), hold off

% Meanangleoct Version 1.0
% Copyright (C) 2011 Alphawave Research, robjohnson@alphawaveresearch.com
% Released under GNU GPLv3 -- see file COPYING for more info.
%
% Meanangle is free software: you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation, either version 3 of the License, or (at
% your option) any later version.
%
% Meanangle is distributed in the hope that it will be useful, but
% WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
% General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with this program. If not, see `http://www.gnu.org/licenses/'.
</code></pre>

blocks|key|1424811|text|没有唯一的“正确答案”。我推荐阅读K.V.MarDia和P.E.Jupp的书，“定向统计”(Wiley，1999)，以获得彻底的分析。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424812|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There's no single "right answer". I recommend reading the book,
K. V. Mardia and P. E. Jupp, "Directional Statistics", (Wiley, 1999),
for a thorough analysis.

blocks|key|1424857|text|(只想分享我的估计理论或统计推断的观点)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424858|Nimble的试验是获得一组角度的MMSE%5E估计，但它是寻找“平均”方向的选择之一；还可以找到MMAE%5E估计，或者其他一些估计是“平均”方向，这取决于方向的度量量化误差；或者更一般地，在估计理论中，代价函数的定义。|1424859|%5E+MMSE/MMAE对应于最小均方误差/绝对误差。|1424860|minimal...they说：“平均角度phi_avg应该有这样的性质:minimal...they_i%7Cφ_avg-φ_i%7C%5E2变成了平均的东西，而不是角度。”|1424861|-你用均方意义量化误差，这是最常见的方法之一，但不是唯一的方法。这里大多数人喜欢的答案(即单位向量之和并得到结果的角度)实际上是合理的解决方案之一。如果向量的方向被建模为von+Mise分布，它就是(可以证明)作为我们想要的“平均”方向的ML估计器。这个分布并不花哨，它只是一个二维高斯分布的周期性采样分布。参见Eqn。(2.179)在毕晓普的书“模式识别和机器学习”中。同样，它绝不是代表“平均”方向的唯一最好的方法，然而，它是相当合理的，既有很好的理论依据，也有简单的实现。|1424862|Nimble说："ackb是正确的，这些基于矢量的解决方案不能被认为是角度的真实平均值，它们只是单位矢量对应物的平均值。“|1424863|-这不是真的。“单位向量对应”揭示了向量的方向信息。角度是一个量，不考虑向量的长度，单位向量是带有附加信息的东西，长度为1。您可以将“单位”向量定义为长度为2，这并不重要。|1424864|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

(Just want to share my viewpoint from Estimation Theory or Statistical Inference)

Nimble's trial is to get the MMSE^ estimate of a set of angles, but it's one of choices to find an "averaged" direction; one can also find an MMAE^ estimate, or some other estimate to be the "averaged" direction, and it depends on your metric quantifying error of direction; or more generally in estimation theory, the definition of cost function.

^ MMSE/MMAE corresponds to minimum mean squared/absolute error.

ackb said "The average angle phi_avg should have the property that sum_i|phi_avg-phi_i|^2 becomes minimal...they average something, but not angles"

---- you quantify errors in mean-squared sense and it's one of the mostly common way, however, not the only way. The answer favored by most people here (i.e., sum of the unit vectors and get the angle of the result) is actually one of the reasonable solutions. It is (can be proved) the ML estimator that serves as the "averaged" direction we want, if the directions of the vectors are modeled as von Mises distribution. This distribution is not fancy, and is just a periodically sampled distribution from a 2D Guassian. See Eqn. (2.179) in Bishop's book "Pattern Recognition and Machine Learning". Again, by no means it's the only best one to represent "average" direction, however, it is quite reasonable one that have both good theoretical justification and simple implementation.

Nimble said "ackb is right that these vector based solutions cannot be considered true averages of angles, they are only an average of the unit vector counterparts"

----this is not true. The "unit vector counterparts" reveals the information of the direction of a vector. The angle is a quantity without considering the length of the vector, and the unit vector is something with additional information that the length is 1. You can define your "unit" vector to be of length 2, it does not really matter.

blocks|key|1424896|text|以下是完整的解决方案：(输入是以度数表示的方向角数组(0-360)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1424897|public+static+int+getAvarageBearing(int[]+arr)
{
++++double+sunSin+=+0;
++++double+sunCos+=+0;
++++int+counter+=+0;

++++for+(double+bearing+:+arr)
++++{
++++++++bearing+*=+Math.PI/180;

++++++++sunSin+%2B=+Math.sin(bearing);
++++++++sunCos+%2B=+Math.cos(bearing);
++++++++counter%2B%2B;+
++++}

++++int+avBearing+=+INVALID_ANGLE_VALUE;
++++if+(counter+>+0)
++++{
++++++++double+bearingInRad+=+Math.atan2(sunSin/counter,+sunCos/counter);
++++++++avBearing+=+(int)+(bearingInRad*180f/Math.PI);
++++++++if+(avBearing<0)
++++++++++++avBearing+%2B=+360;
++++}

++++return+avBearing;
}|code-block|syntax|javascript|1424898|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the full solution: 
(the input is an array of bearing in degrees (0-360) 

<pre><code>public static int getAvarageBearing(int[] arr)
{
 double sunSin = 0;
 double sunCos = 0;
 int counter = 0;

 for (double bearing : arr)
 {
 bearing *= Math.PI/180;

 sunSin += Math.sin(bearing);
 sunCos += Math.cos(bearing);
 counter++; 
 }

 int avBearing = INVALID_ANGLE_VALUE;
 if (counter &gt; 0)
 {
 double bearingInRad = Math.atan2(sunSin/counter, sunCos/counter);
 avBearing = (int) (bearingInRad*180f/Math.PI);
 if (avBearing&lt;0)
 avBearing += 360;
 }

 return avBearing;
}
</code></pre>

blocks|key|1639905|text|这是一个完整的C%2B%2B解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1639906|#include+<vector>
#include+<cmath>

double+dAngleAvg(const+vector<double>&+angles)+{
++++auto+avgSin+=+double{+0.0+};
++++auto+avgCos+=+double{+0.0+};
++++static+const+auto+conv++++++=+double{+0.01745329251994+};+//+PI+/+180
++++static+const+auto+i_conv++++=+double{+57.2957795130823+};+//+180+/+PI
++++for+(const+auto&+theta+:+angles)+{
++++++++avgSin+%2B=+sin(theta*conv);
++++++++avgCos+%2B=+cos(theta*conv);
++++}
++++avgSin+/=+(double)angles.size();
++++avgCos+/=+(double)angles.size();
++++auto+ret+=+double{+90.0+-+atan2(avgCos,+avgSin)+*+i_conv+};
++++if+(ret<0.0)+ret+%2B=+360.0;
++++return+fmod(ret,+360.0);
}|code-block|syntax|javascript|1639907|它以双精度向量的形式获取角度，并简单地以双精度返回平均值。角度必须以度为单位，当然平均值也是以度为单位。|1639908|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's a complete C++ solution:

<pre><code>#include &lt;vector&gt;
#include &lt;cmath&gt;

double dAngleAvg(const vector&lt;double&gt;&amp; angles) {
 auto avgSin = double{ 0.0 };
 auto avgCos = double{ 0.0 };
 static const auto conv = double{ 0.01745329251994 }; // PI / 180
 static const auto i_conv = double{ 57.2957795130823 }; // 180 / PI
 for (const auto&amp; theta : angles) {
 avgSin += sin(theta*conv);
 avgCos += cos(theta*conv);
 }
 avgSin /= (double)angles.size();
 avgCos /= (double)angles.size();
 auto ret = double{ 90.0 - atan2(avgCos, avgSin) * i_conv };
 if (ret&lt;0.0) ret += 360.0;
 return fmod(ret, 360.0);
}
</code></pre>

It takes the angles in the form of a vector of doubles, and returns the average simply as a double. The angles must be in degrees, and of course the average is in degrees as well.

blocks|key|1425015|text|Python函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1425016|from+math+import+sin,cos,atan2,pi
import+numpy+as+np
def+meanangle(angles,weights=0,setting='degrees'):
++++'''computes+the+mean+angle'''
++++if+weights==0:
+++++++++weights=np.ones(len(angles))
++++sumsin=0
++++sumcos=0
++++if+setting=='degrees':
++++++++angles=np.array(angles)*pi/180
++++for+i+in+range(len(angles)):
++++++++sumsin%2B=weights[i]/sum(weights)*sin(angles[i])
++++++++sumcos%2B=weights[i]/sum(weights)*cos(angles[i])
++++average=atan2(sumsin,sumcos)
++++if+setting=='degrees':
++++++++average=average*180/pi
++++return+average|code-block|syntax|javascript|1425017|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Python function:

<pre><code>from math import sin,cos,atan2,pi
import numpy as np
def meanangle(angles,weights=0,setting='degrees'):
 '''computes the mean angle'''
 if weights==0:
 weights=np.ones(len(angles))
 sumsin=0
 sumcos=0
 if setting=='degrees':
 angles=np.array(angles)*pi/180
 for i in range(len(angles)):
 sumsin+=weights[i]/sum(weights)*sin(angles[i])
 sumcos+=weights[i]/sum(weights)*cos(angles[i])
 average=atan2(sumsin,sumcos)
 if setting=='degrees':
 average=average*180/pi
 return average
</code></pre>

blocks|key|1425048|text|您可以在Matlab中使用此函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1425049|function+retVal=DegreeAngleMean(x)+

len=length(x);

sum1=0;+
sum2=0;+

count1=0;
count2=0;+

for+i=1:len+
+++if+x(i)<180+
+++++++sum1=sum1%2Bx(i);+
+++++++count1=count1%2B1;+
+++else+
+++++++sum2=sum2%2Bx(i);+
+++++++count2=count2%2B1;+
+++end+
end+

if+(count1>0)+
+++++k1=sum1/count1;+
end+

if+(count2>0)+
+++++k2=sum2/count2;+
end+

if+count1>0+&&+count2>0+
+++if(k2-k1+>=+180)+
+++++++retVal+=+((sum1%2Bsum2)-count2*360)/len;+
+++else+
+++++++retVal+=+(sum1%2Bsum2)/len;+
+++end+
elseif+count1>0+
++++retVal+=+k1;+
else+
++++retVal+=+k2;+
end+|code-block|syntax|javascript|1425050|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use this function in Matlab:

<pre><code>function retVal=DegreeAngleMean(x) 

len=length(x);

sum1=0; 
sum2=0; 

count1=0;
count2=0; 

for i=1:len 
 if x(i)&lt;180 
 sum1=sum1+x(i); 
 count1=count1+1; 
 else 
 sum2=sum2+x(i); 
 count2=count2+1; 
 end 
end 

if (count1&gt;0) 
 k1=sum1/count1; 
end 

if (count2&gt;0) 
 k2=sum2/count2; 
end 

if count1&gt;0 &amp;&amp; count2&gt;0 
 if(k2-k1 &gt;= 180) 
 retVal = ((sum1+sum2)-count2*360)/len; 
 else 
 retVal = (sum1+sum2)/len; 
 end 
elseif count1&gt;0 
 retVal = k1; 
else 
 retVal = k2; 
end 
</code></pre>

blocks|key|1640156|text|虽然starblue的答案给出了平均单位向量的角度，但如果您接受在0到2*pi+(或0°到360°)的范围内可能有多个答案，则可以将算术平均值的概念扩展到角度。例如，0°和180°的平均值可以是90°或270°。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1640157|算术平均值具有与输入值的平方距离之和最小的单个值的属性。两个单位向量之间沿单位圆的距离可以很容易地计算为它们的点积的反余弦。如果我们通过最小化我们的向量和每个输入单位向量的点积的平方反余弦之和来选择一个单位向量，那么我们就有了一个等价的平均值。同样，请记住，在特殊情况下可能会有两个或更多的最小值。|1640158|这个概念可以扩展到任意多个维度，因为单位球面上的距离可以用与单位圆上的距离完全相同的方式来计算--两个单位向量的点积的反余弦。|1640159|对于圆，我们可以用许多方法来求解这个平均值，但我提出了以下O(n%5E2)算法(角度以弧度表示，我避免计算单位向量)：|1640160|var+bestAverage+=+-1
double+minimumSquareDistance
for+each+a1+in+input
++++var+sumA+=+0;
++++for+each+a2+in+input
++++++++var+a+=+(a2+-+a1)+mod+(2*pi)+%2B+a1
++++++++sumA+%2B=+a
++++end+for
++++var+averageHere+=+sumA+/+input.count
++++var+sumSqDistHere+=+0
++++for+each+a2+in+input
++++++++var+dist+=+(a2+-+averageHere+%2B+pi)+mod+(2*pi)+-+pi+//+keep+within+range+of+-pi+to+pi
++++++++sumSqDistHere+%2B=+dist+*+dist
++++end+for
++++if+(bestAverage+<+0+OR+sumSqDistHere+<+minimumSquareDistance)+//+for+exceptional+cases,+sumSqDistHere+may+be+equal+to+minimumSquareDistance+at+least+once.+In+these+cases+we+will+only+find+one+of+the+averages
++++++++minimumSquareDistance+=+sumSqDistHere
++++++++bestAverage+=+averageHere
++++end+if
end+for
return+bestAverage|code-block|syntax|javascript|1640161|如果所有的角度都在180°以内，那么我们可以使用一个更简单的O(N)%2BO(排序)算法(同样使用弧度，避免使用单位向量)：|1640162|sort(input)
var+largestGapEnd+=+input[0]
var+largestGapSize+=+(input[0]+-+input[input.count-1])+mod+(2*pi)
for+(int+i+=+1;+i+<+input.count;+%2B%2Bi)
++++var+gapSize+=+(input[i]+-+input[i+-+1])+mod+(2*pi)
++++if+(largestGapEnd+<+0+OR+gapSize+>+largestGapSize)
++++++++largestGapSize+=+gapSize
++++++++largestGapEnd+=+input[i]
++++end+if
end+for
double+sum+=+0
for+each+angle+in+input
++++var+a2+=+(angle+-+largestGapEnd)+mod+(2*pi)+%2B+largestGapEnd
++++sum+%2B=+a2
end+for
return+sum+/+input.count|1640163|要使用度，只需将pi替换为180。如果你计划使用更多的维度，那么你很可能不得不使用迭代方法来求解平均值。|1640164|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

While starblue's answer gives the angle of the average unit vector, it is possible to extend the concept of the arithmetic mean to angles if you accept that there may be more than one answer in the range of 0 to 2*pi (or 0° to 360°). For example, the average of 0° and 180° may be either 90° or 270°.

The arithmetic mean has the property of being the single value with the minimum sum of squared distances to the input values. The distance along the unit circle between two unit vectors can be easily calculated as the inverse cosine of their dot product. If we choose a unit vector by minimizing the sum of the squared inverse cosine of the dot product of our vector and each input unit vector then we have an equivalent average. Again, keep in mind that there may be two or more minimums in exceptional cases.

This concept could be extended to any number of dimensions, since the distance along the unit sphere can be calculated in the exact same way as the distance along the unit circle--the inverse cosine of the dot product of two unit vectors.

For circles we could solve for this average in a number of ways, but I propose the following O(n^2) algorithm (angles are in radians, and I avoid calculating the unit vectors):

<pre><code>var bestAverage = -1
double minimumSquareDistance
for each a1 in input
 var sumA = 0;
 for each a2 in input
 var a = (a2 - a1) mod (2*pi) + a1
 sumA += a
 end for
 var averageHere = sumA / input.count
 var sumSqDistHere = 0
 for each a2 in input
 var dist = (a2 - averageHere + pi) mod (2*pi) - pi // keep within range of -pi to pi
 sumSqDistHere += dist * dist
 end for
 if (bestAverage &lt; 0 OR sumSqDistHere &lt; minimumSquareDistance) // for exceptional cases, sumSqDistHere may be equal to minimumSquareDistance at least once. In these cases we will only find one of the averages
 minimumSquareDistance = sumSqDistHere
 bestAverage = averageHere
 end if
end for
return bestAverage
</code></pre>

If all the angles are within 180° of each other, then we could use a simpler O(n)+O(sort) algorithm (again using radians and avoiding use of unit vectors):

<pre><code>sort(input)
var largestGapEnd = input[0]
var largestGapSize = (input[0] - input[input.count-1]) mod (2*pi)
for (int i = 1; i &lt; input.count; ++i)
 var gapSize = (input[i] - input[i - 1]) mod (2*pi)
 if (largestGapEnd &lt; 0 OR gapSize &gt; largestGapSize)
 largestGapSize = gapSize
 largestGapEnd = input[i]
 end if
end for
double sum = 0
for each angle in input
 var a2 = (angle - largestGapEnd) mod (2*pi) + largestGapEnd
 sum += a2
end for
return sum / input.count
</code></pre>

To use degrees, simply replace pi with 180. If you plan to use more dimensions then you will most likely have to use an iterative method to solve for the average.

blocks|key|1640218|text|这里是一个完全算术的解决方案，使用移动平均值并注意规格化值。如果所有角度都在圆的一侧(彼此之间在180°以内)，则它是快速的，并提供正确的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1640219|它在数学上相当于添加将值移入范围(0,180)的偏移量，计算平均值，然后减去偏移量。|1640220|注释描述了特定值在任何给定时间可以呈现的范围|1640221|//+angles+have+to+be+in+the+range+[0,+360)+and+within+180°+of+each+other.
//+n+>=+1
//+returns+the+circular+average+of+the+angles+int+the+range+[0,+360).
double+meanAngle(double*+angles,+int+n)
{
++++double+average+=+angles[0];
++++for+(int+i+=+1;+i<n;+i%2B%2B)
++++{
++++++++//+average:+(0,+360)
++++++++double+diff+=+angles[i]-average;
++++++++//+diff:+(-540,+540)

++++++++if+(diff+<+-180)
++++++++++++diff+%2B=+360;
++++++++else+if+(diff+>=+180)
++++++++++++diff+-=+360;
++++++++//+diff:+(-180,+180)

++++++++average+%2B=+diff/(i%2B1);
++++++++//+average:+(-180,+540)

++++++++if+(average+<+0)
++++++++++++average+%2B=+360;
++++++++else+if+(average+>=+360)
++++++++++++average+-=+360;
++++++++//+average:+(0,+360)
++++}
++++return+average;
}|code-block|syntax|javascript|1640222|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is a completely arithmetic solution using moving averages and taking care to normalize values. It is fast and delivers correct answers if all angles are on one side of the circle (within 180° of each other).

It is mathimatically equivalent to adding the offset which shifts the values into the range (0, 180), calulating the mean and then subtracting the offset.

The comments describe what range a specific value can take on at any given time

<pre class="lang-cpp prettyprint-override"><code>// angles have to be in the range [0, 360) and within 180° of each other.
// n &gt;= 1
// returns the circular average of the angles int the range [0, 360).
double meanAngle(double* angles, int n)
{
 double average = angles[0];
 for (int i = 1; i&lt;n; i++)
 {
 // average: (0, 360)
 double diff = angles[i]-average;
 // diff: (-540, 540)

 if (diff &lt; -180)
 diff += 360;
 else if (diff &gt;= 180)
 diff -= 360;
 // diff: (-180, 180)

 average += diff/(i+1);
 // average: (-180, 540)

 if (average &lt; 0)
 average += 360;
 else if (average &gt;= 360)
 average -= 360;
 // average: (0, 360)
 }
 return average;
}
</code></pre>

blocks|key|1640278|text|这个问题非常简单。1.确保所有角度都在-180度到180度之间。2.+a将所有非负角相加，取其平均值，并计算其数量。2.+b.Add所有负角，取其平均值，并计算其数量。3.取pos_average减去neg_average的差值如果差值大于180，则将差值更改为360减去差值。否则，只需更改差值符号即可。请注意，差异始终是非负的。Average_Angle等于pos_average加上差值乘以“权重”，负数除以负数和正数之和|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1640279|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The problem is extremely simple.
1. Make sure all angles are between -180 and 180 degrees.
2. a Add all non-negative angles, take their average, and COUNT how many
2. b.Add all negative angles, take their average and COUNT how many.
3. Take the difference of pos_average minus neg_average
 If difference is greater than 180 then change difference to 360 minus difference. Otherwise just change the sign of difference. Note that difference is always non-negative.
The Average_Angle equals the pos_average plus difference times the "weight", negative count divided by the sum of negative and positive count

blocks|key|1425351|text|这里有一些平均角度的java代码，我认为它相当健壮。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1425352|public+static+double+getAverageAngle(List<Double>+angles)
{
++++//+r+=+right+(0+to+180+degrees)

++++//+l+=+left+(180+to+360+degrees)

++++double+rTotal+=+0;
++++double+lTotal+=+0;
++++double+rCtr+=+0;
++++double+lCtr+=+0;

++++for+(Double+angle+:+angles)
++++{
++++++++double+norm+=+normalize(angle);
++++++++if+(norm+>=+180)
++++++++{
++++++++++++lTotal+%2B=+norm;
++++++++++++lCtr%2B%2B;
++++++++}+else
++++++++{
++++++++++++rTotal+%2B=+norm;
++++++++++++rCtr%2B%2B;
++++++++}
++++}

++++double+rAvg+=+rTotal+/+Math.max(rCtr,+1.0);
++++double+lAvg+=+lTotal+/+Math.max(lCtr,+1.0);

++++if+(rAvg+>+lAvg+%2B+180)
++++{
++++++++lAvg+%2B=+360;
++++}
++++if+(lAvg+>+rAvg+%2B+180)
++++{
++++++++rAvg+%2B=+360;
++++}

++++double+rPortion+=+rAvg+*+(rCtr+/+(rCtr+%2B+lCtr));
++++double+lPortion+=+lAvg+*+(lCtr+/+(lCtr+%2B+rCtr));
++++return+normalize(rPortion+%2B+lPortion);
}

public+static+double+normalize(double+angle)
{
++++double+result+=+angle;
++++if+(angle+>=+360)
++++{
++++++++result+=+angle+%25+360;
++++}
++++if+(angle+<+0)
++++{
++++++++result+=+360+%2B+(angle+%25+360);
++++}
++++return+result;
}|code-block|syntax|javascript|1425353|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is some java code to average angles, I think it's reasonably robust.

<pre><code>public static double getAverageAngle(List&lt;Double&gt; angles)
{
 // r = right (0 to 180 degrees)

 // l = left (180 to 360 degrees)

 double rTotal = 0;
 double lTotal = 0;
 double rCtr = 0;
 double lCtr = 0;

 for (Double angle : angles)
 {
 double norm = normalize(angle);
 if (norm &gt;= 180)
 {
 lTotal += norm;
 lCtr++;
 } else
 {
 rTotal += norm;
 rCtr++;
 }
 }

 double rAvg = rTotal / Math.max(rCtr, 1.0);
 double lAvg = lTotal / Math.max(lCtr, 1.0);

 if (rAvg &gt; lAvg + 180)
 {
 lAvg += 360;
 }
 if (lAvg &gt; rAvg + 180)
 {
 rAvg += 360;
 }

 double rPortion = rAvg * (rCtr / (rCtr + lCtr));
 double lPortion = lAvg * (lCtr / (lCtr + rCtr));
 return normalize(rPortion + lPortion);
}

public static double normalize(double angle)
{
 double result = angle;
 if (angle &gt;= 360)
 {
 result = angle % 360;
 }
 if (angle &lt; 0)
 {
 result = 360 + (angle % 360);
 }
 return result;
}
</code></pre>

I want to calculate the average of a set of circular data. For example, I might have several samples from the reading of a compass. The problem of course is how to deal with the wraparound. The same algorithm might be useful for a clockface.

The actual question is more complicated - what do statistics mean on a sphere or in an algebraic space which "wraps around", e.g. the additive group mod n. The answer may not be unique, e.g. the average of 359 degrees and 1 degree could be 0 degrees or 180, but statistically 0 looks better.

This is a real programming problem for me and I'm trying to make it not look like just a Math problem.

How do you calculate the average of a set of circular data?

机器学习

Python

Java

我想计算一组循环数据的平均值。例如，我可能有几个指南针读数的样本。问题当然是如何处理环绕式。同样的算法可能对钟面也很有用。实际的问题更复杂--在球面上或在一个“环绕”的代数空间中，统计意味着什么，例如，加法群mod n。答案可能不是唯一的，例如，359度和1度的平均值可能是0度或180度，但统计上看0看起来更好。这对我...

问如何计算一组循环数据的平均值？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算一组循环数据的平均值？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算一组循环数据的平均值？
EN