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

=={{header|Ada}}==

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

 

procedure Mean_Angles is

 

=={{header|Aime}}==

mean(list l)

{

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

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

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

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

 

=={{header|AWK}}==

{

PI = atan2(0,-1);

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

{{works with|BBC BASIC for Windows}}

DIM angles(3)

angles() = 350,10

 

=={{header|C}}==

#include<stdio.h>

 

 

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

using System.Linq;

using static System.Math;

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

{{trans|C#}}

#include <iostream>

#include <vector>

 

=={{header|Clojure}}==

[k coll]

(let [n (count coll)

(Math/toDegrees (Math/atan2 a b))))</syntaxhighlight>

Example:

;=> -1.614809932057922E-15

 

 

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

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

 

 

=={{header|D}}==

import std.math: PI;

 

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

 

=={{header|Elixir}}==

defmodule MeanAngle do

def mean_angle(angles) do

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

 

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

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

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

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

include std/console.e

include std/mathcons.e

 

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

open System.Numerics

 

 

=={{header|Factor}}==

sequences ;

 

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

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

=={{header|Go}}==

===Complex===

 

import (

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 {

 

=={{header|Groovy}}==

def meanAngle = {

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

}</syntaxhighlight>

Test:

def ma = meanAngle(angles)

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

 

=={{header|Haskell}}==

 

meanAngle

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

 

 

-- file: trigdeg.fs

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

 

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

end

 

=={{header|IDL}}==

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

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

 

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

avgAngleD=: 360|avgAngleR&.rfd NB. calculate average angle in degrees</syntaxhighlight>

Example use:

0

avgAngleD 90 180 270 360 NB. result not meaningful

{{trans|NetRexx}}

{{works with|Java|7+}}

 

public class AverageMeanAngle {

=={{header|JavaScript}}==

===atan2===

var s = 0;

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

 

'''Generic Infrastructure'''

 

def deg2rad: . * pi / 180;

 

'''Mean Angle'''

def mean_angle:

def round:

| round;</syntaxhighlight>

'''Examples'''

| "The mean angle of \(.) is: \(mean_angle)"</syntaxhighlight>

 

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

meandegrees(degrees) = rad2deg(atan(mean(sind.(degrees)), mean(cosd.(degrees))))</syntaxhighlight>

The output is:

0.0

 

 

=={{header|Kotlin}}==

 

fun meanAngle(angles: DoubleArray): Double {

 

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

Pi =3.1415926535

 

 

=={{header|Logo}}==

local "avgsin

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

{{trans|Tcl}}

{{works with|Lua|5.1}}

local sumSin, sumCos = 0, 0

for i, angle in pairs(angleList) do

=={{header|Maple}}==

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

[350 [arcdeg], 10 [arcdeg]]</syntaxhighlight>

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;

end proc:</syntaxhighlight>

Applying this to the given data sets, we obtain:

0.

 

 

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

end</syntaxhighlight>

mean_angle([10, 20, 30])

ans = 20.000

</pre>

 

=={{header|NetRexx}}==

{{trans|C}}

options replace format comments java crossref symbols nobinary

numeric digits 80

=={{header|Nim}}==

{{works with|Nim|0.20.0+}}

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

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE MeanAngle;

IMPORT

 

=={{header|OCaml}}==

 

let deg2rad d =

;;</syntaxhighlight>

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

 

let mean_angle angles =

=={{header|ooRexx}}==

{{trans|REXX}}

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

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

 

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

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

apply(meanDegrees,[[350, 10], [90, 180, 270, 360], [10, 20, 30]])</syntaxhighlight>

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}

 

=={{header|Perl}}==

 

sub meanangle {

=={{header|Phix}}==

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

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

=={{header|PHP}}==

{{trans|C}}

$samples = array(

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

 

=={{header|PicoLisp}}==

 

(de meanAngle (Lst)

 

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

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

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

 

=={{header|PowerShell}}==

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

{

</syntaxhighlight>

 

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

</syntaxhighlight>

 

=={{header|Processing}}==

println(meanAngle(350, 10));

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

 

=={{header|PureBasic}}==

 

Macro AE(x)

=={{header|Python}}==

{{works with|Python|2.6+}}

>>> from math import radians, degrees

>>> def mean_angle(deg):

 

=={{header|R}}==

deg2rad <- function(x) {

x * pi/180

=={{header|Racket}}==

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

#lang racket

 

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

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

 

=={{header|Ring}}==

# Project : Averages/Mean angle

 

-90

20.000000

</pre>

 

=={{header|Ruby}}==

 

def deg2rad(d)

=={{header|Rust}}==

 

use std::f64;

// the macro is from

 

=={{header|Scala}}==

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

 

{{trans|Common Lisp}}

 

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

 

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

 

=={{header|Sidef}}==

atan2(

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

 

=={{header|Stata}}==

function meanangle(a) {

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

=={{header|Swift}}==

 

 

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

 

=={{header|Tcl}}==

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

set sumSin [set sumCos 0.0]

}</syntaxhighlight>

Demonstration code:

proc printMeanAngle {angles} {

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

 

=={{header|Vala}}==

double y_part = 0.0;

double x_part = 0.0;

 

=={{header|VBA}}==

Private Function mean_angle(angles As Variant) As Double

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

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

{{trans|C#}}

 

Module Module1

20</pre>

 

{{trans|go}}

fn mean_angle(deg []f64) f64 {

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var meanAngle = Fn.new { |angles|

 

=={{header|XPL0}}==

 

def Pi = 3.14159265358979323846;

 

=={{header|zkl}}==

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

n:=as.len();

20

</pre>