Averages/Mean angle: Difference between revisions

{{task}}

 

::<math>\bar{\alpha} = \operatorname{atan2}\left(\frac{1}{n}\cdot\sum_{j=1}^n \sin\alpha_j, \frac{1}{n}\cdot\sum_{j=1}^n \cos\alpha_j\right) </math>

 

 

# write a function/method/subroutine/... that given a list of angles in degrees returns their mean angle. <br> (You should use a built-in function if you have one that does this for degrees or radians).

 

<br><hr>

 

=={{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|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

{{trans|C|Note: This specimen retains the original [[#C|C]] coding style}}

# -*- coding: utf-8 -*- #

 

printf ((summary fmt,"2nd", mean angle (angle set 2)));

printf ((summary fmt,"3rd", mean angle (angle set 3)))

<pre>

Mean angle for 1st set : -0.00000 degrees

Mean angle for 3rd set : 20.00000 degrees

</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>

-90

20

</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

 

=={{header|C sharp|C#}}==

using System.Linq;

using static System.Math;

printMean(new double[] { 10, 20, 30 });

}

{{out}}

<pre>0

-90

20</pre>

 

=={{header|Clojure}}==

[k coll]

(let [n (count coll)

a (mean-fn :sin radians)

b (mean-fn :cos radians)]

Example:

;=> -1.614809932057922E-15

 

 

(mean-angle [10 20 30])

 

=={{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|EchoLisp}}==

(define-syntax-rule (deg->radian deg) (* deg 1/180 PI))

(define-syntax-rule (radian->deg rad) (* 180 (/ PI) rad))

(mean-angles '[10 20 30])

→ 20

 

=={{header|Elixir}}==

defmodule MeanAngle do

def mean_angle(angles) do

IO.inspect MeanAngle.mean_angle([90, 180, 270, 360])

IO.inspect MeanAngle.mean_angle([10, 20, 30])

{{out}}

<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>

 

=={{header|F_Sharp|F#}}==

open System.Numerics

 

|> fun c -> c.Phase |> rad2deg

|> printfn "Mean angle for [%s]: %g°" (String.Join("; ",argv))

{{out}}

<pre>>RosettaCode 350 10

>RosettaCode 90 180 270 360

Mean angle for [90; 180; 270; 360]: -90°

</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|FreeBASIC}}==

' FB 1.05.0 Win64

 

Print "Press any key to quit the program"

Sleep

 

{{out}}

=={{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

"The mean angle of " ++

show angles ++ " is: " ++ show (meanAngle angles) ++ " degrees")

{{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}}==

This verb can be represented as simpler component verbs, for example:

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

5

avgAngleD 10 340

 

Notes:

{{trans|NetRexx}}

{{works with|Java|7+}}

 

public class AverageMeanAngle {

return Math.toDegrees(avgR);

}

{{out}}

<pre>The mean angle of [350.0, 10.0] is -1.614809932057922E-15

=={{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|Kotlin}}==

 

fun meanAngle(angles: DoubleArray): Double {

println("Mean for angles 2 is ${fmt.format(meanAngle(angles2))}")

println("Mean for angles 3 is ${fmt.format(meanAngle(angles3))}")

 

{{out}}

 

=={{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}}

{{trans|Tcl}}

{{works with|Lua|5.1}}

local sumSin, sumCos = 0, 0

for i, angle in pairs(angleList) do

print(meanAngle({350, 10}))

print(meanAngle({90, 180, 270, 360}))

{{out}}

<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) );

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{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}}==

proc meanAngle(deg: openArray[float]): float =

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|Oberon-2}}==

{{works with|oo2c}}

MODULE MeanAngle;

IMPORT

Out.LongRealFix(Mean(grades) * toDegs,15,9);Out.Ln;

END MeanAngle.

{{out}}

<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>

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

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

{90,180,270,360}: Mean Angle is not meaningful

{0,180}: Mean Angle is not meaningful

</pre>

=={{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>

 

=={{header|PowerShell}}==

function Get-MeanAngle ([double[]]$Angles)

{

[Math]::Atan2($y, $x) * 180 / [Math]::PI

}

 

@(350, 10), @(90, 180, 270, 360), @(10, 20, 30) | ForEach-Object {Get-MeanAngle $_}

 

{{Out}}

20

</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}}==

 

<pre>

is the same as: 90 180 -90 0

and: -270 -180 -90 -360

and other combinations.

</pre>

 

 

-8.154e-61 and

+8.154e-61

 

call pi /*define the value of pi to some accuracy.*/

exit /*stick a fork in it, we're all done with it*/

/*───────────────────────────────────────────────────────────────────────────────────────────*/

r2d: return d2d((r2r(arg(1)) / pi()) * 180)

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

pi: pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862;return pi

select

<pre>

angles=350 10 mean angle= 0

</pre>

Note that with the increase in decimal digit precision, the 2^nd mean angle changed dramatically from an earlier result. <br><br>

 

=={{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>

=={{header|Rust}}==

 

use std::f64;

// the macro is from

assert_diff!(20.0, mean_angle(&angles3), 0.001);

}

 

=={{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|Scheme}}==

{{trans|Common Lisp}}

 

(import (srfi 1 lists)) ;; use 'fold' from library

 

(display " is ") (display (mean-angle angles)) (newline))

'((350 10) (90 180 270 360) (10 20 30)))

 

<pre>

 

=={{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}}==

atan2(

Math.avg(angles.map{ .deg2rad.sin }...),

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

say "The mean angle of #{angles.dump} is: #{ '%.2f' % mean_angle(angles)} degrees"

{{out}}

<pre>

 

=={{header|Stata}}==

function meanangle(a) {

}

 

 

meanangle((350,10)*deg)/deg

meanangle((10,20,30)*deg)/deg

20

 

=={{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}}==

as:=vm.arglist.pump(List,"toFloat","toRad");

n:=as.len();

.atan2(as.apply("cos").sum(0.0)/n)

.toDeg()

{{out}}

<pre>

20

</pre>