Averages/Mean angle: Difference between revisions

{{task}}

When calculating the [[wp:Mean of circular quantities|average or mean of an angle]] one has to take into account how angles wrap around so that any angle in degrees plus any integer multiple of 360 degrees is a measure of the same angle.

 

# Convert the complex mean to polar coordinates whereupon the phase of the complex mean is the required angular mean.

 

(Note that, since the mean is the sum divided by the number of numbers, and division by a positive real number does not affect the angle, you can also simply compute the sum for step 2.)

 

You can alternatively use this formula:

 

 

 

 

 

=={{header|Ada}}==

An implementation based on the formula using the "Arctan" (atan2) function, thus avoiding complex numbers:

 

procedure Mean_Angles is

Put(Mean_Angle((10.0, 350.0))); Ada.Text_IO.New_Line; -- 0.00

Put(Mean_Angle((90.0, 180.0, 270.0, 360.0))); -- Ada.Numerics.Argument_Error!

{{out}}

<pre> 20.00

 

raised ADA.NUMERICS.ARGUMENT_ERROR : a-ngelfu.adb:427 instantiated at mean_angles.adb:17</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

MsgBox, % MeanAngle(Angles[1]) "`n"

. MeanAngle(Angles[2]) "`n"

atan2(x, y) {

return dllcall("msvcrt\atan2", "Double",y, "Double",x, "CDECL Double")

'''Output:'''

<pre>-0.000000

 

=={{header|AWK}}==

{

PI = atan2(0,-1);

if (p<0) p += 360;

print p;

<pre> echo 350 10 | ./mean_angle.awk

360

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

DIM angles(3)

angles() = 350,10

DEF FNatan2(y,x) : ON ERROR LOCAL = SGN(y)*PI/2

{{out}}

<pre>

 

=={{header|C}}==

#include<stdio.h>

 

printf ("\nMean Angle for 3rd set : %lf degrees\n", meanAngle (angleSet3, 3));

return 0;

{{out}}

<pre>Mean Angle for 1st set : -0.000000 degrees

Mean Angle for 2nd set : -90.000000 degrees

Mean Angle for 3rd set : 20.000000 degrees</pre>

 

=={{header|Common Lisp}}==

(/ (reduce #'+ list) (length list)))

 

 

(defun degrees (angle)

 

(defun mean-angle (angles)

 

(loop for angles in '((350 10) (90 180 270 360) (10 20 30))

{{out}}

<pre>The mean angle of (350 10) is -0.00°.

 

=={{header|D}}==

import std.math: PI;

 

writefln("The mean angle of %s is: %.2f degrees",

angles, angles.meanAngle);

{{out}}

<pre>The mean angle of [350, 10] is: -0.00 degrees

The mean angle of [90, 180, 270, 360] is: 90.00 degrees

The mean angle of [10, 20, 30] is: 20.00 degrees</pre>

 

=={{header|Erlang}}==

The function from_degrees/1 is used to solve [[Averages/Mean_time_of_day]]. Please keep backwards compatibility when editing. Or update the other module, too.

-module( mean_angle ).

-export( [from_degrees/1, task/0] ).

 

radians( Degrees ) -> Degrees * math:pi() / 180.

{{out}}

<pre>

 

=={{header|Euler Math Toolbox}}==

$ z=sum(exp(rad(a)*I));

$ if z~=0 then error("Not meaningful");

if z~=0 then error("Not meaningful");

>meanangle([10,20,30])

 

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

include std/console.e

include std/mathcons.e

 

if getc(0) then end if

{{out}}

<pre>

Mean Angle for set 2: -90.00000

Mean Angle for set 3: 20.00000

</pre>

 

=={{header|Fortran}}==

Please find the example output along with the build instructions in the comments at the start of the FORTRAN 2008 source. Compiler: gfortran from the GNU compiler collection. Command interpreter: bash.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Mon Jun 3 18:07:59

end do

end program average_angles

 

=={{header|Go}}==

===Complex===

 

import (

fmt.Printf("The mean angle of %v is: %f degrees\n", angles, mean_angle(angles))

}

{{out}}

<pre>

A mean_angle function that could be substituted above. Functions deg2rad and rad2deg are not used here but there is no runtime advantage either way to using them or not. Inlining should result in eqivalent code being generated. Also the Go Atan2 library function has no limits on the arguments so there is no need to divide by the number of elements.

 

var ss, sc float64

for _, x := range deg {

}

return math.Atan2(ss, sc) * 180 / math.Pi

 

=={{header|Groovy}}==

def meanAngle = {

atan2( it.sum { sin(it * PI / 180) } / it.size(), it.sum { cos(it * PI / 180) } / it.size()) * 180 / PI

Test:

def ma = meanAngle(angles)

printf("Mean Angle for $angles: %5.2f%n", ma)

assert verifyAngle([350, 10]) == -0

assert verifyAngle([90, 180, 270, 360]) == -90

{{out}}

<pre>Mean Angle for [350, 10]: -0.00

 

=={{header|Haskell}}==

 

meanAngle = (/ pi) . (* 180) . phase . sum . map (cis . (/ 180) . (* pi))

 

{{out}}

<pre>

Alternative Solution: This solution gives an insight about using factoring, many small functions like Forth and using function composition.

 

 

-- file: trigdeg.fs

 

-- End of trigdeg.fs --------

 

{{out}}

=={{header|Icon}} and {{header|Unicon}}==

 

write("Mean angle is ",meanAngle(A))

end

every (sumCosines := 0.0) +:= cos(dtor(!A))

return rtod(atan(sumSines/*A,sumCosines/*A))

 

Sample runs:

->ama 10 20 30

Mean angle is 20.0

</pre>

 

=={{header|J}}==

toComplex=: *.inv NB. maps integer pairs as length, complex angle (in radians)

mean=: +/ % # NB. calculate arithmetic mean

roundComplex=: (* * |)&.+. NB. discard an extraneous least significant bit of precision from a complex value whose magnitude is in the vicinity of 1

avgAngleR=: _1 { [: roundComplex@mean&.toComplex 1 ,. ] NB. calculate average angle in radians

Example use:

0

avgAngleD 90 180 270 360 NB. result not meaningful

0

avgAngleD 10 20 30

 

Notes:

 

<code>verb&.(1r180p1&*)</code> converts its argument from degrees to radians, uses the verb in the radian domain, then converts the result of that argument back to degrees.

 

=={{header|Java}}==

{{trans|NetRexx}}

{{works with|Java|7+}}

 

 

 

}

 

 

}

{{out}}

 

=={{header|JavaScript}}==

===atan2===

return s;

}

 

function degToRad(a) {

}

 

function meanAngleDeg(a) {

}

 

console.log(meanAngleDeg(a));

console.log(meanAngleDeg(b));

{{out}}

<pre>-1.614809932057922e-15

 

'''Generic Infrastructure'''

 

def deg2rad: . * pi / 180;

def abs: if . < 0 then - . else . end;

 

'''Mean Angle'''

def mean_angle:

def round:

| .[1]

| rad2deg

'''Examples'''

 

{{out}}

The mean angle of [350,10] is: 0

The mean angle of [90,180,270,360] is: null

 

=={{header|Julia}}==

Julia has built-in functions <code>sind</code> and <code>cosd</code> to compute the sine and cosine of angles specified in degrees accurately (avoiding the roundoff errors incurred in conversion to radians), and a built-in function to convert radians to degrees (or vice versa). Using these:

The output is:

0.0

 

 

julia> meandegrees([10, 20, 30]])

(Note that the mean of 90°, 180°, 270°, and 360° gives zero because of the lack of roundoff errors in the <code>sind</code> function, since the standard-library <code>atan2(0,0)</code> value is zero. Many of the other languages report an average of 90° or –90° in this case due to rounding errors.)

 

=={{header|Liberty BASIC}}==

Pi =3.1415926535

 

if y =0 and x =0 then notice "undefined": end

atan2 =at

{{out}}

<pre>

Mean Angle( "10,20,30") = 20.0 degrees.

</pre>

=={{header|Logo}}==

local "avgsin

make "avgsin quotient apply "sum map "sin :angles count :angles

 

bye

 

{{Out}}

The average of ( 90 180 270 360 ) is 0

The average of ( 10 20 30 ) is 20</pre>

 

=={{header|Maple}}==

The following procedure takes a list of numeric degrees (with attached units) such as

as input. (We could use "degree" instead of "arcdeg", since "degree" is taken, by default, to mean angle measure, but it seems best to avoid the ambiguity.)

uses Units:-Standard; # for unit-awareness

local u;

evalf( convert( argument( add( u, u = exp~( I *~ L ) ) ), 'units', 'radian', 'degree' ) )

Applying this to the given data sets, we obtain:

0.

 

 

> MeanAngle( [ 10, 20, 30 ] *~ Unit(arcdeg) );

 

{{out}}

<pre>meanAngle /@ {{350, 10}, {90, 180, 270, 360}, {10, 20, 30}}

 

=={{header|MATLAB}} / {{header|Octave}}==

u = angle(mean(exp(i*pi*phi/180)))*180/pi;

<pre> mean_angle([350, 10])

ans = -2.7452e-14

mean_angle([10, 20, 30])

ans = 20.000

</pre>

 

=={{header|NetRexx}}==

{{trans|C}}

options replace format comments java crossref symbols nobinary

numeric digits 80

end angles

return

{{out}}

<pre>

 

=={{header|Nim}}==

for d in deg:

echo "The 1st mean angle is: ", meanAngle([350.0, 10.0]), " degrees"

echo "The 2nd mean angle is: ", meanAngle([90.0, 180.0, 270.0, 360.0]), " degrees"

Output:

The 2nd mean angle is: -90.0 degrees

The 3rd mean angle is: 20.0 degrees</pre>

 

=={{header|OCaml}}==

 

let deg2rad d =

test [90.0; 180.0; 270.0; 360.0];

test [10.0; 20.0; 30.0];

or using the <code>Complex</code> module:

 

let mean_angle angles =

List.fold_left (fun sum a -> add sum (polar 1.0 (deg2rad a))) zero angles

in

{{out}}

<pre>

=={{header|ooRexx}}==

{{trans|REXX}}

numeric digits 50 /*use fifty digits of precision, */

showDig=10 /*··· but only display 10 digits.*/

return left('angles='a,30) 'mean angle=' format(mA,,showDig,0)/1

 

{{out}}

<pre>angles=350 10 mean angle= 0

angles=90 180 270 360 mean angle= 0

=={{header|PARI/GP}}==

meanDegrees(v)=meanAngle(v*Pi/180)*180/Pi

{{out}}

<pre>[360.000000, 296.565051, 20.0000000]</pre>

=={{header|Pascal}}==

uses library math for sincos, a function of FPU80x87, atan2 and DegToRad.

Tested with free pascal.

Try to catch very small cos values and set to 0.0 degrees " Error : Not meaningful" as http://rosettacode.org/wiki/Averages/Mean_angle#Euler_Math_Toolbox complains.

{$IFDEF DELPHI}

{$APPTYPE CONSOLE}

 

setlength(a,0);

;output:

<pre>

 

=={{header|Perl}}==

 

sub meanangle {

 

print "The mean angle of [@$_] is: ", meandegrees(@$_), " degrees\n"

{{out}}

<pre>

</pre>

 

{{out}}

 

=={{header|PHP}}==

{{trans|C}}

$samples = array(

'1st' => array(350, 10),

return rad2deg(atan2($y_part, $x_part));

}

{{out}}

<pre>Mean angle for 1st sample: -1.6148099320579E-15 degrees.

 

=={{header|PicoLisp}}==

 

(de meanAngle (Lst)

"The mean angle of ["

(glue ", " (mapcar round L '(0 .)))

{{out}}

<pre>The mean angle of [350, 10] is: 0.000

 

=={{header|PL/I}}==

declare b1(2) fixed initial (350, 10);

declare b2(4) fixed initial (90, 180, 270, 360);

end mean;

 

Results (the final one brings up an error in inverse tangent):

<pre>

At offset +000009CC in procedure with entry AVERAGES

</pre>

 

=={{header|Python}}==

{{works with|Python|2.6+}}

>>> from math import radians, degrees

>>> def mean_angle(deg):

The mean angle of [90, 180, 270, 360] is: -90.0 degrees

The mean angle of [10, 20, 30] is: 20.0 degrees

 

=={{header|Racket}}==

The formula given above can be straightforwardly transcribed into a program:

#lang racket

 

(mean-angle '(90 180 270 360))

(mean-angle '(10 20 30))

{{out}}

<pre>

19.999999999999996

</pre>

 

=={{header|REXX}}==

 

 

and other combinations.

 

 

 

.sinCos: arg z,_,i; x=x*x; do k=2 by 2 until p=z; p=z; _=-_*x/(k*(k+i)); z=z+_; end; return z

$fuzz: return min(arg(1), max(1, digits() - arg(2) ) )

d2d: return arg(1) // 360

r2r: return arg(1) // (pi() * 2)

pi: pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862;return pi

select

<pre>

</pre>

 

=={{header|Ruby}}==

 

def deg2rad(d)

[[350, 10], [90, 180, 270, 360], [10, 20, 30]].each {|angles|

puts "The mean angle of %p is: %f degrees" % [angles, mean_angle(angles)]

{{out}}

<pre>

The mean angle of [10, 20, 30] is: 20.000000 degrees

</pre>

 

=={{header|Scala}}==

import scala.math.{Pi, atan2, cos, sin}

 

assert(meanAngle(List(10, 20, 30)).round == 20, "Unexpected result with 10, 20, 30")

println("Successfully completed without errors.")

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

writeln(meanAngle([] (90.0, 180.0, 270.0, 360.0)) digits 4);

writeln(meanAngle([] (10.0, 20.0, 30.0)) digits 4);

0.0000

90.0000

 

=={{header|Sidef}}==

}

 

[[350,10], [90,180,270,360], [10,20,30]].each { |angles|

{{out}}

<pre>

The mean angle of [350, 10] is: 0.00 degrees

The mean angle of [10, 20, 30] is: 20.00 degrees

</pre>

 

=={{header|Tcl}}==

set toRadians [expr {atan2(0,-1) / 180}]

set sumSin [set sumCos 0.0]

# Don't need to divide by counts; atan2() cancels that out

return [expr {atan2($sumSin, $sumCos) / $toRadians}]

Demonstration code:

proc printMeanAngle {angles} {

puts [format "mean angle of \[%s\] = %.2f" \

printMeanAngle {350 10}

printMeanAngle {90 180 270 360}

{{out}}

<pre>

mean angle of [90, 180, 270, 360] = -90.00

mean angle of [10, 20, 30] = 20.00

</pre>

 

=={{header|XPL0}}==

 

def Pi = 3.14159265358979323846;

RlOut(0, MeanAng([4, 90, 180, 270, 360])); CrLf(0);

RlOut(0, MeanAng([3, 10, 20, 30])); CrLf(0);

{{out}}

<pre>

 

=={{header|zkl}}==

n:=as.len();

(as.apply("sin").sum(0.0)/n)

{{out}}

<pre>