Data commit

Task/Averages-Mean-angle/00-META.yaml

@@ -0,0 +1,4 @@
+---
+category:
+- Geometry
+from: http://rosettacode.org/wiki/Averages/Mean_angle

Task/Averages-Mean-angle/00-TASK.txt

@@ -0,0 +1,33 @@
+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.
+
+If one wanted an average direction of the wind over two readings where the first reading was of 350 degrees and the second was of 10 degrees then the average of the numbers is 180 degrees, whereas if you can note that 350 degrees is equivalent to -10 degrees and so you have two readings at 10 degrees either side of zero degrees leading to a more fitting mean angle of zero degrees.
+
+To calculate the mean angle of several angles:
+# Assume all angles are on the unit circle and convert them to complex numbers expressed in real and imaginary form.
+# Compute the mean of the complex numbers.
+# Convert the complex mean to polar coordinates whereupon the phase of the complex mean is the required angular mean.
+
+<br>
+(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:
+
+: Given the angles <math>\alpha_1,\dots,\alpha_n</math> the mean is computed by
+
+::<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>
+
+;Task
+
+# 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). 
+# Use the function to compute the means of these lists of angles (in degrees): 
+#* &nbsp; [350, 10]  
+#* &nbsp; [90, 180, 270, 360] 
+#* &nbsp; [10, 20, 30]
+# Show your output here.
+
+{{task heading|See also}}
+
+{{Related tasks/Statistical measures}}
+
+<br><hr>
+

Task/Averages-Mean-angle/11l/averages-mean-angle.11l

@@ -0,0 +1,8 @@
+F mean_angle(angles)
+   V x = sum(angles.map(a -> cos(radians(a)))) / angles.len
+   V y = sum(angles.map(a -> sin(radians(a)))) / angles.len
+   R degrees(atan2(y, x))
+
+print(mean_angle([350, 10]))
+print(mean_angle([90, 180, 270, 360]))
+print(mean_angle([10, 20, 30]))

Task/Averages-Mean-angle/ALGOL-68/averages-mean-angle.alg

@@ -0,0 +1,26 @@
+#!/usr/bin/a68g --script #
+# -*- coding: utf-8 -*- #
+
+PROC mean angle = ([]#LONG# REAL angles)#LONG# REAL:
+(
+  INT size = UPB angles - LWB angles + 1;
+  #LONG# REAL y part := 0, x part := 0;
+  FOR i FROM LWB angles TO UPB angles DO
+      x part +:= #long# cos (angles[i] * #long# pi / 180);
+      y part +:= #long# sin (angles[i] * #long# pi / 180)
+  OD;
+
+  #long# arc tan2 (y part / size, x part / size) * 180 / #long# pi
+);
+
+main:
+(
+  []#LONG# REAL angle set 1 = ( 350, 10 );
+  []#LONG# REAL angle set 2 = ( 90, 180, 270, 360);
+  []#LONG# REAL angle set 3 = ( 10, 20, 30);
+
+  FORMAT summary fmt=$"Mean angle for "g" set :"-zd.ddddd" degrees"l$;
+  printf ((summary fmt,"1st", mean angle (angle set 1)));
+  printf ((summary fmt,"2nd", mean angle (angle set 2)));
+  printf ((summary fmt,"3rd", mean angle (angle set 3)))
+)

Task/Averages-Mean-angle/AWK/averages-mean-angle.awk

@@ -0,0 +1,13 @@
+#!/usr/bin/awk -f
+{
+    PI = atan2(0,-1);
+    x=0.0; y=0.0;
+    for (i=1; i<=NF; i++) {	
+	p = $i*PI/180.0;
+	x += sin(p);
+	y += cos(p);
+    }
+    p = atan2(x,y)*180.0/PI;	
+    if (p<0) p += 360;
+    print p;
+}

Task/Averages-Mean-angle/Ada/averages-mean-angle.ada

@@ -0,0 +1,34 @@
+with Ada.Text_IO, Ada.Numerics.Generic_Elementary_Functions;
+
+procedure Mean_Angles is
+
+   type X_Real is digits 4;      -- or more digits for improved precision
+   subtype Real is X_Real range 0.0 .. 360.0; -- the range of interest
+   type Angles is array(Positive range <>) of Real;
+
+   procedure Put(R: Real) is
+      package IO is new Ada.Text_IO.Float_IO(Real);
+   begin
+      IO.Put(R, Fore => 3, Aft => 2, Exp => 0);
+   end Put;
+
+   function Mean_Angle(A: Angles) return Real is
+      Sin_Sum, Cos_Sum: X_Real := 0.0; -- X_Real since sums might exceed 360.0
+      package Math is new Ada.Numerics.Generic_Elementary_Functions(Real);
+      use Math;
+   begin
+      for I in A'Range loop
+        Sin_Sum := Sin_Sum + Sin(A(I), Cycle => 360.0);
+        Cos_Sum := Cos_Sum + Cos(A(I), Cycle => 360.0);
+      end loop;
+      return Arctan(Sin_Sum / X_Real(A'Length), Cos_Sum / X_Real(A'Length),
+                    Cycle => 360.0);
+        -- may raise Ada.Numerics.Argument_Error if inputs are
+        -- numerically instable, e.g., when Cos_Sum is 0.0
+   end Mean_Angle;
+
+begin
+   Put(Mean_Angle((10.0, 20.0, 30.0)));     Ada.Text_IO.New_Line;    -- 20.00
+   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!
+end Mean_Angles;

Task/Averages-Mean-angle/Aime/averages-mean-angle.aime

@@ -0,0 +1,27 @@
+real
+mean(list l)
+{
+    integer i;
+    real x, y;
+
+    x = y = 0;
+
+    i = 0;
+    while (i < l_length(l)) {
+        x += Gcos(l[i]);
+        y += Gsin(l[i]);
+        i += 1;
+    }
+
+    return Gatan2(y / l_length(l), x / l_length(l));
+}
+
+integer
+main(void)
+{
+    o_form("mean of 1st set: /d6/\n", mean(l_effect(350, 10)));
+    o_form("mean of 2nd set: /d6/\n", mean(l_effect(90, 180, 270, 360)));
+    o_form("mean of 3rd set: /d6/\n", mean(l_effect(10, 20, 30)));
+
+    return 0;
+}

Task/Averages-Mean-angle/AutoHotkey/averages-mean-angle.ahk

@@ -0,0 +1,17 @@
+Angles :=  [[350, 10], [90, 180, 270, 360], [10, 20, 30]]
+MsgBox, % MeanAngle(Angles[1]) "`n"
+	. MeanAngle(Angles[2]) "`n"
+	. MeanAngle(Angles[3])
+
+MeanAngle(a, x=0, y=0) {
+	static c := ATan(1) / 45
+	for k, v in a {
+		x += Cos(v * c) / a.MaxIndex()
+		y += Sin(v * c) / a.MaxIndex()
+	}
+	return atan2(x, y) / c
+}
+
+atan2(x, y) {
+   return dllcall("msvcrt\atan2", "Double",y, "Double",x, "CDECL Double")
+}

Task/Averages-Mean-angle/BBC-BASIC/averages-mean-angle.basic

@@ -0,0 +1,20 @@
+      *FLOAT 64
+      DIM angles(3)
+      angles() = 350,10
+      PRINT FNmeanangle(angles(), 2)
+      angles() = 90,180,270,360
+      PRINT FNmeanangle(angles(), 4)
+      angles() = 10,20,30
+      PRINT FNmeanangle(angles(), 3)
+      END
+
+      DEF FNmeanangle(angles(), N%)
+      LOCAL I%, sumsin, sumcos
+      FOR I% = 0 TO N%-1
+        sumsin += SINRADangles(I%)
+        sumcos += COSRADangles(I%)
+      NEXT
+      = DEGFNatan2(sumsin, sumcos)
+
+      DEF FNatan2(y,x) : ON ERROR LOCAL = SGN(y)*PI/2
+      IF x>0 THEN = ATN(y/x) ELSE IF y>0 THEN = ATN(y/x)+PI ELSE = ATN(y/x)-PI

Task/Averages-Mean-angle/C++/averages-mean-angle.cpp

@@ -0,0 +1,37 @@
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+template<typename C>
+double meanAngle(const C& c) {
+    auto it = std::cbegin(c);
+    auto end = std::cend(c);
+
+    double x = 0.0;
+    double y = 0.0;
+    double len = 0.0;
+    while (it != end) {
+        x += cos(*it * M_PI / 180);
+        y += sin(*it * M_PI / 180);
+        len++;
+
+        it = std::next(it);
+    }
+
+    return atan2(y, x) * 180 / M_PI;
+}
+
+void printMean(std::initializer_list<double> init) {
+    std::cout << std::fixed << std::setprecision(3) << meanAngle(init) << '\n';
+}
+
+int main() {
+    printMean({ 350, 10 });
+    printMean({ 90, 180, 270, 360 });
+    printMean({ 10, 20, 30 });
+
+    return 0;
+}

Task/Averages-Mean-angle/C-sharp/averages-mean-angle.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Linq;
+using static System.Math;
+class Program
+{
+    static double MeanAngle(double[] angles)
+    {
+        var x = angles.Sum(a => Cos(a * PI / 180)) / angles.Length;
+        var y = angles.Sum(a => Sin(a * PI / 180)) / angles.Length;
+        return Atan2(y, x) * 180 / PI;
+    }
+    static void Main()
+    {
+        Action<double[]> printMean = x => Console.WriteLine("{0:0.###}", MeanAngle(x));
+        printMean(new double[] { 350, 10 });
+        printMean(new double[] { 90, 180, 270, 360 });
+        printMean(new double[] { 10, 20, 30 });
+    }
+}

Task/Averages-Mean-angle/C/averages-mean-angle.c

@@ -0,0 +1,30 @@
+#include<math.h>
+#include<stdio.h>
+
+double
+meanAngle (double *angles, int size)
+{
+  double y_part = 0, x_part = 0;
+  int i;
+
+  for (i = 0; i < size; i++)
+    {
+      x_part += cos (angles[i] * M_PI / 180);
+      y_part += sin (angles[i] * M_PI / 180);
+    }
+
+  return atan2 (y_part / size, x_part / size) * 180 / M_PI;
+}
+
+int
+main ()
+{
+  double angleSet1[] = { 350, 10 };
+  double angleSet2[] = { 90, 180, 270, 360};
+  double angleSet3[] = { 10, 20, 30};
+
+  printf ("\nMean Angle for 1st set : %lf degrees", meanAngle (angleSet1, 2));
+  printf ("\nMean Angle for 2nd set : %lf degrees", meanAngle (angleSet2, 4));
+  printf ("\nMean Angle for 3rd set : %lf degrees\n", meanAngle (angleSet3, 3));
+  return 0;
+}

Task/Averages-Mean-angle/Clojure/averages-mean-angle-1.clj

@@ -0,0 +1,12 @@
+(defn mean-fn
+  [k coll]
+  (let [n (count coll)
+        trig (get {:sin #(Math/sin %) :cos #(Math/cos %)} k)]
+    (* (/ 1 n) (reduce + (map trig coll)))))
+
+(defn mean-angle
+  [degrees]
+  (let [radians (map #(Math/toRadians %) degrees)
+        a (mean-fn :sin radians)
+        b (mean-fn :cos radians)]
+    (Math/toDegrees (Math/atan2 a b))))

Task/Averages-Mean-angle/Clojure/averages-mean-angle-2.clj

@@ -0,0 +1,8 @@
+(mean-angle [350 10])
+;=> -1.614809932057922E-15
+
+(mean-angle [90 180 270 360])
+;=> -90.0
+
+(mean-angle [10 20 30])
+;=> 19.999999999999996

Task/Averages-Mean-angle/Common-Lisp/averages-mean-angle.lisp

@@ -0,0 +1,22 @@
+(defun average (list)
+  (/ (reduce #'+ list) (length list)))
+
+(defun radians (angle)
+  (* pi 1/180 angle))
+
+(defun degrees (angle)
+  (* (/ 180 pi) angle))
+
+(defun mean-angle (angles)
+  (let* ((angles (map 'list #'radians angles))
+	 (cosines (map 'list #'cos angles))
+	 (sines (map 'list #'sin angles)))
+    (degrees (atan (average sines) (average cosines)))))
+
+(loop for angles in '((350 10) (90 180 270 360) (10 20 30))
+   do (format t "~&The mean angle of ~a is ~$°." angles (mean-angle angles)))
+
+;; or using complex numbers (cis and phase)
+
+(defun mean-angle-2 (angles)
+    (degrees (phase (reduce #'+ angles :key (lambda (deg) (cis (radians deg)))))))

Task/Averages-Mean-angle/D/averages-mean-angle.d

@@ -0,0 +1,16 @@
+import std.stdio, std.algorithm, std.complex;
+import std.math: PI;
+
+auto radians(T)(in T d) pure nothrow @nogc { return d * PI / 180; }
+auto degrees(T)(in T r) pure nothrow @nogc { return r * 180 / PI; }
+
+real meanAngle(T)(in T[] D) pure nothrow @nogc {
+    immutable t = reduce!((a, d) => a + d.radians.expi)(0.complex, D);
+    return (t / D.length).arg.degrees;
+}
+
+void main() {
+    foreach (angles; [[350, 10], [90, 180, 270, 360], [10, 20, 30]])
+        writefln("The mean angle of %s is: %.2f degrees",
+                 angles, angles.meanAngle);
+}

Task/Averages-Mean-angle/EchoLisp/averages-mean-angle.l

@@ -0,0 +1,14 @@
+(define-syntax-rule  (deg->radian deg) (* deg 1/180 PI))
+(define-syntax-rule  (radian->deg rad) (* 180 (/ PI) rad))
+
+(define (mean-angles angles)
+	(radian->deg
+          (angle
+	    (for/sum ((a angles)) (make-polar 1 (deg->radian a))))))
+
+(mean-angles '( 350 10))
+    → -0
+(mean-angles '[90 180 270 360])
+    → -90
+(mean-angles '[10 20 30])
+    → 20

Task/Averages-Mean-angle/Elixir/averages-mean-angle.elixir

@@ -0,0 +1,21 @@
+defmodule MeanAngle do
+  def mean_angle(angles) do
+    rad_angles = Enum.map(angles, &deg_to_rad/1)
+    sines = rad_angles |> Enum.map(&:math.sin/1) |> Enum.sum
+    cosines = rad_angles |> Enum.map(&:math.cos/1) |> Enum.sum
+
+    rad_to_deg(:math.atan2(sines, cosines))
+  end
+
+  defp deg_to_rad(a) do
+    (:math.pi/180) * a
+  end
+
+  defp rad_to_deg(a) do
+    (180/:math.pi) * a
+  end
+end
+
+IO.inspect MeanAngle.mean_angle([10, 350])
+IO.inspect MeanAngle.mean_angle([90, 180, 270, 360])
+IO.inspect MeanAngle.mean_angle([10, 20, 30])

Task/Averages-Mean-angle/Erlang/averages-mean-angle.erl

@@ -0,0 +1,19 @@
+-module( mean_angle ).
+-export( [from_degrees/1, task/0] ).
+
+from_degrees( Angles ) ->
+	Radians = [radians(X) || X <- Angles],
+	Sines = [math:sin(X) || X <- Radians],
+	Coses = [math:cos(X) || X <- Radians],
+	degrees( math:atan2( average(Sines), average(Coses) ) ).
+
+task() ->
+	Angles = [[350, 10], [90, 180, 270, 360], [10, 20, 30]],
+	[io:fwrite( "Mean angle of ~p is: ~p~n", [X, erlang:round(from_degrees(X))] ) || X <- Angles].
+
+
+average( List ) -> lists:sum( List ) / erlang:length( List ).
+
+degrees( Radians ) -> Radians * 180 / math:pi().
+
+radians( Degrees ) -> Degrees * math:pi() / 180.

Task/Averages-Mean-angle/Euler/averages-mean-angle.euler

@@ -0,0 +1,16 @@
+>function meanangle (a) ...
+$  z=sum(exp(rad(a)*I));
+$  if z~=0 then error("Not meaningful");
+$  else return deg(arg(z))
+$  endfunction
+>meanangle([350,10])
+ 0
+>meanangle([90,180,270,360])
+ Error : Not meaningful
+
+ Error generated by error() command
+
+ Error in function meanangle in line
+ if z~=0 then error("Not meaningful");
+>meanangle([10,20,30])
+ 20

Task/Averages-Mean-angle/Euphoria/averages-mean-angle.euphoria

@@ -0,0 +1,26 @@
+include std/console.e
+include std/mathcons.e
+
+sequence AngleList = {{350,10},{90,180,270,360},{10,20,30}}
+
+function atan2(atom y, atom x)
+	return 2*arctan((sqrt(power(x,2)+power(y,2)) - x)/y)
+end function
+
+function MeanAngle(sequence angles)
+	atom x = 0, y = 0
+	integer l = length(angles)
+	
+	for i = 1 to length(angles) do
+		x += cos(angles[i] * PI / 180)
+		y += sin(angles[i] * PI / 180)
+	end for
+	
+	return atan2(y / l, x / l) * 180 / PI
+end function
+
+for i = 1 to length(AngleList) do
+	printf(1,"Mean Angle for set %d:  %3.5f\n",{i,MeanAngle(AngleList[i])})
+end for
+
+if getc(0) then end if

Task/Averages-Mean-angle/F-Sharp/averages-mean-angle.fs

@@ -0,0 +1,15 @@
+open System
+open System.Numerics
+
+let deg2rad d = d * Math.PI / 180.
+let rad2deg r = r * 180. / Math.PI
+
+[<EntryPoint>]
+let main argv =
+    let makeComplex = fun r ->  Complex.FromPolarCoordinates(1., r)
+    argv
+    |> Seq.map (Double.Parse >> deg2rad >> makeComplex)
+    |> Seq.fold (fun x y -> Complex.Add(x,y)) Complex.Zero
+    |> fun c -> c.Phase |> rad2deg
+    |> printfn "Mean angle for [%s]: %g°" (String.Join("; ",argv))
+    0

Task/Averages-Mean-angle/Factor/averages-mean-angle.factor

@@ -0,0 +1,11 @@
+USING: formatting kernel math math.functions math.libm math.trig
+sequences ;
+
+: mean-angle ( seq -- x )
+    [ deg>rad ] map [ [ sin ] map-sum ] [ [ cos ] map-sum ]
+    [ length ] tri recip [ * ] curry bi@ fatan2 rad>deg ;
+
+: show ( seq -- )
+    dup mean-angle "The mean angle of %u is: %f°\n" printf ;
+
+{ { 350 10 } { 90 180 270 360 } { 10 20 30 } } [ show ] each

Task/Averages-Mean-angle/Fortran/averages-mean-angle.f

@@ -0,0 +1,36 @@
+!-*- mode: compilation; default-directory: "/tmp/" -*-
+!Compilation started at Mon Jun  3 18:07:59
+!
+!a=./f && make $a && OMP_NUM_THREADS=2 $a
+!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f
+!  -7.80250048E-06         350          10
+!   90.0000000              90         180         270         360
+!   19.9999962              10          20          30
+!
+!Compilation finished at Mon Jun  3 18:07:59
+
+program average_angles
+  !real(kind=8), parameter :: TAU = 6.283185307179586232 ! http://tauday.com/
+  !integer, dimension(13), parameter :: test_data = (/2,350,10, 4,90,180,270,360, 3,10,20,30, 0/)
+  !integer :: i, j, n
+  !complex(kind=16) :: some
+  !real(kind=8) :: angle
+  real, parameter :: TAU = 6.283185307179586232 ! http://tauday.com/
+  integer, dimension(13), parameter :: test_data = (/2,350,10, 4,90,180,270,360, 3,10,20,30, 0/)
+  integer :: i, j, n
+  complex :: some
+  real :: angle
+  i = 1
+  n = int(test_data(i))
+  do while (0 .lt. n)
+    some = 0
+    do j = 1, n
+      angle = (TAU/360)*test_data(i+j)
+      some = some + cmplx(cos(angle), sin(angle))
+    end do
+    some = some / n
+    write(6,*)(360/TAU)*atan2(aimag(some), real(some)),test_data(i+1:i+n)
+    i = i + n + 1
+    n = int(test_data(i))
+  end do
+end program average_angles

Task/Averages-Mean-angle/FreeBASIC/averages-mean-angle.basic

@@ -0,0 +1,25 @@
+' FB 1.05.0 Win64
+
+Const PI As Double = 3.1415926535897932
+
+Function MeanAngle(angles() As Double) As Double
+  Dim As Integer length = Ubound(angles) - Lbound(angles) + 1
+  Dim As Double sinSum = 0.0
+  Dim As Double cosSum = 0.0
+  For i As Integer = LBound(angles) To UBound(angles)
+    sinSum += Sin(angles(i) * PI / 180.0)
+    cosSum += Cos(angles(i) * PI / 180.0)
+  Next
+  Return Atan2(sinSum / length, cosSum / length) * 180.0 / PI
+End Function
+
+Dim As Double angles1(1 To 2) = {350, 10}
+Dim As Double angles2(1 To 4) = {90, 180, 270, 360}
+Dim As Double angles3(1 To 3) = {10, 20, 30}
+
+Print Using "Mean for angles 1 is : ####.## degrees"; MeanAngle(angles1())
+Print Using "Mean for angles 2 is : ####.## degrees"; MeanAngle(angles2())
+Print Using "Mean for angles 3 is : ####.## degrees"; MeanAngle(angles3())
+Print
+Print "Press any key to quit the program"
+Sleep

Task/Averages-Mean-angle/Go/averages-mean-angle-1.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/cmplx"
+)
+
+func deg2rad(d float64) float64 { return d * math.Pi / 180 }
+func rad2deg(r float64) float64 { return r * 180 / math.Pi }
+
+func mean_angle(deg []float64) float64 {
+	sum := 0i
+	for _, x := range deg {
+		sum += cmplx.Rect(1, deg2rad(x))
+	}
+	return rad2deg(cmplx.Phase(sum))
+}
+
+func main() {
+	for _, angles := range [][]float64{
+		{350, 10},
+		{90, 180, 270, 360},
+		{10, 20, 30},
+	} {
+		fmt.Printf("The mean angle of %v is: %f degrees\n", angles, mean_angle(angles))
+	}
+}

Task/Averages-Mean-angle/Go/averages-mean-angle-2.go

@@ -0,0 +1,9 @@
+func mean_angle(deg []float64) float64 {
+	var ss, sc float64
+	for _, x := range deg {
+		s, c := math.Sincos(x * math.Pi / 180)
+		ss += s
+		sc += c
+	}
+	return math.Atan2(ss, sc) * 180 / math.Pi
+}

Task/Averages-Mean-angle/Groovy/averages-mean-angle-1.groovy

@@ -0,0 +1,4 @@
+import static java.lang.Math.*
+def meanAngle = {
+    atan2( it.sum { sin(it * PI / 180) } / it.size(), it.sum { cos(it * PI / 180) } / it.size()) * 180 / PI
+}

Task/Averages-Mean-angle/Groovy/averages-mean-angle-2.groovy

@@ -0,0 +1,8 @@
+def verifyAngle = { angles ->
+    def ma = meanAngle(angles)
+    printf("Mean Angle for $angles: %5.2f%n", ma)
+    round(ma * 100) / 100.0
+}
+assert verifyAngle([350, 10]) == -0
+assert verifyAngle([90, 180, 270, 360]) == -90
+assert verifyAngle([10, 20, 30]) == 20

Task/Averages-Mean-angle/Haskell/averages-mean-angle-1.hs

@@ -0,0 +1,15 @@
+import Data.Complex (cis, phase)
+
+meanAngle
+  :: RealFloat c
+  => [c] -> c
+meanAngle = (/ pi) . (* 180) . phase . sum . map (cis . (/ 180) . (* pi))
+
+main :: IO ()
+main =
+  mapM_
+    (\angles ->
+        putStrLn $
+        "The mean angle of " ++
+        show angles ++ " is: " ++ show (meanAngle angles) ++ " degrees")
+    [[350, 10], [90, 180, 270, 360], [10, 20, 30]]

Task/Averages-Mean-angle/Haskell/averages-mean-angle-2.hs

@@ -0,0 +1,17 @@
+-- file: trigdeg.fs
+
+deg2rad deg = deg*pi/180.0
+rad2deg rad = rad*180.0/pi
+
+sind = sin . deg2rad
+cosd = cos . deg2rad
+tand = tan . deg2rad
+atand = rad2deg . atan
+atan2d y x = rad2deg (atan2 y x )
+
+avg_angle angles = atan2d y x
+    where
+    y = mean (map sind angles)
+    x = mean (map cosd angles)
+
+-- End of trigdeg.fs --------

Task/Averages-Mean-angle/IDL/averages-mean-angle.idl

@@ -0,0 +1,4 @@
+function mean_angle, phi
+        z = total(exp(complex(0,phi*!dtor)))
+	return, atan(imaginary(z),real_part(z))*!radeg
+end

Task/Averages-Mean-angle/Icon/averages-mean-angle.icon

@@ -0,0 +1,9 @@
+procedure main(A)
+    write("Mean angle is ",meanAngle(A))
+end
+
+procedure meanAngle(A)
+    every (sumSines := 0.0) +:= sin(dtor(!A))
+    every (sumCosines := 0.0) +:= cos(dtor(!A))
+    return rtod(atan(sumSines/*A,sumCosines/*A))
+end

Task/Averages-Mean-angle/J/averages-mean-angle-1.j

@@ -0,0 +1 @@
+avgAngleD=: 360|(_1 { [: (**|)&.+.@(+/ % #)&.(*.inv) 1,.])&.(1r180p1&*)

Task/Averages-Mean-angle/J/averages-mean-angle-2.j

@@ -0,0 +1,6 @@
+rfd=: 1r180p1&*                                          NB. convert angle to radians from degrees
+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
+avgAngleD=: 360|avgAngleR&.rfd                           NB. calculate average angle in degrees

Task/Averages-Mean-angle/J/averages-mean-angle-3.j

@@ -0,0 +1,10 @@
+   avgAngleD 10 350
+0
+   avgAngleD 90 180 270 360 NB. result not meaningful
+0
+   avgAngleD 10 20 30
+20
+   avgAngleD 20 350
+5
+   avgAngleD 10 340
+355

Task/Averages-Mean-angle/Java/averages-mean-angle.java

@@ -0,0 +1,30 @@
+import java.util.Arrays;
+
+public class AverageMeanAngle {
+
+    public static void main(String[] args) {
+        printAverageAngle(350.0, 10.0);
+        printAverageAngle(90.0, 180.0, 270.0, 360.0);
+        printAverageAngle(10.0, 20.0, 30.0);
+        printAverageAngle(370.0);
+        printAverageAngle(180.0);
+    }
+
+    private static void printAverageAngle(double... sample) {
+        double meanAngle = getMeanAngle(sample);
+        System.out.printf("The mean angle of %s is %s%n", Arrays.toString(sample), meanAngle);
+    }
+
+    public static double getMeanAngle(double... anglesDeg) {
+        double x = 0.0;
+        double y = 0.0;
+
+        for (double angleD : anglesDeg) {
+            double angleR = Math.toRadians(angleD);
+            x += Math.cos(angleR);
+            y += Math.sin(angleR);
+        }
+        double avgR = Math.atan2(y / anglesDeg.length, x / anglesDeg.length);
+        return Math.toDegrees(avgR);
+    }
+}

Task/Averages-Mean-angle/JavaScript/averages-mean-angle.js

@@ -0,0 +1,21 @@
+function sum(a) {
+    var s = 0;
+    for (var i = 0; i < a.length; i++) s += a[i];
+    return s;
+}
+
+function degToRad(a) {
+    return Math.PI / 180 * a;
+}
+
+function meanAngleDeg(a) {
+    return 180 / Math.PI * Math.atan2(
+        sum(a.map(degToRad).map(Math.sin)) / a.length,
+        sum(a.map(degToRad).map(Math.cos)) / a.length
+    );
+}
+
+var a = [350, 10], b = [90, 180, 270, 360],  c = [10, 20, 30];
+console.log(meanAngleDeg(a));
+console.log(meanAngleDeg(b));
+console.log(meanAngleDeg(c));

Task/Averages-Mean-angle/Jq/averages-mean-angle-1.jq

@@ -0,0 +1,19 @@
+def pi: 4 * (1|atan);
+
+def deg2rad: . * pi / 180;
+
+def rad2deg: if . == null then null else . * 180 / pi end;
+
+# Input: [x,y] (special handling of x==0)
+# Output: [r, theta] where theta may be null
+def to_polar:
+  if .[0] == 0
+  then [1, if .[1] > 5e-14 then pi/2 elif .[1] < -5e-14 then -pi/2 else null end]
+  else [1, ((.[1]/.[0]) | atan)]
+  end;
+
+def from_polar: .[1] | [ cos, sin];
+
+def abs: if . < 0 then - . else . end;
+
+def summation(f): map(f) | add;

Task/Averages-Mean-angle/Jq/averages-mean-angle-2.jq

@@ -0,0 +1,15 @@
+# input: degrees
+def mean_angle:
+  def round:
+    if . == null then null
+    elif . < 0 then -1 * ((- .) | round) | if . == -0 then 0 else . end
+    else ((. + 3e-14) | floor) as $x
+    | if ($x - .) | abs < 3e-14 then $x else . end
+    end;
+
+  map( [1, deg2rad] | from_polar)
+  | [ summation(.[0]), summation(.[1]) ]
+  | to_polar
+  | .[1]
+  | rad2deg
+  | round;

Task/Averages-Mean-angle/Jq/averages-mean-angle-3.jq

@@ -0,0 +1,2 @@
+([350, 10], [90, 180, 270, 360], [10, 20, 30])
+| "The mean angle of \(.) is: \(mean_angle)"

Task/Averages-Mean-angle/Jq/averages-mean-angle-4.jq

@@ -0,0 +1,4 @@
+jq -r -n -f Mean_angle.jq
+The mean angle of [350,10] is: 0
+The mean angle of [90,180,270,360] is: null
+The mean angle of [10,20,30] is: 20

Task/Averages-Mean-angle/Julia/averages-mean-angle-1.julia

@@ -0,0 +1,2 @@
+using Statistics
+meandegrees(degrees) = rad2deg(atan(mean(sind.(degrees)), mean(cosd.(degrees))))

Task/Averages-Mean-angle/Julia/averages-mean-angle-2.julia

@@ -0,0 +1,8 @@
+julia> meandegrees([350, 10])
+0.0
+
+julia> meandegrees([90, 180, 270, 360]])
+0.0
+
+julia> meandegrees([10, 20, 30]])
+19.999999999999996

Task/Averages-Mean-angle/Kotlin/averages-mean-angle.kotlin

@@ -0,0 +1,17 @@
+// version 1.0.5-2
+
+fun meanAngle(angles: DoubleArray): Double {
+    val sinSum = angles.sumByDouble {  Math.sin(it * Math.PI / 180.0) }
+    val cosSum = angles.sumByDouble {  Math.cos(it * Math.PI / 180.0) }
+    return Math.atan2(sinSum / angles.size, cosSum / angles.size) * 180.0 / Math.PI
+}
+
+fun main(args: Array<String>) {
+    val angles1 = doubleArrayOf(350.0, 10.0)
+    val angles2 = doubleArrayOf(90.0, 180.0, 270.0, 360.0)
+    val angles3 = doubleArrayOf(10.0, 20.0, 30.0)
+    val fmt  = "%.2f degrees" // format results to 2 decimal places
+    println("Mean for angles 1 is ${fmt.format(meanAngle(angles1))}")
+    println("Mean for angles 2 is ${fmt.format(meanAngle(angles2))}")
+    println("Mean for angles 3 is ${fmt.format(meanAngle(angles3))}")
+}

Task/Averages-Mean-angle/Liberty-BASIC/averages-mean-angle.basic

@@ -0,0 +1,42 @@
+global Pi
+Pi =3.1415926535
+
+print "Mean Angle( "; chr$( 34); "350,10"; chr$( 34); ") = ";         using( "###.#", meanAngle( "350,10")); " degrees."             '          0
+print "Mean Angle( "; chr$( 34); "90,180,270,360"; chr$( 34); ") = "; using( "###.#", meanAngle( "90,180,270,360")); " degrees."  '        -90
+print "Mean Angle( "; chr$( 34); "10,20,30"; chr$( 34); ") = ";       using( "###.#", meanAngle( "10,20,30")); " degrees."        '         20
+
+end
+
+function meanAngle( angles$)
+   term =1
+   while word$( angles$, term, ",") <>""
+      angle  =val( word$( angles$, term, ","))
+      sumSin = sumSin +sin( degRad( angle))
+      sumCos = sumCos +cos( degRad( angle))
+      term =term +1
+   wend
+   meanAngle= radDeg( atan2( sumSin, sumCos))
+   if abs( sumSin) +abs( sumCos) <0.001 then notice "Not Available." +_
+     chr$( 13) +"(" +angles$ +")" +_
+     chr$( 13) +"Result nearly equals zero vector." +_
+     chr$( 13) +"Displaying '666'.": meanAngle =666
+
+end function
+
+function degRad( theta)
+    degRad =theta *Pi /180
+end function
+
+function radDeg( theta)
+    radDeg =theta *180 /Pi
+end function
+
+function atan2( y, x)
+    if x >0           then at =atn( y /x)
+    if y >=0 and x <0 then at =atn( y /x) +pi
+    if y <0  and x <0 then at =atn( y /x) -pi
+    if y >0  and x =0 then at =    pi /2
+    if y <0  and x =0 then at = 0 -pi /2
+    if y =0  and x =0 then notice "undefined": end
+    atan2 =at
+end function

Task/Averages-Mean-angle/Logo/averages-mean-angle.logo

@@ -0,0 +1,13 @@
+to mean_angle :angles
+   local "avgsin
+   make "avgsin quotient apply "sum map "sin :angles count :angles
+   local "avgcos
+   make "avgcos quotient apply "sum map "cos :angles count :angles
+   output (arctan :avgcos :avgsin)
+end
+
+foreach [[350 10] [90 180 270 360] [10 20 30]] [
+  print (sentence [The average of \(] ? [\) is] (mean_angle ?))
+]
+
+bye

Task/Averages-Mean-angle/Lua/averages-mean-angle.lua

@@ -0,0 +1,13 @@
+function meanAngle (angleList)
+  local sumSin, sumCos = 0, 0
+  for i, angle in pairs(angleList) do
+    sumSin = sumSin + math.sin(math.rad(angle))
+    sumCos = sumCos + math.cos(math.rad(angle))
+  end
+  local result = math.deg(math.atan2(sumSin, sumCos))
+  return string.format("%.2f", result)
+end
+
+print(meanAngle({350, 10}))
+print(meanAngle({90, 180, 270, 360}))
+print(meanAngle({10, 20, 30}))

Task/Averages-Mean-angle/MATLAB/averages-mean-angle.m

@@ -0,0 +1,3 @@
+function u = mean_angle(phi)
+	u = angle(mean(exp(i*pi*phi/180)))*180/pi;
+end

Task/Averages-Mean-angle/Maple/averages-mean-angle-1.maple

@@ -0,0 +1,2 @@
+> [ 350, 10 ] *~ Unit(arcdeg);
+                      [350 [arcdeg], 10 [arcdeg]]

Task/Averages-Mean-angle/Maple/averages-mean-angle-2.maple

@@ -0,0 +1,5 @@
+MeanAngle := proc( L )
+        uses Units:-Standard; # for unit-awareness
+        local   u;
+        evalf( convert( argument( add( u, u = exp~( I *~ L ) ) ), 'units', 'radian', 'degree' ) )
+end proc:

Task/Averages-Mean-angle/Maple/averages-mean-angle-3.maple

@@ -0,0 +1,8 @@
+> MeanAngle( [ 350, 10 ] *~ Unit(arcdeg) );
+                                   0.
+
+> MeanAngle( [ 90, 180, 270, 360 ] *~ Unit(arcdeg) );
+                                   0.
+
+> MeanAngle( [ 10, 20, 30 ] *~ Unit(arcdeg) );
+                              20.00000000

Task/Averages-Mean-angle/Mathematica/averages-mean-angle.math

@@ -0,0 +1 @@
+meanAngle[data_List] := N@Arg[Mean[Exp[I data Degree]]]/Degree

Task/Averages-Mean-angle/NetRexx/averages-mean-angle.netrexx

@@ -0,0 +1,33 @@
+/* NetRexx */
+options replace format comments java crossref symbols nobinary
+numeric digits 80
+
+runSample(arg)
+return
+
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+method getMeanAngle(angles) private static binary
+  x_component = double 0.0
+  y_component = double 0.0
+  aK = int angles.words()
+  loop a_ = 1 to aK
+    angle_d = double angles.word(a_)
+    angle_r = double Math.toRadians(angle_d)
+    x_component = x_component + Math.cos(angle_r)
+    y_component = y_component + Math.sin(angle_r)
+    end a_
+  x_component = x_component / aK
+  y_component = y_component / aK
+  avg_r = Math.atan2(y_component, x_component)
+  avg_d = Math.toDegrees(avg_r)
+  return avg_d
+
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+method runSample(arg) private static
+  angleSet = [ '350 10', '90 180 270 360', '10 20 30', '370', '180' ]
+  loop angles over angleSet
+    say 'The mean angle of' angles.space(1, ',') 'is:'
+    say '  'getMeanAngle(angles).format(6, 6)
+    say
+    end angles
+  return

Task/Averages-Mean-angle/Nim/averages-mean-angle.nim

@@ -0,0 +1,11 @@
+import math, complex
+
+proc meanAngle(deg: openArray[float]): float =
+  var c: Complex[float]
+  for d in deg:
+    c += rect(1.0, degToRad(d))
+  radToDeg(phase(c / float(deg.len)))
+
+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"
+echo "The 3rd mean angle is: ", meanAngle([10.0, 20.0, 30.0]), " degrees"

Task/Averages-Mean-angle/OCaml/averages-mean-angle-1.ocaml

@@ -0,0 +1,25 @@
+let pi = 3.14159_26535_89793_23846_2643
+
+let deg2rad d =
+  d *. pi /. 180.0
+
+let rad2deg r =
+  r *. 180.0 /. pi
+
+let mean_angle angles =
+  let rad_angles = List.map deg2rad angles in
+  let sum_sin = List.fold_left (fun sum a -> sum +. sin a) 0.0 rad_angles
+  and sum_cos = List.fold_left (fun sum a -> sum +. cos a) 0.0 rad_angles
+  in
+  rad2deg (atan2 sum_sin sum_cos)
+
+let test angles =
+  Printf.printf "The mean angle of [%s] is: %g degrees\n"
+    (String.concat "; " (List.map (Printf.sprintf "%g") angles))
+    (mean_angle angles)
+
+let () =
+  test [350.0; 10.0];
+  test [90.0; 180.0; 270.0; 360.0];
+  test [10.0; 20.0; 30.0];
+;;

Task/Averages-Mean-angle/OCaml/averages-mean-angle-2.ocaml

@@ -0,0 +1,7 @@
+open Complex
+
+let mean_angle angles =
+  let sum =
+    List.fold_left (fun sum a -> add sum (polar 1.0 (deg2rad a))) zero angles
+  in
+    rad2deg (arg sum)

Task/Averages-Mean-angle/Oberon-2/averages-mean-angle.oberon

@@ -0,0 +1,32 @@
+MODULE MeanAngle;
+IMPORT
+  M := LRealMath,
+  Out;
+CONST
+  toRads = M.pi / 180;
+  toDegs = 180 / M.pi;
+VAR
+  grades: ARRAY 64 OF LONGREAL;
+
+PROCEDURE Mean(g: ARRAY OF LONGREAL): LONGREAL;
+VAR
+  i: INTEGER;
+  sumSin, sumCos: LONGREAL;
+BEGIN
+  i := 0;sumSin := 0.0;sumCos := 0.0;
+  WHILE g[i] # 0.0 DO
+    sumSin := sumSin + M.sin(g[i] * toRads);
+    sumCos := sumCos + M.cos(g[i] * toRads);
+    INC(i)
+  END;
+  RETURN M.arctan2(sumSin / i,sumCos / i);
+END Mean;
+
+BEGIN
+  grades[0] := 350.0;grades[1] := 10.0;
+  Out.LongRealFix(Mean(grades) * toDegs,15,9);Out.Ln;
+  grades[0] := 90.0;grades[1] := 180.0;grades[2] := 270.0;grades[3] := 360.0;
+  Out.LongRealFix(Mean(grades) * toDegs,15,9);Out.Ln;
+  grades[0] := 10.0;grades[1] := 20.0;grades[2] := 30.0;grades[3] := 0.0;
+  Out.LongRealFix(Mean(grades) * toDegs,15,9);Out.Ln;
+END MeanAngle.

Task/Averages-Mean-angle/OoRexx/averages-mean-angle.rexx

@@ -0,0 +1,24 @@
+/*REXX program computes the  mean angle  (angles expressed in degrees). */
+numeric digits 50                      /*use fifty digits of precision, */
+       showDig=10                      /*··· but only display 10 digits.*/
+xl = 350 10            ;      say showit(xl, meanAngleD(xl) )
+xl = 90 180 270 360    ;      say showit(xl, meanAngleD(xl) )
+xl = 10 20 30          ;      say showit(xl, meanAngleD(xl) )
+exit                                   /*stick a fork in it, we're done.*/
+/*----------------------------------MEANANGD subroutine-----------------*/
+meanAngleD:  procedure;  parse arg xl;   numeric digits digits()+digits()%4
+sum.=0
+n=words(xl)
+do j=1 to n
+  sum.0sin+=rxCalcSin(word(xl,j))
+  sum.0cos+=rxCalcCos(word(xl,j))
+  End
+If sum.0cos=0 Then
+  Return sign(sum.0sin/n)*90
+Else
+  Return rxCalcArcTan((sum.0sin/n)/(sum.0cos/n))
+
+showit: procedure expose showDig;  numeric digits showDig;  parse arg a,mA
+        return left('angles='a,30)  'mean angle='  format(mA,,showDig,0)/1
+
+::requires rxMath library;

Task/Averages-Mean-angle/PARI-GP/averages-mean-angle.parigp

@@ -0,0 +1,3 @@
+meanAngle(v)=atan(sum(i=1,#v,sin(v[i]))/sum(i=1,#v,cos(v[i])))%(2*Pi)
+meanDegrees(v)=meanAngle(v*Pi/180)*180/Pi
+apply(meanDegrees,[[350, 10], [90, 180, 270, 360], [10, 20, 30]])

Task/Averages-Mean-angle/PHP/averages-mean-angle.php

@@ -0,0 +1,23 @@
+<?php
+$samples = array(
+	'1st' => array(350, 10),
+	'2nd' => array(90, 180, 270, 360),
+	'3rd' => array(10, 20, 30)
+);
+
+foreach($samples as $key => $sample){
+	echo 'Mean angle for ' . $key . ' sample: ' . meanAngle($sample) . ' degrees.' . PHP_EOL;
+}
+
+function meanAngle ($angles){
+	$y_part = $x_part = 0;
+	$size = count($angles);
+	for ($i = 0; $i < $size; $i++){
+		$x_part += cos(deg2rad($angles[$i]));
+		$y_part += sin(deg2rad($angles[$i]));
+	}
+	$x_part /= $size;
+	$y_part /= $size;
+	return rad2deg(atan2($y_part, $x_part));
+}
+?>

Task/Averages-Mean-angle/PL-I/averages-mean-angle.pli

@@ -0,0 +1,18 @@
+averages: procedure options (main);             /* 31 August 2012 */
+   declare b1(2) fixed initial (350, 10);
+   declare b2(4) fixed initial (90, 180, 270, 360);
+   declare b3(3) fixed initial (10, 20, 30);
+
+   put edit ( b1) (f(7));
+   put edit ( ' mean=', mean(b1) )   (a, f(7) );
+   put skip edit ( b3) (f(7));
+   put edit ( ' mean=', mean(b3) )   (a, f(7) );
+   put skip edit ( b2) (f(7));
+   put edit ( ' mean=', mean(b2) )   (a, f(7) );
+
+mean: procedure (a) returns (fixed);
+   declare a(*) float (18);
+   return ( atand(sum(sind(a))/hbound(a), sum(cosd(a))/hbound(a) ) );
+end mean;
+
+end averages;

Task/Averages-Mean-angle/Pascal/averages-mean-angle.pas

@@ -0,0 +1,71 @@
+program MeanAngle;
+{$IFDEF DELPHI}
+  {$APPTYPE CONSOLE}
+{$ENDIF}
+uses
+  math;// sincos and atan2
+type
+  tAngles = array of double;
+
+function MeanAngle(const a:tAngles;cnt:longInt):double;
+// calculates mean angle.
+// returns 0.0 if direction is not sure.
+const
+  eps = 1e-10;
+
+var
+  i : LongInt;
+  s,c,
+  Sumsin,SumCos : extended;
+begin
+  IF cnt = 0 then
+  Begin
+    MeanAngle := 0.0;
+    EXIT;
+  end;
+
+  SumSin:= 0;
+  SumCos:= 0;
+  For i := Cnt-1 downto 0 do
+  Begin
+    sincos(DegToRad(a[i]),s,c);
+    Sumsin := sumSin+s;
+    SumCos := sumCos+c;
+  end;
+  s := SumSin/cnt;
+  c := sumCos/cnt;
+  IF c > eps then
+    MeanAngle := RadToDeg(arctan2(s,c))
+  else
+    // Not meaningful
+    MeanAngle := 0.0;
+end;
+
+Procedure OutMeanAngle(const a:tAngles;cnt:longInt);
+var
+  i : longInt;
+Begin
+  IF cnt > 0 then
+  Begin
+    write('The mean angle of [');
+    For i := 0 to Cnt-2 do
+      write(a[i]:0:2,',');
+    write(a[Cnt-1]:0:2,'] => ');
+    writeln(MeanAngle(a,cnt):0:16);
+  end;
+end;
+
+var
+  a:tAngles;
+Begin
+  setlength(a,4);
+
+  a[0] := 350;a[1] := 10;
+  OutMeanAngle(a,2);
+  a[0] := 90;a[1] := 180;a[2] := 270;a[3] := 360;
+  OutMeanAngle(a,4);
+  a[0] := 10;a[1] := 20;a[2] := 30;
+  OutMeanAngle(a,3);
+
+  setlength(a,0);
+end.

Task/Averages-Mean-angle/Perl/averages-mean-angle.pl

@@ -0,0 +1,17 @@
+sub Pi () { 3.1415926535897932384626433832795028842 }
+
+sub meanangle {
+  my($x, $y) = (0,0);
+  ($x,$y) = ($x + sin($_), $y + cos($_)) for @_;
+  my $atan = atan2($x,$y);
+  $atan += 2*Pi while $atan < 0;    # Ghetto fmod
+  $atan -= 2*Pi while $atan > 2*Pi;
+  $atan;
+}
+
+sub meandegrees {
+  meanangle( map { $_ * Pi/180 } @_ ) * 180/Pi;
+}
+
+print "The mean angle of [@$_] is: ", meandegrees(@$_), " degrees\n"
+  for ([350,10], [90,180,270,360], [10,20,30]);

Task/Averages-Mean-angle/Phix/averages-mean-angle.phix

@@ -0,0 +1,19 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">MeanAngle</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">angles</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">angles</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">atom</span> <span style="color: #000000;">ai_rad</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">angles</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]*</span><span style="color: #004600;">PI</span><span style="color: #0000FF;">/</span><span style="color: #000000;">180</span>
+         <span style="color: #000000;">x</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">cos</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ai_rad</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">y</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">sin</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ai_rad</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">if</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">1e-16</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #008000;">"not meaningful"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">return</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%g"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">round</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">atan2</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x</span><span style="color: #0000FF;">)*</span><span style="color: #000000;">180</span><span style="color: #0000FF;">/</span><span style="color: #004600;">PI</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e10</span><span style="color: #0000FF;">))</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">AngleLists</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">350</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">90</span><span style="color: #0000FF;">,</span><span style="color: #000000;">180</span><span style="color: #0000FF;">,</span><span style="color: #000000;">270</span><span style="color: #0000FF;">,</span><span style="color: #000000;">360</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">,</span><span style="color: #000000;">30</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">180</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">180</span><span style="color: #0000FF;">}}</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">AngleLists</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">ai</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">AngleLists</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%16V: Mean Angle is %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">ai</span><span style="color: #0000FF;">,</span><span style="color: #000000;">MeanAngle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ai</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Averages-Mean-angle/PicoLisp/averages-mean-angle.l

@@ -0,0 +1,14 @@
+(load "@lib/math.l")
+
+(de meanAngle (Lst)
+   (*/
+      (atan2
+         (sum '((A) (sin (*/ A pi 180.0))) Lst)
+         (sum '((A) (cos (*/ A pi 180.0))) Lst) )
+      180.0 pi ) )
+
+(for L '((350.0 10.0) (90.0 180.0 270.0 360.0) (10.0 20.0 30.0))
+   (prinl
+      "The mean angle of ["
+      (glue ", " (mapcar round L '(0 .)))
+      "] is: " (round (meanAngle L))) )

Task/Averages-Mean-angle/PowerShell/averages-mean-angle-1.psh

@@ -0,0 +1,7 @@
+function Get-MeanAngle ([double[]]$Angles)
+{
+    $x = ($Angles | ForEach-Object {[Math]::Cos($_ * [Math]::PI / 180)} | Measure-Object -Average).Average
+    $y = ($Angles | ForEach-Object {[Math]::Sin($_ * [Math]::PI / 180)} | Measure-Object -Average).Average
+
+    [Math]::Atan2($y, $x) * 180 / [Math]::PI
+}

Task/Averages-Mean-angle/PowerShell/averages-mean-angle-2.psh

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

Task/Averages-Mean-angle/Processing/averages-mean-angle.processing

@@ -0,0 +1,14 @@
+void setup() {
+  println(meanAngle(350, 10));
+  println(meanAngle(90, 180, 270, 360));
+  println(meanAngle(10, 20, 30));
+}
+
+float meanAngle(float... angles) {
+  float sum1 = 0, sum2 = 0;
+  for (int i = 0; i < angles.length; i++) {
+    sum1 += sin(radians(angles[i])) / angles.length;
+    sum2 += cos(radians(angles[i])) / angles.length;
+  }
+  return degrees(atan2(sum1, sum2));
+}

Task/Averages-Mean-angle/PureBasic/averages-mean-angle.basic

@@ -0,0 +1,29 @@
+NewList angle.d()
+
+Macro AE(x)
+  AddElement(angle()) : angle()=x
+EndMacro
+
+Procedure.d atan3(y.d,x.d)
+  If x<=0.0 : ProcedureReturn Sign(y)*#PI/2 : EndIf
+  If x>0.0  : ProcedureReturn ATan(y/x)     : EndIf
+  If y>0.0  : ProcedureReturn ATan(y/x)+#PI : EndIf
+  ProcedureReturn ATan(y/x)-#PI
+EndProcedure
+
+Procedure.d mAngle(List angle.d())
+  Define.d sumS,sumC
+  ForEach angle()
+    sumS+Sin(Radian(angle())) : sumC+Cos(Radian(angle()))
+  Next
+  ProcedureReturn Degree(atan3(sumS,sumC))
+EndProcedure
+
+AE(350.0) : AE(10.0)
+Debug StrD(mAngle(angle()),6) : ClearList(angle())
+
+AE(90.0) : AE(180.0) : AE(270.0) : AE(360.0)
+Debug StrD(mAngle(angle()),6) : ClearList(angle())
+
+AE(10.0) : AE(20.0) : AE(30.0)
+Debug StrD(mAngle(angle()),6) : ClearList(angle())

Task/Averages-Mean-angle/Python/averages-mean-angle.py

@@ -0,0 +1,12 @@
+>>> from cmath import rect, phase
+>>> from math import radians, degrees
+>>> def mean_angle(deg):
+...     return degrees(phase(sum(rect(1, radians(d)) for d in deg)/len(deg)))
+...
+>>> for angles in [[350, 10], [90, 180, 270, 360], [10, 20, 30]]:
+...     print('The mean angle of', angles, 'is:', round(mean_angle(angles), 12), 'degrees')
+...
+The mean angle of [350, 10] is: -0.0 degrees
+The mean angle of [90, 180, 270, 360] is: -90.0 degrees
+The mean angle of [10, 20, 30] is: 20.0 degrees
+>>>

Task/Averages-Mean-angle/R/averages-mean-angle.r

@@ -0,0 +1,33 @@
+deg2rad <- function(x) {
+  x * pi/180
+}
+
+rad2deg <- function(x) {
+  x * 180/pi
+}
+
+deg2vec <- function(x) {
+  c(sin(deg2rad(x)), cos(deg2rad(x)))
+}
+
+vec2deg <- function(x) {
+  res <- rad2deg(atan2(x[1], x[2]))
+  if (res < 0) {
+    360 + res
+  } else {
+    res
+  }
+}
+
+mean_vec <- function(x) {
+  y <- lapply(x, deg2vec)
+  Reduce(`+`, y)/length(y)
+}
+
+mean_deg <- function(x) {
+  vec2deg(mean_vec(x))
+}
+
+mean_deg(c(350, 10))
+mean_deg(c(90, 180, 270, 360))
+mean_deg(c(10, 20, 30))

Task/Averages-Mean-angle/REXX/averages-mean-angle.rexx

@@ -0,0 +1,55 @@
+/*REXX program  computes  the   mean angle   for a  group of angles  (expressed in degrees). */
+call pi                                          /*define the value of  pi  to some accuracy.*/
+numeric digits length(pi) - 1;                   /*use PI width  decimal digits of precision,*/
+        showDig= 10                              /*only display  ten  decimal digits.        */
+#= 350 10         ;   say show(#, meanAngleD(#)) /*display mean angle (in degrees), 1st case.*/
+#= 90 180 270 360 ;   say show(#, meanAngleD(#)) /*   "      "    "     "    "      2nd   "  */
+#= 10 20 30       ;   say show(#, meanAngleD(#)) /*   "      "    "     "    "      3rd   "  */
+exit                                             /*stick a fork in it, we're all done with it*/
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+.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) ) )
+Acos:   procedure; parse arg x;        return pi() * .5 - Asin(x)
+Atan:   parse arg x; if abs(x)=1  then return pi()*.25 * sign(x);  return Asin(x/sqrt(1 + x*x))
+d2d:    return arg(1)           //  360
+d2r:    return r2r(d2d(arg(1))  /   180   * pi() )
+r2d:    return d2d((r2r(arg(1)) /   pi()) * 180)
+r2r:    return arg(1)           // (pi()  *   2)
+pi: pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862;return pi
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+Asin:   procedure;  parse arg x 1 z 1 o 1 p;          a= abs(x);                aa= a * a
+        if a>1  then call AsinErr x                            /*argument X  is out of range.*/
+        if a >= sqrt(2) * .5  then  return sign(x) * acos( sqrt(1 - aa),  '-ASIN')
+          do j=2  by 2  until p=z;  p= z;  o= o * aa * (j-1) / j;   z= z +o / (j+1);   end
+        return  z                                              /* [↑]  compute until no noise*/
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+Atan2:  procedure; parse arg y,x;                     call pi;        s= sign(y)
+          select
+          when x=0  then  z= s * pi * .5
+          when x<0  then  if  y=0  then z= pi;  else z= s * (pi - abs( Atan(y/x) ) )
+          otherwise       z= s * Atan(y / x)
+          end   /*select*/;                           return z
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+cos:    procedure; parse arg x;      x= r2r(x);       numeric fuzz  $fuzz(6, 3)
+        a= abs(x);      if a=0  then return   1;      if a=pi    then return -1
+        if a=pi*.5 | a= pi*1.5  then return   0;      if a=pi/3  then return .5
+                  if a= pi*2/3  then return -.5;                      return .sinCos(1, 1, -1)
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+meanAngleD: procedure;  parse arg x;                  numeric digits digits() + digits() % 4
+            n= words(x);                              _sin= 0;              _cos= 0
+               do j=1  for n;  != d2r( word(x, j));   _sin= _sin + sin(!);  _cos= _cos + cos(!)
+               end   /*j*/
+            return  r2d( Atan2( _sin/n, _cos/n) )
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+show:   parse arg a,mA;                               _= format(ma, , showDig, 0) / 1
+        return left('angles='a, 30)   "mean angle="   right(_, max(4, length(_) ) )
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+sin:    procedure; parse arg x;   x= r2r(x);          numeric fuzz  $fuzz(5, 3)
+        if x=pi * .5         then return 1;           if x==pi * 1.5  then return -1
+        if abs(x)=pi | x=0   then return 0;           return .sinCos(x, x, +1)
+/*───────────────────────────────────────────────────────────────────────────────────────────*/
+sqrt:   procedure; parse arg x; if x=0  then return 0;  d=digits();  m.=9; numeric form; h= d+6
+        numeric digits;  parse value format(x,2,1,,0) 'E0'  with  g "E" _ .;  g= g * .5'e'_ % 2
+                 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*/
+        return g

Task/Averages-Mean-angle/Racket/averages-mean-angle.rkt

@@ -0,0 +1,15 @@
+#lang racket
+
+(define (mean-angle αs)
+  (radians->degrees
+   (mean-angle/radians
+    (map degrees->radians αs))))
+
+(define (mean-angle/radians αs)
+  (define n (length αs))
+  (atan (* (/ 1 n) (for/sum ([α_j αs]) (sin α_j)))
+        (* (/ 1 n) (for/sum ([α_j αs]) (cos α_j)))))
+
+(mean-angle '(350 0 10))
+(mean-angle '(90 180 270 360))
+(mean-angle '(10 20 30))

Task/Averages-Mean-angle/Raku/averages-mean-angle.raku

@@ -0,0 +1,16 @@
+# Of course, you can still use pi and 180.
+sub deg2rad { $^d * tau / 360 }
+sub rad2deg { $^r * 360 / tau }
+
+sub phase ($c)  {
+    my ($mag,$ang) = $c.polar;
+    return NaN if $mag < 1e-16;
+    $ang;
+}
+
+sub meanAngle { rad2deg phase [+] map { cis deg2rad $_ }, @^angles }
+
+say meanAngle($_).fmt("%.2f\tis the mean angle of "), $_ for
+    [350, 10],
+    [90, 180, 270, 360],
+    [10, 20, 30];

Task/Averages-Mean-angle/Ring/averages-mean-angle.ring

@@ -0,0 +1,34 @@
+# Project : Averages/Mean angle
+
+load "stdlib.ring"
+decimals(6)
+pi = 3.1415926535897
+angles = [350,10]
+see meanangle(angles, len(angles)) + nl
+angles = [90,180,270,360]
+see meanangle(angles, len(angles)) + nl
+angles = [10,20,30]
+see meanangle(angles, len(angles)) + nl
+
+func meanangle(angles, n)
+        sumsin = 0
+        sumcos = 0
+        for i = 1 to n
+             sumsin = sumsin + sin(angles[i]*pi/180)
+             sumcos = sumcos + cos(angles[i]*pi/180)
+        next
+        return 180/pi*atan3(sumsin, sumcos)
+
+func atan3(y,x)
+        if x <= 0
+           return sign(y)*pi/2
+        ok
+        if x>0
+           return atan(y/x)
+        else
+           if y>0
+              return atan(y/x)+pi
+           else
+              return atan(y/x)-pi
+           ok
+        ok

Task/Averages-Mean-angle/Ruby/averages-mean-angle.rb

@@ -0,0 +1,17 @@
+require 'complex' # Superfluous in Ruby >= 2.0; complex is added to core.
+
+def deg2rad(d)
+  d * Math::PI / 180
+end
+
+def rad2deg(r)
+  r * 180 / Math::PI
+end
+
+def mean_angle(deg)
+  rad2deg((deg.inject(0) {|z, d| z + Complex.polar(1, deg2rad(d))} / deg.length).arg)
+end
+
+[[350, 10], [90, 180, 270, 360], [10, 20, 30]].each {|angles|
+  puts "The mean angle of %p is: %f degrees" % [angles, mean_angle(angles)]
+}

Task/Averages-Mean-angle/Rust/averages-mean-angle.rust

@@ -0,0 +1,43 @@
+use std::f64;
+// the macro is from
+// http://stackoverflow.com/questions/30856285/assert-eq-with-floating-
+// point-numbers-and-delta
+fn mean_angle(angles: &[f64]) -> f64 {
+    let length: f64 = angles.len() as f64;
+    let cos_mean: f64 = angles.iter().fold(0.0, |sum, i| sum + i.to_radians().cos()) / length;
+    let sin_mean: f64 = angles.iter().fold(0.0, |sum, i| sum + i.to_radians().sin()) / length;
+    (sin_mean).atan2(cos_mean).to_degrees()
+}
+
+fn main() {
+    let angles1 = [350.0_f64, 10.0];
+    let angles2 = [90.0_f64, 180.0, 270.0, 360.0];
+    let angles3 = [10.0_f64, 20.0, 30.0];
+    println!("Mean Angle for {:?}  is {:.5} degrees",
+             &angles1,
+             mean_angle(&angles1));
+    println!("Mean Angle for {:?}  is {:.5} degrees",
+             &angles2,
+             mean_angle(&angles2));
+    println!("Mean Angle for {:?}  is {:.5} degrees",
+             &angles3,
+             mean_angle(&angles3));
+}
+
+macro_rules! assert_diff{
+    ($x: expr,$y : expr, $diff :expr)=>{
+        if ( $x - $y ).abs() > $diff {
+            panic!("floating point difference is to big {}", $x - $y );
+        }
+    }
+}
+
+#[test]
+fn calculate() {
+    let angles1 = [350.0_f64, 10.0];
+    let angles2 = [90.0_f64, 180.0, 270.0, 360.0];
+    let angles3 = [10.0_f64, 20.0, 30.0];
+    assert_diff!(0.0, mean_angle(&angles1), 0.001);
+    assert_diff!(-90.0, mean_angle(&angles2), 0.001);
+    assert_diff!(20.0, mean_angle(&angles3), 0.001);
+}

Task/Averages-Mean-angle/Scala/averages-mean-angle.scala

@@ -0,0 +1,19 @@
+trait MeanAnglesComputation {
+  import scala.math.{Pi, atan2, cos, sin}
+
+  def meanAngle(angles: List[Double], convFactor: Double = 180.0 / Pi) = {
+    val sums = angles.foldLeft((.0, .0))((r, c) => {
+      val rads = c / convFactor
+      (r._1 + sin(rads), r._2 + cos(rads))
+    })
+    val result = atan2(sums._1, sums._2)
+    (result + (if (result.signum == -1) 2 * Pi else 0.0)) * convFactor
+  }
+}
+
+object MeanAngles extends App with MeanAnglesComputation {
+  assert(meanAngle(List(350, 10), 180.0 / math.Pi).round == 360, "Unexpected result with 350, 10")
+  assert(meanAngle(List(90, 180, 270, 360)).round == 270, "Unexpected result with 90, 180, 270, 360")
+  assert(meanAngle(List(10, 20, 30)).round == 20, "Unexpected result with 10, 20, 30")
+  println("Successfully completed without errors.")
+}

Task/Averages-Mean-angle/Scheme/averages-mean-angle.ss

@@ -0,0 +1,23 @@
+(import (srfi 1 lists))  ;; use 'fold' from library
+
+(define (average l)
+  (/ (fold + 0 l) (length l)))
+
+(define pi 3.14159265358979323846264338327950288419716939937510582097)
+
+(define (radians a)
+  (* pi 1/180 a))
+
+(define (degrees a)
+  (* 180 (/ 1 pi) a))
+
+(define (mean-angle angles)
+  (let* ((angles (map radians angles))
+         (cosines (map cos angles))
+         (sines (map sin angles)))
+    (degrees (atan (average sines) (average cosines)))))
+
+(for-each (lambda (angles)
+            (display "The mean angle of ") (display angles)
+            (display " is ") (display (mean-angle angles)) (newline))
+          '((350 10) (90 180 270 360) (10 20 30)))

Task/Averages-Mean-angle/Seed7/averages-mean-angle.seed7

@@ -0,0 +1,30 @@
+$ include "seed7_05.s7i";
+  include "float.s7i";
+  include "math.s7i";
+  include "complex.s7i";
+
+const func float: deg2rad (in float: degree) is
+  return degree * PI / 180.0;
+
+const func float: rad2deg (in float: rad) is
+  return rad * 180.0 / PI;
+
+const func float: meanAngle (in array float: degrees) is func
+  result
+    var float: mean is 0.0;
+  local
+    var float: degree is 0.0;
+    var complex: sum is complex.value;
+  begin
+    for degree range degrees do
+      sum +:= polar(1.0, deg2rad(degree));
+    end for;
+    mean := rad2deg(arg(sum / complex conv length(degrees)));
+  end func;
+
+const proc: main is func
+  begin
+    writeln(meanAngle([] (350.0, 10.0)) digits 4);
+    writeln(meanAngle([] (90.0, 180.0, 270.0, 360.0)) digits 4);
+    writeln(meanAngle([] (10.0, 20.0, 30.0)) digits 4);
+  end func;

Task/Averages-Mean-angle/Sidef/averages-mean-angle.sidef

@@ -0,0 +1,10 @@
+func mean_angle(angles) {
+    atan2(
+        Math.avg(angles.map{ .deg2rad.sin }...),
+        Math.avg(angles.map{ .deg2rad.cos }...),
+    ) -> rad2deg
+}
+
+[[350,10], [90,180,270,360], [10,20,30]].each { |angles|
+  say "The mean angle of #{angles.dump} is: #{ '%.2f' % mean_angle(angles)} degrees"
+}

Task/Averages-Mean-angle/Stata/averages-mean-angle.stata

@@ -0,0 +1,14 @@
+mata
+function meanangle(a) {
+	return(arg(sum(exp(C(0,a)))))
+}
+
+deg=pi()/180
+
+meanangle((350,10)*deg)/deg
+  -1.61481e-15
+meanangle((90,180,270,360)*deg)/deg
+  0
+meanangle((10,20,30)*deg)/deg
+  20
+end

Task/Averages-Mean-angle/Swift/averages-mean-angle.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+@inlinable public func d2r<T: FloatingPoint>(_ f: T) -> T { f * .pi / 180 }
+@inlinable public func r2d<T: FloatingPoint>(_ f: T) -> T { f * 180 / .pi }
+
+public func meanOfAngles(_ angles: [Double]) -> Double {
+  let cInv = 1 / Double(angles.count)
+  let (s, c) =
+    angles.lazy
+      .map(d2r)
+      .map({ (sin($0), cos($0)) })
+      .reduce(into: (0.0, 0.0), { $0.0 += $1.0; $0.1 += $1.1 })
+
+  return r2d(atan2(cInv * s, cInv * c))
+}
+
+let fmt = { String(format: "%lf", $0) }
+
+print("Mean of angles (350, 10) => \(fmt(meanOfAngles([350, 10])))")
+print("Mean of angles (90, 180, 270, 360) => \(fmt(meanOfAngles([90, 180, 270, 360])))")
+print("Mean of angles (10, 20, 30) => \(fmt(meanOfAngles([10, 20, 30])))")

Task/Averages-Mean-angle/Tcl/averages-mean-angle-1.tcl

@@ -0,0 +1,10 @@
+proc meanAngle {angles} {
+    set toRadians [expr {atan2(0,-1) / 180}]
+    set sumSin [set sumCos 0.0]
+    foreach a $angles {
+	set sumSin [expr {$sumSin + sin($a * $toRadians)}]
+	set sumCos [expr {$sumCos + cos($a * $toRadians)}]
+    }
+    # Don't need to divide by counts; atan2() cancels that out
+    return [expr {atan2($sumSin, $sumCos) / $toRadians}]
+}

Task/Averages-Mean-angle/Tcl/averages-mean-angle-2.tcl

@@ -0,0 +1,9 @@
+# A little pretty-printer
+proc printMeanAngle {angles} {
+    puts [format "mean angle of \[%s\] = %.2f" \
+	      [join $angles ", "] [meanAngle $angles]]
+}
+
+printMeanAngle {350 10}
+printMeanAngle {90 180 270 360}
+printMeanAngle {10 20 30}

Task/Averages-Mean-angle/V-(Vlang)/averages-mean-angle.v

@@ -0,0 +1,21 @@
+import math
+
+fn mean_angle(deg []f64) f64 {
+	mut ss, mut sc := f64(0), f64(0)
+	for x in deg {
+		s, c := math.sincos(x * math.pi / 180)
+		ss += s
+		sc += c
+	}
+	return math.atan2(ss, sc) * 180 / math.pi
+}
+
+fn main() {
+	for angles in [
+		[f64(350), 10],
+		[f64(90), 180, 270, 360],
+		[f64(10), 20, 30],
+	] {
+		println("The mean angle of $angles is: ${mean_angle(angles)} degrees")
+	}
+}

Task/Averages-Mean-angle/VBA/averages-mean-angle.vba

@@ -0,0 +1,19 @@
+Option Base 1
+Private Function mean_angle(angles As Variant) As Double
+    Dim sins() As Double, coss() As Double
+    ReDim sins(UBound(angles))
+    ReDim coss(UBound(angles))
+    For i = LBound(angles) To UBound(angles)
+        sins(i) = Sin(WorksheetFunction.Radians(angles(i)))
+        coss(i) = Cos(WorksheetFunction.Radians(angles(i)))
+    Next i
+    mean_angle = WorksheetFunction.Degrees( _
+        WorksheetFunction.Atan2( _
+        WorksheetFunction.sum(coss), _
+        WorksheetFunction.sum(sins)))
+End Function
+Public Sub main()
+    Debug.Print Format(mean_angle([{350,10}]), "##0")
+    Debug.Print Format(mean_angle([{90, 180, 270, 360}]), "##0")
+    Debug.Print Format(mean_angle([{10, 20, 30}]), "##0")
+End Sub

Task/Averages-Mean-angle/Vala/averages-mean-angle.vala

@@ -0,0 +1,21 @@
+double meanAngle(double[] angles) {
+  double y_part = 0.0;
+  double x_part = 0.0;
+
+  for (int i = 0; i < angles.length; i++) {
+    x_part += Math.cos(angles[i] * Math.PI / 180.0);
+    y_part += Math.sin(angles[i] * Math.PI / 180.0);
+  }
+
+  return Math.atan2(y_part / angles.length, x_part / angles.length) * 180 / Math.PI;
+}
+
+void main() {
+  double[] angleSet1 = {350.0, 10.0};
+  double[] angleSet2 = {90.0, 180.0, 270.0, 360.0};
+  double[] angleSet3 = {10.0, 20.0, 30.0};
+
+  print("\nMean Angle for 1st set :  %lf degrees", meanAngle(angleSet1));
+  print("\nMean Angle for 2nd set : %lf degrees", meanAngle(angleSet2));
+  print("\nMean Angle for 3rd set :  %lf degrees\n", meanAngle(angleSet3));
+}

Task/Averages-Mean-angle/Visual-Basic-.NET/averages-mean-angle.vb

@@ -0,0 +1,18 @@
+Imports System.Math
+
+Module Module1
+
+    Function MeanAngle(angles As Double()) As Double
+        Dim x = angles.Sum(Function(a) Cos(a * PI / 180)) / angles.Length
+        Dim y = angles.Sum(Function(a) Sin(a * PI / 180)) / angles.Length
+        Return Atan2(y, x) * 180 / PI
+    End Function
+
+    Sub Main()
+        Dim printMean = Sub(x As Double()) Console.WriteLine("{0:0.###}", MeanAngle(x))
+        printMean({350, 10})
+        printMean({90, 180, 270, 360})
+        printMean({10, 20, 30})
+    End Sub
+
+End Module

Task/Averages-Mean-angle/Wren/averages-mean-angle.wren

@@ -0,0 +1,22 @@
+import "/fmt" for Fmt
+
+var meanAngle = Fn.new { |angles|
+    var n = angles.count
+    var sinSum = 0
+    var cosSum = 0
+    for (angle in angles) {
+        sinSum = sinSum + (angle * Num.pi / 180).sin
+        cosSum = cosSum + (angle * Num.pi / 180).cos
+    }
+    return (sinSum/n).atan(cosSum/n) * 180 / Num.pi
+}
+
+var angles1 = [350, 10]
+var angles2 = [90, 180, 270, 360]
+var angles3 = [10, 20, 30]
+
+var i = 1
+for (angles in [angles1, angles2, angles3]) {
+    System.print("Mean for angles %(i) is : %(Fmt.f(6, meanAngle.call(angles), 2))")
+    i = i + 1
+}

Task/Averages-Mean-angle/XPL0/averages-mean-angle.xpl0

@@ -0,0 +1,22 @@
+include c:\cxpl\codes;
+
+def Pi  = 3.14159265358979323846;
+def D2R = Pi/180.0;             \coefficient to convert degrees to radians
+
+func real MeanAng(A);           \Return the mean of the given list of angles
+int  A;
+real X, Y;
+int  I;
+[X:= 0.0;  Y:= 0.0;
+for I:= 1 to A(0) do
+    [X:= X + Cos(D2R*float(A(I)));
+     Y:= Y + Sin(D2R*float(A(I)));
+    ];
+return ATan2(Y,X)/D2R;
+];
+
+[Format(5, 15);
+RlOut(0, MeanAng([2, 350, 10]));  CrLf(0);
+RlOut(0, MeanAng([4, 90, 180, 270, 360]));  CrLf(0);
+RlOut(0, MeanAng([3, 10, 20, 30]));  CrLf(0);
+]

Task/Averages-Mean-angle/Zkl/averages-mean-angle.zkl

@@ -0,0 +1,7 @@
+fcn meanA(a1,a2,etc){
+   as:=vm.arglist.pump(List,"toFloat","toRad");
+   n:=as.len();
+   (as.apply("sin").sum(0.0)/n)
+   .atan2(as.apply("cos").sum(0.0)/n)
+   .toDeg()
+}