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

=={{header|11l}}==

{{trans|C#}}

V x = sum(angles.map(a -> cos(radians(a)))) / angles.len

V y = sum(angles.map(a -> sin(radians(a)))) / angles.len

print(mean_angle([350, 10]))

print(mean_angle([90, 180, 270, 360]))

{{out}}

<pre>

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

 

=={{header|Aime}}==

mean(list l)

{

 

return 0;

{{out}}

<pre>mean of 1st set: -.000000

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

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

 

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

using System.Linq;

using static System.Math;

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

}

{{out}}

<pre>0

=={{header|C++}}==

{{trans|C#}}

#include <iostream>

#include <vector>

 

return 0;

{{out}}

<pre>-0.000

 

=={{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 mean-angle-2 (angles)

(degrees (phase (reduce #'+ angles :key (lambda (deg) (cis (radians deg)))))))

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

=={{header|Delphi}}==

See [[#Pascal]].

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

 

=={{header|Factor}}==

sequences ;

 

dup mean-angle "The mean angle of %u is: %f°\n" printf ;

 

{{out}}

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

 

=={{header|IDL}}==

z = total(exp(complex(0,phi*!dtor)))

return, atan(imaginary(z),real_part(z))*!radeg

 

{{out}}

 

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

var s = 0;

for (var i = 0; i < a.length; i++) s += a[i];

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>

 

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

{{works with|Nim|0.20.0+}}

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

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:

<pre>The 1st mean angle is: -1.614809932057922e-15 degrees

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

 

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

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

{{out}}

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

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>

=={{header|Phix}}==

Copied from [[Averages/Mean_angle#Euphoria|Euphoria]], and slightly improved

{{out}}

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

 

=={{header|Processing}}==

println(meanAngle(350, 10));

println(meanAngle(90, 180, 270, 360));

}

return degrees(atan2(sum1, sum2));

{{out}}

<pre>-7.8025005E-6

 

=={{header|PureBasic}}==

 

Macro AE(x)

AE(10.0) : AE(20.0) : AE(30.0)

Debug StrD(mAngle(angle()),6) : ClearList(angle())

{{out}}

<pre>-0.000000

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

deg2rad <- function(x) {

x * pi/180

mean_deg(c(90, 180, 270, 360))

mean_deg(c(10, 20, 30))

{{out}}

<pre>

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

{{works with|Rakudo|2015.12}}

This solution refuses to return an answer when the angles cancel out to a tiny magnitude.

sub deg2rad { $^d * tau / 360 }

sub rad2deg { $^r * 360 / tau }

[350, 10],

[90, 180, 270, 360],

{{out}}

<pre>-0.00 is the mean angle of 350 10

REXX statements

<br>into single lines would increase the program's bulk and detract from the main program.

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

numeric digits length(pi) - 1; /*use PI width decimal digits of precision,*/

do j=0 while h>9; m.j= h; h= h % 2 + 1; end /*j*/

do k=j+5 to 0 by -1; numeric digits m.k; g= (g + x/g) * .5; end /*k*/

{{out|output|text=&nbsp; when using the default internal inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Averages/Mean angle

 

ok

ok

Output:

<pre>

-90

20.000000

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

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

return(arg(sum(exp(C(0,a)))))

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

20

 

=={{header|Swift}}==

 

 

@inlinable public func d2r<T: FloatingPoint>(_ f: T) -> T { f * .pi / 180 }

print("Mean of angles (350, 10) => \(fmt(meanOfAngles([350, 10])))")

print("Mean of angles (90, 180, 270, 360) => \(fmt(meanOfAngles([90, 180, 270, 360])))")

 

{{out}}

 

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

 

=={{header|Vala}}==

double y_part = 0.0;

double x_part = 0.0;

print("\nMean Angle for 2nd set : %lf degrees", meanAngle(angleSet2));

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

 

{{out}}

 

=={{header|VBA}}==

Private Function mean_angle(angles As Variant) As Double

Dim sins() As Double, coss() As Double

Debug.Print Format(mean_angle([{90, 180, 270, 360}]), "##0")

Debug.Print Format(mean_angle([{10, 20, 30}]), "##0")

<pre>0

-90

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>0

-90

20</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var meanAngle = Fn.new { |angles|

System.print("Mean for angles %(i) is : %(Fmt.f(6, meanAngle.call(angles), 2))")

i = i + 1

 

{{out}}

 

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