-- setup
CREATE TABLE averages (val INTEGER);
INSERT INTO averages VALUES (1);
INSERT INTO averages VALUES (2);
INSERT INTO averages VALUES (3);
INSERT INTO averages VALUES (1);
INSERT INTO averages VALUES (2);
INSERT INTO averages VALUES (4);
INSERT INTO averages VALUES (2);
INSERT INTO averages VALUES (5);
INSERT INTO averages VALUES (2);
INSERT INTO averages VALUES (3);
INSERT INTO averages VALUES (3);
INSERT INTO averages VALUES (1);
INSERT INTO averages VALUES (3);
INSERT INTO averages VALUES (6);
-- find the mode
WITH
  counts AS
  (
    SELECT
      val,
      COUNT(*) AS num
    FROM
      averages
    GROUP BY
      val
  )
SELECT
  val AS mode_val
FROM
  counts
WHERE
  num IN (SELECT MAX(num) FROM counts);


// Extend the Collection protocol. Any type that conforms to extension where its Element type conforms to Hashable will automatically gain this method.
extension Collection where Element: Hashable {

    /// Return a Mode of the function, or nil if none exist.
    func mode() -> Element? {
        var frequencies = [Element: Int]()

        // Standard for loop. Can also use the forEach(_:) or reduce(into:) methods on self.
        for element in self {
            frequencies[element] = (frequencies[element] ?? 0) + 1
        }

        // The max(by:) method used here to find one of the elements with the highest associated count.
        if let ( mode, _ ) = frequencies.max(by: { $0.value < $1.value }) {
            return mode
        } else {
            return nil
        }
    }

}

["q", "a", "a", "a", "a", "b", "b", "z", "c", "c", "c"].mode() // returns "a"
[1, 1, 2, 3, 3, 3, 3, 4, 4, 4].mode() // returns 3

let emptyArray: [Int] = []
emptyArray.mode() // returns nil


# Can find the modal value of any vector of values
proc mode {n args} {
    foreach n [list $n {*}$args] {
        dict incr counter $n
    }
    set counts [lsort -stride 2 -index 1 -decreasing $counter]
    set best {}
    foreach {n count} $counts {
        if {[lindex $counts 1] == $count} {
            lappend best $n
        } else break
    }
    return $best
}

# Testing
puts [mode 1 3 6 6 6 6 7 7 12 12 17];  # --> 6
puts [mode 1 1 2 4 4];  # --> 1 4


#!/bin/bash

function mode {
    declare -A map
    max=0
    for x in "[email protected]"; do
	tmp=$((${map[$x]} + 1))
	map[$x]=$tmp
	((tmp > max)) && max=$tmp
    done
    for x in "${!map[@]}"; do
	[[ ${map[$x]} == $max ]] && echo -n "$x "
    done
    echo
}


#import std

mode = ~&hS+ leql$^&h+ eql|[email protected]

#cast %nLW

examples = mode~~ (<1,3,6,6,6,7,7,12,12,17>,<1,1,2,4,4>)


Public Sub main()
    s = [{1,2,3,3,3,4,4,4,5,5,6}]
    t = WorksheetFunction.Mode_Mult(s)
    For Each x In t
        Debug.Print x;
    Next x
End Sub


BOF                               // Copy all data to a new buffer
Reg_Copy(10, ALL)
Buf_Switch(Buf_Free)
Reg_Ins(10)

Sort(0, File_Size)                // Sort the data

BOF
repeat(ALL) {                     // Count & delete duplicate lines
    #1 = 1
    while(Match("^{.*}\N\1$", REGEXP)==0) {
        Del_Line(1)
        #1++
    }
    Num_Ins(#1, NOCR)             // Insert item count at the beginning of line
    Ins_Char(9)                   // TAB
    Line(1, ERRBREAK)             // Next (different) line
}

Sort(0, File_Size, REVERSE)       // Sort according to the count

BOF                               // Display the results
Reg_Copy_Block(10, CP, EOL_pos)
Buf_Quit(OK)
Statline_Message(@10)


fn main() {
    println(mode([2, 7, 1, 8, 2]))
    println(mode([2, 7, 1, 8, 2, 8]))
}

fn mode(a []int) []int {
    mut m := map[int]int{}
    for v in a {
        m[v]++
    }
    mut mode := []int{}
    mut n := 0
    for k, v in m {
        match true {
            v > n {
                n = v
                mode = [k]
            }
            v<n{}
            else {
                mode << k
            }
        }
    }
    return mode
}


class Arithmetic {
    static mode(arr) {
        var map = {}
        for (e in arr) {
            if (map[e] == null) map[e] = 0
            map[e] = map[e] + 1
        }
        var max = map.values.reduce {|x, y| x > y ? x : y}
        return map.keys.where {|x| map[x] == max}.toList
    }
}

System.print(Arithmetic.mode([1,2,3,4,5,5,51,2,3]))


(defun mode ( predicate &rest values)
  "Finds the mode of all values passed in.
Uses `predicate' to compare items."
  (let ((modes nil)                                      ; Declare local variables
	(mode-count 0)
	(value-list nil)
	current-value)
    (loop for value in values do
      (if (setq current-value (assoc* value value-list :test predicate)) ; Construct a linked list of cons cells, (value . count)
	  (incf (cdr current-value))
	(push (cons value 1) value-list)))
    (loop for (value . count) in value-list do           ; Find modes in linked list
      (if (> count mode-count)
	  (setq modes (list value)
		mode-count count)
	(when (eq count mode-count)
	  (push value modes))))
    modes))


sub floor(x)
    return int(x + .05)
end sub

SUB ASort$(matriz$())
    local last, gap, first, tempi$, tempj$, i, j

    last = arraysize(matriz$(), 1)

    gap = floor(last / 10) + 1
    while(TRUE)
	first = gap + 1
	for i = first to last
	    tempi$ = matriz$(i)
	    j = i - gap
	    while(TRUE)
	        tempj$ = matriz$(j)
	 	if (tempi$ >= tempj$) then
	   	    j = j + gap
	   	    break
	 	end if
	 	matriz$(j+gap) = tempj$
	 	if j <= gap then
	   	    break
	 	end if
	 	j = j - gap
	    wend
	    matriz$(j) = tempi$
        next i
	if gap = 1 then
	    return
	else
	    gap = floor(gap / 3.5) + 1
	end if
    wend
END SUB

sub getMode$(list$) // returns mode and count
	local m$(1), n, i, mode$, count, maxM$, maxC

	n = token(list$, m$(), ", ")
	ASort$(m$())

	for i = 1 to n
		if m$(i) <> mode$ then
			if count > maxC then
				maxM$ = mode$
				maxC = count
			end if
			count = 1
			mode$ = m$(i)
		else
			count = count + 1
		end if
	next i

	return maxM$ + "," + str$(maxC)
end sub

result$ = getMode$("1,3,6,6,6,6,7,7,12,12,17")
n = instr(result$, ",")
print "mode ", left$(result$, n - 1), " occur(s) ", right$(result$, len(result$) - n), " times."

result$ = getMode$("a, a, b, d, d")
print "mode ", left$(result$, n - 1), " occur(s) ", right$(result$, len(result$) - n), " times."


fcn mode(items){
   d:=Dictionary(); foreach i in (items){ d.incV(i) }
   m:=d.reduce(fcn(m,[(_,v)]){ v.max(m) },0);
   d.filter('wrap([(_,v)]){ v==m }).apply("get",0);
}


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

F mean_time(times)
   V t = (times.map(time -> time.split(‘:’)))
   V seconds = (t.map(hms -> (Float(hms[2]) + Int(hms[1]) * 60 + Int(hms[0]) * 3600)))
   V day = 24 * 60 * 60
   V to_angles = seconds.map(s -> s * 360.0 / @day)
   V mean_as_angle = mean_angle(to_angles)
   V mean_seconds = round(mean_as_angle * day / 360.0)
   I mean_seconds < 0
      mean_seconds += day
   V h = mean_seconds I/ 3600
   V m = mean_seconds % 3600
   V s = m % 60
   m = m I/ 60
   R ‘#02:#02:#02’.format(h, m, s)

print(mean_time([‘23:00:17’, ‘23:40:20’, ‘00:12:45’, ‘00:17:19’]))


INCLUDE "H6:REALMATH.ACT"

DEFINE PTR="CARD"
TYPE Time=[BYTE s,m,h]
REAL r60

PROC PrintB2(BYTE b)
  IF b<10 THEN Put('0) FI
  PrintB(b)
RETURN

PROC PrintTime(Time POINTER t)
  PrintB2(t.h) Put(':)
  PrintB2(t.m) Put(':)
  PrintB2(t.s)
RETURN

PROC Decode(CHAR ARRAY st Time POINTER t)
  CHAR ARRAY tmp

  IF st(0)#8 THEN Break() FI
  SCopyS(tmp,st,1,2) t.h=ValB(tmp)
  SCopyS(tmp,st,4,5) t.m=ValB(tmp)
  SCopyS(tmp,st,7,8) t.s=ValB(tmp)
RETURN

PROC TimeToSeconds(Time POINTER t REAL POINTER seconds)
  REAL r

  IntToReal(t.h,seconds)
  RealMult(seconds,r60,seconds)
  IntToReal(t.m,r)
  RealAdd(seconds,r,seconds)
  RealMult(seconds,r60,seconds)
  IntToReal(t.s,r)
  RealAdd(seconds,r,seconds)
RETURN

PROC SecondsToTime(REAL POINTER seconds Time POINTER t)
  REAL tmp1,tmp2

  RealAssign(seconds,tmp1)
  RealMod(tmp1,r60,tmp2)
  t.s=RealToInt(tmp2)
  RealDivInt(tmp1,r60,tmp2)
  RealMod(tmp2,r60,tmp1)
  t.m=RealToInt(tmp1)
  RealDivInt(tmp2,r60,tmp1)
  t.h=RealToInt(tmp1)
RETURN

PROC AverageTime(PTR ARRAY times BYTE count Time POINTER res)
  BYTE i
  Time t
  REAL avg,rcount,seconds,halfDay,day

  IntToReal(0,avg)
  IntToReal(count,rcount)
  ValR("43200",halfDay) ;seconds in the half of day
  ValR("86400",day)     ;seconds in the whole day
  FOR i=0 TO count-1
  DO
    Decode(times(i),t)
    TimeToSeconds(t,seconds)
    IF RealLess(seconds,halfDay) THEN
      RealAdd(seconds,day,seconds) ;correction of time
    FI
    RealAdd(avg,seconds,avg)
  OD
  RealDivInt(avg,rcount,avg)
  WHILE RealGreaterOrEqual(avg,day)
  DO
    RealSub(avg,day,avg) ;correction of time
  OD
  SecondsToTime(avg,res)
RETURN

PROC Main()
  DEFINE COUNT="4"
  PTR ARRAY times(COUNT)
  Time t

  Put(125) PutE() ;clear the screen
  IntToReal(60,r60)
  times(0)="23:00:17" times(1)="23:40:20"
  times(2)="00:12:45" times(3)="00:17:19"

  AverageTime(times,COUNT,t)
  Print("Mean time is ") PrintTime(t)
RETURN


with Ada.Calendar.Formatting;
with Ada.Command_Line;
with Ada.Numerics.Elementary_Functions;
with Ada.Strings.Fixed;
with Ada.Text_IO;

procedure Mean_Time_Of_Day is

   subtype Time        is Ada.Calendar.Time;
   subtype Time_Of_Day is Ada.Calendar.Day_Duration;
   subtype Time_String is String (1 .. 8);  --  "HH:MM:SS"

   type Time_List is array (Positive range <>) of Time_String;

   function Average_Time (List : Time_List) return Time_String is

      function To_Time (Time_Image : Time_String) return Time
      is (Ada.Calendar.Formatting.Value ("2000-01-01 " & Time_Image));

      function To_Time_Of_Day (TS : Time) return Time_Of_Day is
         use Ada.Calendar.Formatting;
         Hour_Part : constant Time_Of_Day := 60.0 * 60.0 * Hour (TS);
         Min_Part  : constant Time_Of_Day := 60.0 * Minute (TS);
         Sec_Part  : constant Time_Of_Day := Time_Of_Day (Second (TS));
      begin
         return Hour_Part + Min_Part + Sec_Part;
      end To_Time_Of_Day;

      function To_Time_Image (Angle : Time_Of_Day) return Time_String
      is
         use Ada.Calendar.Formatting;
         TOD : constant Time := Time_Of
           (Year => 2000, Month => 1, Day => 1,  --  Not used
            Seconds => Angle);
      begin
         return Ada.Strings.Fixed.Tail (Image (TOD), Time_String'Length);
      end To_Time_Image;

      function Average_Time_Of_Day (List : Time_List) return Time_Of_Day is
         use Ada.Numerics.Elementary_Functions;
         Cycle : constant Float := Float (Time_Of_Day'Last);
         X_Sum, Y_Sum : Float := 0.0;
         Angle        : Float;
      begin
         for Time_Stamp of List loop
            Angle := Float (To_Time_Of_Day (To_Time (Time_Stamp)));
            X_Sum := X_Sum + Cos (Angle, Cycle => Cycle);
            Y_Sum := Y_Sum + Sin (Angle, Cycle => Cycle);
         end loop;
         Angle := Arctan (Y_Sum, X_Sum, Cycle => Cycle);
         if Angle < 0.0 then
            Angle := Angle + Cycle;
         elsif Angle > Cycle then
            Angle := Angle - Cycle;
         end if;
         return Time_Of_Day (Angle);
      end Average_Time_Of_Day;

   begin
      return To_Time_Image (Average_Time_Of_Day (List));
   end Average_Time;

   use Ada.Command_Line;
   List : Time_List (1 .. Argument_Count);
begin
   if Argument_Count = 0 then
      raise Constraint_Error;
   end if;

   for A in 1 .. Argument_Count loop
      List (A) := Argument (A);
   end loop;
   Ada.Text_IO.Put_Line (Average_Time (List));

exception
   when others =>
      Ada.Text_IO.Put_Line ("Usage: mean_time_of_day <time-1> ...");
      Ada.Text_IO.Put_Line ("       <time-1> ...   'HH:MM:SS' format");
end Mean_Time_Of_Day;


      nTimes% = 4
      DATA 23:00:17, 23:40:20, 00:12:45, 00:17:19

      DIM angles(nTimes%-1)
      FOR N% = 0 TO nTimes%-1
        READ tim$
        angles(N%) = FNtimetoangle(tim$)
      NEXT
      PRINT "Mean time is " FNangletotime(FNmeanangle(angles(), nTimes%))
      END

      DEF FNtimetoangle(t$)
      LOCAL A%, I%
      REPEAT
        A% = A% * 60 + VAL(t$)
        I% = INSTR(t$, ":")
        t$ = MID$(t$, I%+1)
      UNTIL I% = 0
      = A% / 240 - 180

      DEF FNangletotime(a)
      LOCAL A%, I%, t$
      A% = INT((a + 180) * 240 + 0.5)
      FOR I% = 1 TO 3
        t$ = RIGHT$("0" + STR$(A% MOD 60), 2) + ":" + t$
        A% DIV= 60
      NEXT
      = LEFT$(t$)

      DEF FNmeanangle(angles(), N%)
      LOCAL I%, addsin, addcos
      FOR I% = 0 TO N%-1
        addsin += SINRADangles(I%)
        addcos += COSRADangles(I%)
      NEXT
      = DEGFNatan2(addsin, addcos)

      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


#include<stdlib.h>
#include<math.h>
#include<stdio.h>

typedef struct
{
  int hour, minute, second;
} digitime;

double
timeToDegrees (digitime time)
{
  return (360 * time.hour / 24.0 + 360 * time.minute / (24 * 60.0) +
          360 * time.second / (24 * 3600.0));
}

digitime
timeFromDegrees (double angle)
{
  digitime d;
  double totalSeconds = 24 * 60 * 60 * angle / 360;

  d.second = (int) totalSeconds % 60;
  d.minute = ((int) totalSeconds % 3600 - d.second) / 60;
  d.hour = (int) totalSeconds / 3600;

  return d;
}

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 ()
{
  digitime *set, meanTime;
  int inputs, i;
  double *angleSet, angleMean;

  printf ("Enter number of inputs : ");
  scanf ("%d", &inputs);
  set = malloc (inputs * sizeof (digitime));
  angleSet = malloc (inputs * sizeof (double));
  printf ("\n\nEnter the data separated by a space between each unit : ");

  for (i = 0; i < inputs; i++)
    {
      scanf ("%d:%d:%d", &set[i].hour, &set[i].minute, &set[i].second);
      angleSet[i] = timeToDegrees (set[i]);
    }

  meanTime = timeFromDegrees (360 + meanAngle (angleSet, inputs));

  printf ("\n\nThe mean time is : %d:%d:%d", meanTime.hour, meanTime.minute,
          meanTime.second);
  return 0;
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RosettaCode
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<TimeSpan, double> TimeToDegrees = (time) =>
                360 * time.Hours / 24.0 +
                360 * time.Minutes / (24 * 60.0) +
                360 * time.Seconds / (24 * 3600.0);
            Func<List<double>, double> MeanAngle = (angles) =>
                {
                    double y_part = 0.0d, x_part = 0.0d;
                    int numItems = angles.Count;

                    for (int i = 0; i < numItems; i++)
                    {
                        x_part += Math.Cos(angles[i] * Math.PI / 180);
                        y_part += Math.Sin(angles[i] * Math.PI / 180);
                    }

                    return Math.Atan2(y_part / numItems, x_part / numItems) * 180 / Math.PI;
                };
            Func<double, TimeSpan> TimeFromDegrees = (angle) =>
                    new TimeSpan(
                        (int)(24 * 60 * 60 * angle / 360) / 3600,
                        ((int)(24 * 60 * 60 * angle / 360) % 3600 - (int)(24 * 60 * 60 * angle / 360) % 60) / 60,
                        (int)(24 * 60 * 60 * angle / 360) % 60);
            List<double> digitimes = new List<double>();
            TimeSpan digitime;
            string input;

            Console.WriteLine("Enter times, end with no input: ");
            do
            {
                input = Console.ReadLine();
                if (!(string.IsNullOrWhiteSpace(input)))
                {
                    if (TimeSpan.TryParse(input, out digitime))
                        digitimes.Add(TimeToDegrees(digitime));
                    else
                        Console.WriteLine("Seems this is wrong input: ignoring time");
                }
            } while (!string.IsNullOrWhiteSpace(input));

            if(digitimes.Count() > 0)
                Console.WriteLine("The mean time is : {0}", TimeFromDegrees(360 + MeanAngle(digitimes)));
        }
    }
}


#include <iomanip>
#include <iostream>
#include <vector>

#define _USE_MATH_DEFINES
#include <math.h>

struct Time {
    int hour, minute, second;

    friend std::ostream &operator<<(std::ostream &, const Time &);
};

std::ostream &operator<<(std::ostream &os, const Time &t) {
    return os << std::setfill('0')
        << std::setw(2) << t.hour << ':'
        << std::setw(2) << t.minute << ':'
        << std::setw(2) << t.second;
}

double timeToDegrees(Time &&t) {
    return 360.0 * t.hour / 24.0
        + 360.0 * t.minute / (24 * 60.0)
        + 360.0 * t.second / (24 * 3600.0);
}

Time degreesToTime(double angle) {
    while (angle < 0.0) {
        angle += 360.0;
    }
    while (angle > 360.0) {
        angle -= 360.0;
    }

    double totalSeconds = 24.0 * 60 * 60 * angle / 360;
    Time t;

    t.second = (int)totalSeconds % 60;
    t.minute = ((int)totalSeconds % 3600 - t.second) / 60;
    t.hour = (int)totalSeconds / 3600;

    return t;
}

double meanAngle(const std::vector<double> &angles) {
    double yPart = 0.0, xPart = 0.0;
    for (auto a : angles) {
        xPart += cos(a * M_PI / 180);
        yPart += sin(a * M_PI / 180);
    }
    return atan2(yPart / angles.size(), xPart / angles.size()) * 180 / M_PI;
}

int main() {
    std::vector<double> tv;
    tv.push_back(timeToDegrees({ 23, 0, 17 }));
    tv.push_back(timeToDegrees({ 23, 40, 20 }));
    tv.push_back(timeToDegrees({ 0, 12, 45 }));
    tv.push_back(timeToDegrees({ 0, 17, 19 }));

    double ma = meanAngle(tv);
    auto mt = degreesToTime(ma);
    std::cout << mt << '\n';

    return 0;
}


;; * Loading the split-sequence library
(eval-when (:compile-toplevel :load-toplevel :execute)
  (ql:quickload '("split-sequence")))

;; * The package definition
(defpackage :mean-time-of-day
  (:use :common-lisp :iterate :split-sequence))
(in-package :mean-time-of-day)

;; * The data
(defparameter *time-values*
  '("23:00:17" "23:40:20" "00:12:45" "00:17:19"))

(defun time->radian (time)
  "Returns the radian value for TIME given as a STRING like HH:MM:SS. Assuming a
valid input value."
  (destructuring-bind (h m s)
      (mapcar #'parse-integer (split-sequence #\: time))
    (+  (* h (/ PI 12)) (* m (/ PI 12 60)) (* s (/ PI 12 3600)))))

(defun radian->time (radian)
  "Returns the corresponding time as a string like HH:MM:SS for RADIAN."
  (let* ((time (if (plusp radian)
                   (round (/ (* 12 3600 radian) PI))
                   (round (/ (* 12 3600 (+ radian (* 2 PI))) PI))))
         (h (floor time 3600))
         (m (floor (- time (* h 3600)) 60))
         (s (- time (* h 3600) (* m 60))))
    (format nil "~2,'0D:~2,'0D:~2,'0D" h m s)))

(defun make-polar (rho theta)
  "Returns a complex representing the polar coordinates."
  (complex (* rho (cos theta)) (* rho (sin theta))))

(defun mean-time (times)
  "Returns the mean time value within 24h of the list of TIMES given as strings
  HH:MM:SS."
  (radian->time (phase
                 (reduce #'+ (mapcar (lambda (time)
                                       (make-polar 1 (time->radian time))) times)))))


import std.stdio, std.range, std.algorithm, std.complex, std.math,
       std.format, std.conv;

double radians(in double d) pure nothrow @safe @nogc {
    return d * PI / 180;
}

double degrees(in double r) pure nothrow @safe @nogc {
    return r * 180 / PI;
}

double meanAngle(in double[] deg) pure nothrow @safe @nogc {
    return (deg.map!(d => fromPolar(1, d.radians)).sum / deg.length).arg.degrees;
}

string meanTime(in string[] times) pure @safe {
    auto t = times.map!(times => times.split(':').to!(int[3]));
    assert(t.all!(hms => 24.iota.canFind(hms[0]) &&
                         60.iota.canFind(hms[1]) &&
                         60.iota.canFind(hms[2])),
           "Invalid time");

    auto seconds = t.map!(hms => hms[2] + hms[1] * 60 + hms[0] * 3600);
    enum day = 24 * 60 * 60;
    const to_angles = seconds.map!(s => s * 360.0 / day).array;

    immutable mean_as_angle = to_angles.meanAngle;
    auto mean_seconds_fp = mean_as_angle * day / 360.0;
    if (mean_seconds_fp < 0)
        mean_seconds_fp += day;
    immutable mean_seconds = mean_seconds_fp.to!uint;
    immutable h = mean_seconds / 3600;
    immutable m = mean_seconds % 3600;
    return "%02d:%02d:%02d".format(h, m / 60, m % 60);
}

void main() @safe {
    ["23:00:17", "23:40:20", "00:12:45", "00:17:19"].meanTime.writeln;
}


program Averages_Mean_time_of_day;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  System.Math;

const
  Inputs: TArray<string> = ['23:00:17', '23:40:20', '00:12:45', '00:17:19'];

function ToTimes(ts: TArray<string>): TArray<TTime>;
begin
  SetLength(result, length(ts));
  for var i := 0 to High(ts) do
    Result[i] := StrToTime(ts[i]);
end;

function MeanTime(times: TArray<TTime>): TTime;
var
  ssum, csum: TTime;
  h, m, s, ms: word;
  dayFrac, fsec, ssin, ccos: double;
begin
  if Length(times) = 0 then
    exit(0);

  ssum := 0;
  csum := 0;
  for var t in times do
  begin
    DecodeTime(t, h, m, s, ms);
    fsec := (h * 60 + m) * 60 + s + ms / 1000;
    ssin := sin(fsec * Pi / (12 * 60 * 60));
    ccos := cos(fsec * Pi / (12 * 60 * 60));
    ssum := ssum + ssin;
    csum := csum + ccos;
  end;
  if (ssum = 0) and (csum = 0) then
    raise Exception.Create('Error MeanTime: Mean undefined');

  dayFrac := frac(1 + ArcTan2(ssum, csum) / (2 * Pi));
  fsec := dayFrac * 24 * 3600;

  ms := Trunc(frac(fsec) * 1000);
  s := trunc(fsec) mod 60;
  m := trunc(fsec) div 60 mod 60;
  h := trunc(fsec) div 3600;

  Result := EncodeTime(h, m, s, ms);
end;

begin
  writeln(TimeToStr(MeanTime(ToTimes(Inputs))));
  readln;
end.


;; string hh:mm:ss to radians
(define (time->radian time)
    (define-values (h m s) (map string->number (string-split time ":")))
    (+  (* h (/ PI 12)) (* m (/ PI 12 60)) (* s (/ PI 12 3600))))

;; radians to string hh:mm;ss
(define (radian->time rad)
	(when (< rad 0) (+= rad (* 2 PI)))
	(define t (round (/ (* 12 3600 rad) PI)))
	(define h (quotient t 3600))
	(define m (quotient (- t (* h 3600)) 60))
	(define s (- t (* 3600 h) (* 60 m)))
	(string-join (map number->string (list h m s)) ":"))

(define (mean-time times)
	(radian->time
	 (angle
	  (for/sum ((t times)) (make-polar 1 (time->radian t))))))

(mean-time '{"23:00:17" "23:40:20" "00:12:45" "00:17:19"})
    →  "23:47:43"


-module( mean_time_of_day ).
-export( [from_times/1, task/0] ).

from_times( Times ) ->
	Seconds = [seconds_from_time(X) || X <- Times],
	Degrees = [degrees_from_seconds(X) || X <- Seconds],
	Average = mean_angle:from_degrees( Degrees ),
	time_from_seconds( seconds_from_degrees(Average) ).

task() ->
	Times = ["23:00:17", "23:40:20", "00:12:45", "00:17:19"],
	io:fwrite( "The mean time of  ~p is: ~p~n", [Times, from_times(Times)] ).

degrees_from_seconds( Seconds ) when Seconds < (24 * 3600) -> (Seconds * 360) / (24 * 3600).

seconds_from_degrees( Degrees ) when Degrees < 0 -> seconds_from_degrees( Degrees + 360 );
seconds_from_degrees( Degrees ) when Degrees < 360 -> (Degrees * 24 * 3600) / 360.

seconds_from_time( Time ) ->
	{ok, [Hours, Minutes, Seconds], _Rest} = io_lib:fread( "~d:~d:~d", Time ),
	Hours * 3600 + Minutes * 60 + Seconds.

time_from_seconds( Seconds_float ) ->
	Seconds = erlang:round( Seconds_float ),
	Hours = Seconds div 3600,
	Minutes = (Seconds - (Hours * 3600)) div 60,
	Secs = Seconds - (Hours * 3600) - (Minutes * 60),
	lists:flatten( io_lib:format("~2.10.0B:~2.10.0B:~2.10.0B", [Hours, Minutes, Secs]) ).


include std/console.e
include std/math.e
include std/mathcons.e
include std/sequence.e
include std/get.e

function T2D(sequence TimeSeq)
	return (360 * TimeSeq[1] / 24 + 360 * TimeSeq[2] / (24 * 60) +
			360 * TimeSeq[3] / (24 * 3600))
end function

function D2T(atom angle)
	sequence TimeSeq = {0,0,0}
	atom seconds = 24 * 60 * 60 * angle / 360

	TimeSeq[3] = mod(seconds,60)
	TimeSeq[2] = (mod(seconds,3600) - TimeSeq[3]) / 60
	TimeSeq[1] = seconds / 3600

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

sequence TimeEntry, TimeList = {}, TimeSeq

puts(1,"Enter times.  Enter with no input to end\n")
while 1 do
 TimeEntry = prompt_string("")
 if equal(TimeEntry,"") then  -- no more entries
 	for i = 1 to length(TimeList) do
 		TimeList[i] = split(TimeList[i],":") -- split the times into sequences
 		for j = 1 to 3 do
 			TimeList[i][j] = defaulted_value(TimeList[i][j],0) -- convert to numerical values
 		end for
 	end for
 	exit
 end if
 TimeList = append(TimeList,TimeEntry)
end while

sequence AngleList = repeat({},length(TimeList))

for i = 1 to length(AngleList) do
	AngleList[i] = T2D(TimeList[i])
end for

sequence MeanTime = D2T(360+MeanAngle(AngleList))

printf(1,"\nMean Time: %d:%d:%d\n",MeanTime)

if getc(0) then end if


open System
open System.Numerics

let deg2rad d = d * Math.PI / 180.
let rad2deg r = r * 180. / Math.PI
let makeComplex = fun r ->  Complex.FromPolarCoordinates(1., r)
// 1 msec = 10000 ticks
let time2deg = TimeSpan.Parse >> (fun ts -> ts.Ticks) >> (float) >> (*) (10e-9/24.)
let deg2time = (*) (24. * 10e7) >> (int64) >> TimeSpan

[<EntryPoint>]
let main argv =
    let msg = "Average time for [" + (String.Join("; ",argv)) + "] is"
    argv
    |> Seq.map (time2deg >> deg2rad >> makeComplex)
    |> Seq.fold (fun x y -> Complex.Add(x,y)) Complex.Zero
    |> fun c -> c.Phase |> rad2deg
    |> fun d -> if d < 0. then d + 360. else d
    |> deg2time |> fun t -> t.ToString(@"hh\:mm\:ss")
    |> printfn "%s: %s" msg
    0


USING: arrays formatting kernel math math.combinators
math.functions math.libm math.parser math.trig qw sequences
splitting ;
IN: rosetta-code.mean-time

CONSTANT: input qw{ 23:00:17 23:40:20 00:12:45 00:17:19 }

: time>deg ( hh:mm:ss -- x )
    ":" split [ string>number ] map first3
    [ 15 * ] [ 1/4 * ] [ 1/240 * ] tri* + + ;

: mean-angle ( seq -- x )
    [ deg>rad ] map [ [ sin ] map-sum ] [ [ cos ] map-sum ]
    [ length ] tri recip [ * ] curry [email protected] fatan2 rad>deg ;

: cutf ( x -- str y )
    [ >integer number>string ] [ dup floor - ] bi ;

: mean-time ( seq -- str )
    [ time>deg ] map mean-angle [ 360 + ] when-negative 24 *
    360 / cutf 60 * cutf 60 * round cutf drop 3array ":" join ;

: mean-time-demo ( -- )
    input dup mean-time "Mean time for %u is %s.\n" printf ;

MAIN: mean-time-demo


program mean_time_of_day
  implicit none
  integer(kind=4), parameter :: dp = kind(0.0d0)

  type time_t
    integer(kind=4) :: hours, minutes, seconds
  end type

  character(len=8), dimension(4), parameter :: times = &
    (/ '23:00:17', '23:40:20', '00:12:45', '00:17:19' /)
  real(kind=dp), dimension(size(times)) :: angles
  real(kind=dp) :: mean

  angles = time_to_angle(str_to_time(times))
  mean = mean_angle(angles)
  if (mean < 0) mean = 360 + mean

  write(*, fmt='(I2.2, '':'', I2.2, '':'', I2.2)') angle_to_time(mean)
contains
  real(kind=dp) function mean_angle(angles)
    real(kind=dp), dimension(:), intent (in) :: angles
    real(kind=dp) :: x, y

    x = sum(sin(radians(angles)))/size(angles)
    y = sum(cos(radians(angles)))/size(angles)

    mean_angle = degrees(atan2(x, y))
  end function

  elemental real(kind=dp) function radians(angle)
    real(kind=dp), intent (in) :: angle
    real(kind=dp), parameter :: pi = 4d0*atan(1d0)
    radians = angle/180*pi
  end function

  elemental real(kind=dp) function degrees(angle)
    real(kind=dp), intent (in) :: angle
    real(kind=dp), parameter :: pi = 4d0*atan(1d0)
    degrees = 180*angle/pi
  end function

  elemental type(time_t) function str_to_time(str)
    character(len=*), intent (in) :: str
    ! Assuming time in format hh:mm:ss
    read(str, fmt='(I2, 1X, I2, 1X, I2)') str_to_time
  end function

  elemental real(kind=dp) function time_to_angle(time) result (res)
    type(time_t), intent (in) :: time

    real(kind=dp) :: seconds
    real(kind=dp), parameter :: seconds_in_day = 24*60*60

    seconds = time%seconds + 60*time%minutes + 60*60*time%hours
    res = 360*seconds/seconds_in_day
  end function

  elemental type(time_t) function angle_to_time(angle)
    real(kind=dp), intent (in) :: angle

    real(kind=dp) :: seconds
    real(kind=dp), parameter :: seconds_in_day = 24*60*60

    seconds = seconds_in_day*angle/360d0
    angle_to_time%hours = int(seconds/60d0/60d0)
    seconds = mod(seconds, 60d0*60d0)
    angle_to_time%minutes = int(seconds/60d0)
    angle_to_time%seconds = mod(seconds, 60d0)
  end function
end program


' 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

' time string assumed to be in format "hh:mm:ss"
Function timeToSecs(t As String) As Integer
  Dim As Integer hours = Val(Left(t, 2))
  Dim As Integer mins =  Val(Mid(t, 4, 2))
  Dim As Integer secs =  Val(Right(t, 2))
  Return 3600 * hours + 60 * mins + secs
End Function

' 1 second of time = 360/(24 * 3600) = 1/240th degree
Function timeToDegrees(t As String) As Double
  Dim secs As Integer = timeToSecs(t)
  Return secs/240.0
End Function

Function degreesToTime(d As Double) As String
  If d < 0 Then d += 360.0
  Dim secs As Integer  = d * 240.0
  Dim hours As Integer = secs \ 3600
  Dim mins As Integer  = secs Mod 3600
  secs = mins Mod 60
  mins = mins \ 60
  Dim hBuffer As String = Right("0" + Str(hours), 2)
  Dim mBuffer As String = Right("0" + Str(mins), 2)
  Dim sBuffer As String = Right("0" + Str(secs), 2)
  Return hBuffer + ":" + mBuffer + ":" + sBuffer
End Function

Dim tm(1 To 4) As String = {"23:00:17", "23:40:20", "00:12:45", "00:17:19"}
Dim angles(1 To 4) As Double

For i As Integer = 1 To 4
  angles(i) = timeToDegrees(tm(i))
Next

Dim mean As Double = meanAngle(angles())
Print "Average time is : "; degreesToTime(mean)
Print
Print "Press any key to quit"
Sleep


package main

import (
    "errors"
    "fmt"
    "log"
    "math"
    "time"
)

var inputs = []string{"23:00:17", "23:40:20", "00:12:45", "00:17:19"}

func main() {
    tList := make([]time.Time, len(inputs))
    const clockFmt = "15:04:05"
    var err error
    for i, s := range inputs {
        tList[i], err = time.Parse(clockFmt, s)
        if err != nil {
            log.Fatal(err)
        }
    }
    mean, err := meanTime(tList)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(mean.Format(clockFmt))
}

func meanTime(times []time.Time) (mean time.Time, err error) {
    if len(times) == 0 {
        err = errors.New("meanTime: no times specified")
        return
    }
    var ssum, csum float64
    for _, t := range times {
        h, m, s := t.Clock()
        n := t.Nanosecond()
        fSec := (float64((h*60+m)*60+s) + float64(n)*1e-9)
        sin, cos := math.Sincos(fSec * math.Pi / (12 * 60 * 60))
        ssum += sin
        csum += cos
    }
    if ssum == 0 && csum == 0 {
        err = errors.New("meanTime: mean undefined")
        return
    }
    _, dayFrac := math.Modf(1 + math.Atan2(ssum, csum)/(2*math.Pi))
    return mean.Add(time.Duration(dayFrac * 24 * float64(time.Hour))), nil
}


import static java.lang.Math.*

final format = 'HH:mm:ss',  clock = PI / 12,  millisPerHr = 3600*1000
final tzOffset = new Date(0).timezoneOffset / 60
def parseTime = { time -> (Date.parse(format, time).time / millisPerHr) - tzOffset }
def formatTime = { time -> new Date((time + tzOffset) * millisPerHr as int).format(format) }
def mean = { list, closure -> list.sum(closure)/list.size() }
def meanTime = { ... timeStrings ->
    def times = timeStrings.collect(parseTime)
    formatTime(atan2( mean(times) { sin(it * clock) }, mean(times) { cos(it * clock) }) / clock)
}


import Data.Complex (cis, phase)
import Data.List.Split (splitOn)
import Text.Printf (printf)

timeToRadians :: String -> Float
timeToRadians time =
        let hours:minutes:seconds:_ = splitOn ":" time
            s = fromIntegral (read seconds :: Int)
            m = fromIntegral (read minutes :: Int)
            h = fromIntegral (read hours :: Int)
        in  (2*pi)*(h+ (m + s/60.0 )/60.0 )/24.0

radiansToTime :: Float -> String
radiansToTime  r =
        let tau = pi*2
            (_,fDay) = properFraction (r / tau) :: (Int, Float)
            fDayPositive = if fDay < 0 then 1.0+fDay else fDay
            (hours, fHours) = properFraction $ 24.0 * fDayPositive
            (minutes, fMinutes) = properFraction $ 60.0 * fHours
            seconds = 60.0 * fMinutes
        in printf "%0d" (hours::Int) ++ ":" ++ printf "%0d" (minutes::Int) ++ ":" ++ printf "%0.0f" (seconds::Float)

meanAngle :: [Float] -> Float
meanAngle = phase . sum . map cis

main :: IO ()
main = putStrLn $ radiansToTime $ meanAngle $ map timeToRadians ["23:00:17", "23:40:20", "00:12:45", "00:17:19"]


procedure main(A)
    every put(B := [], ct2a(!A))
    write(ca2t(meanAngle(B)))
end

procedure ct2a(t)
    t ? {s := ((1(move(2),move(1))*60 + 1(move(2),move(1)))*60 + move(2))}
    return (360.0/86400.0) * s
end

procedure ca2t(a)
    while a < 0 do a +:= 360.0
    t := integer((86400.0/360.0)*a + 0.5)
    s := left(1(.t % 60, t /:= 60),2,"0")
    s := left(1(.t % 60, t /:= 60),2,"0")||":"||s
    s := left(t,2,"0")||":"||s
    return s
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


require 'types/datetime'
parseTimes=: ([: _&".;._2 ,&':');._2
secsFromTime=:  24 60 60 #. ]     NB. convert from time to seconds
rft=: 2r86400p1 * secsFromTime    NB. convert from time to radians
meanTime=: 'hh:mm:ss' fmtTime [: secsFromTime [: avgAngleR&.rft parseTimes


public class MeanTimeOfDay {

    static double meanAngle(double[] angles) {
        int len = angles.length;
        double sinSum = 0.0;
        for (int i = 0; i < len; i++) {
            sinSum += Math.sin(angles[i] * Math.PI / 180.0);
        }

        double cosSum = 0.0;
        for (int i = 0; i < len; i++) {
            cosSum += Math.cos(angles[i] * Math.PI / 180.0);
        }

        return Math.atan2(sinSum / len, cosSum / len) * 180.0 / Math.PI;
    }

    /* time string assumed to be in format "hh:mm:ss" */
    static int timeToSecs(String t) {
        int hours = Integer.parseInt(t.substring(0, 2));
        int mins  = Integer.parseInt(t.substring(3, 5));
        int secs  = Integer.parseInt(t.substring(6, 8));
        return 3600 * hours + 60 * mins + secs;
    }

    /* 1 second of time = 360/(24 * 3600) = 1/240th degree */
    static double timeToDegrees(String t) {
        return timeToSecs(t) / 240.0;
    }

    static String degreesToTime(double d) {
        if (d < 0.0) d += 360.0;
        int secs  = (int)(d * 240.0);
        int hours = secs / 3600;
        int mins  = secs % 3600;
        secs = mins % 60;
        mins /= 60;
        return String.format("%2d:%2d:%2d", hours, mins, secs);
    }

    public static void main(String[] args) {
        String[] tm = {"23:00:17", "23:40:20", "00:12:45", "00:17:19"};
        double[] angles = new double[4];
        for (int i = 0; i < 4; i++) angles[i] = timeToDegrees(tm[i]);
        double mean = meanAngle(angles);
        System.out.println("Average time is : " + degreesToTime(mean));
    }
}


var args  = process.argv.slice(2);

function time_to_seconds( hms ) {
    var parts = hms.split(':');
    var h = parseInt(parts[0]);
    var m = parseInt(parts[1]);
    var s = parseInt(parts[2]);
    if ( h < 12 ) {
        h += 24;
    }
    var seconds = parseInt(parts[0]) * 60 * 60 + parseInt(parts[1]) * 60 + parseInt(parts[2]);
    return seconds;
}
function seconds_to_time( s ) {
    var h = Math.floor( s/(60 * 60) );
    if ( h < 10 ) {
        h = '0' + h;
    }
    s = s % (60 * 60);

    var m = Math.floor( s/60 );
    if ( m < 10 ) {
        m = '0' + m;
    }
    s = s % 60
    if ( s < 10 ) {
        s = '0' + s;
    }
    return h + ':' + m + ':' + s;
}

var sum = 0, count = 0, idx;
for (idx in args) {
    var seconds = time_to_seconds( args[idx] );
    sum += seconds;
    count++;
}

var seconds = Math.floor( sum / count )
console.log( 'Mean time is ', seconds_to_time(seconds));


# input: array of "h:m:s"
def mean_time_of_day:
  def pi: 4 * (1|atan);
  def to_radians:   pi * . /(12*60*60);
  def from_radians: (. * 12*60*60) / pi;

  def secs2time:  # produce "hh:mm:ss" string
    def pad: tostring | (2 - length) * "0" + .;
    "\(./60/60 % 24 | pad):\(./60 % 60 | pad):\(. % 60 | pad)";

  def round:
    if . < 0 then -1 * ((- .) | round) | if . == -0 then 0 else . end
    else floor as $x
    | if (. - $x) < 0.5 then $x else $x+1 end
    end;

  map( split(":")
       | map(tonumber)
       | (.[0]*3600 + .[1]*60 + .[2])
       | to_radians )
   | (map(sin) | add) as $y
   | (map(cos) | add) as $x
   | if $x == 0 then (if $y > 3e-14 then pi/2 elif $y < -3e-14 then -(pi/2) else null end)
     else ($y / $x) | atan
     end
   | if . == null then null
     else from_radians
     | if (.<0) then . + (24*60*60) else . end
     | round
     | secs2time
     end ;


using Statistics

function meantime(times::Array, dlm::String=":")
    c = π / (12 * 60 * 60)
    a = map(x -> parse.(Int, x), split.(times, dlm))
    ϕ = collect(3600t[1] + 60t[2] + t[3] for t in a)
    d = angle(mean(exp.(c * im * ϕ))) / 2π # days
    if d < 0 d += 1 end
    # Convert to h:m:s
    h = trunc(Int, d * 24)
    m = trunc(Int, d * 24 * 60) - h * 60
    s = trunc(Int, d * 24 * 60 * 60) - h * 60 * 60 - m * 60
    return "$h:$m:$s"
end

times = String["23:00:17", "23:40:20", "00:12:45", "00:17:19"]
mtime = meantime(times)
println("Times:")
println.(times)
println("Mean: $mtime")


// version 1.0.6

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
}

/* time string assumed to be in format "hh:mm:ss" */
fun timeToSecs(t: String): Int {
    val hours = t.slice(0..1).toInt()
    val mins  = t.slice(3..4).toInt()
    val secs  = t.slice(6..7).toInt()
    return 3600 * hours + 60 * mins + secs
}

/* 1 second of time = 360/(24 * 3600) = 1/240th degree */
fun timeToDegrees(t: String): Double = timeToSecs(t) / 240.0

fun degreesToTime(d: Double): String {
    var dd = d
    if (dd < 0.0) dd += 360.0
    var secs  = (dd * 240.0).toInt()
    val hours = secs / 3600
    var mins  = secs % 3600
    secs  = mins % 60
    mins /= 60
    return String.format("%2d:%2d:%2d", hours, mins, secs)
}

fun main(args: Array<String>) {
    val tm = arrayOf("23:00:17", "23:40:20", "00:12:45", "00:17:19")
    val angles = DoubleArray(4) { timeToDegrees(tm[it]) }
    val mean = meanAngle(angles)
    println("Average time is : ${degreesToTime(mean)}")
}


global pi
pi = acs(-1)

Print "Average of:"
for i = 1 to 4
    read t$
    print t$
    a=time2angle(t$)
    ss=ss+sin(a)
    sc=sc+cos(a)
next
a=atan2(ss,sc)
if a<0 then a=a+2*pi
print "is ";angle2time$(a)

end
data "23:00:17", "23:40:20", "00:12:45", "00:17:19"

function nn$(n)
    nn$=right$("0";n, 2)
end function

function angle2time$(a)
    a=int(a/2/pi*24*60*60)
    ss=a mod 60
    a=int(a/60)
    mm=a mod 60
    hh=int(a/60)
    angle2time$=nn$(hh);":";nn$(mm);":";nn$(ss)
end function

function time2angle(time$)
    hh=val(word$(time$,1,":"))
    mm=val(word$(time$,2,":"))
    ss=val(word$(time$,3,":"))
    time2angle=2*pi*(60*(60*hh+mm)+ss)/24/60/60
end function

function atan2(y, x)
    On Error GoTo [DivZero]      'If y is 0 catch division by zero error
        atan2 = (2 * (atn((sqr((x * x) + (y * y)) - x)/ y)))
        exit function
    [DivZero]
        atan2 = (y=0)*(x<0)*pi
End Function


local times = {"23:00:17","23:40:20","00:12:45","00:17:19"}

-- returns time converted to a radian format
local function timeToAngle(str)
	local h,m,s = str:match("(..):(..):(..)")
	return (h + m / 60 + s / 3600)/12 * math.pi
end

-- computes the mean of the angles inside a list
local function meanAngle(angles)
	local sumSin,sumCos = 0,0
	for k,v in pairs(angles) do
		sumSin = sumSin + math.sin(v)
		sumCos = sumCos + math.cos(v)
	end
	return math.atan2(sumSin,sumCos)
end

-- converts and angle back to a time string
local function angleToTime(angle)
	local abs = angle % (math.pi * 2)
	local time = abs / math.pi * 12
	local h = math.floor(time)
	local m = math.floor(time * 60) % 60
	local s = math.floor(time * 3600) % 60
	return string.format("%02d:%02d:%02d", h, m, s)
end

-- convert times to angles
for k,v in pairs(times) do
	times[k] = timeToAngle(v)
end

print(angleToTime(meanAngle(times)))


function t = mean_time_of_day(t)
    c = pi/(12*60*60);
    for k=1:length(t)
	a = sscanf(t{k},'%d:%d:%d');
	phi(k) = (a(1)*3600+a(2)*60+a(3));
    end;
    d = angle(mean(exp(i*phi*c)))/(2*pi); % days
    if (d<0) d += 1;
    t = datestr(d,"HH:MM:SS");
end;


import math, complex, strutils, sequtils

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

proc meanTime(times: openArray[string]): string =
  const day = 24 * 60 * 60
  let
    angles = times.map(proc(time: string): float =
      let t = time.split(":")
      (t[2].parseInt + t[1].parseInt * 60 + t[0].parseInt * 3600) * 360 / day)
    ms = (angles.meanAngle * day / 360 + day) mod day
    (h,m,s) = (ms.int div 3600, (ms.int mod 3600) div 60, ms.int mod 60)

  align($h, 2, '0') & ":" & align($m, 2, '0') & ":" & align($s, 2, '0')

echo meanTime(["23:00:17", "23:40:20", "00:12:45", "00:17:19"])


MODULE AvgTimeOfDay;
IMPORT
  M := LRealMath,
  T := NPCT:Tools,
  Out := NPCT:Console;

CONST
  secsDay = 86400;
  secsHour = 3600;
  secsMin = 60;

  toRads = M.pi / 180;

VAR
  h,m,s: LONGINT;
  data: ARRAY 4 OF LONGREAL;

PROCEDURE TimeToDeg(time: STRING): LONGREAL;
VAR
  parts: ARRAY 3 OF STRING;
  h,m,s: LONGREAL;
BEGIN
  T.Split(time,':',parts);
  h := T.StrToInt(parts[0]);
  m := T.StrToInt(parts[1]);
  s := T.StrToInt(parts[2]);
  RETURN (h * secsHour + m * secsMin + s) * 360 / secsDay;
END TimeToDeg;

PROCEDURE DegToTime(d: LONGREAL; VAR h,m,s: LONGINT);
VAR
  ds: LONGREAL;
  PROCEDURE Mod(x,y: LONGREAL): LONGREAL;
  VAR
    c: LONGREAL;
  BEGIN
    c := ENTIER(x / y);
    RETURN x - c * y
  END Mod;
BEGIN
  ds :=  Mod(d,360.0) * secsDay / 360.0;
  h := ENTIER(ds / secsHour);
  m := ENTIER(Mod(ds,secsHour) / secsMin);
  s := ENTIER(Mod(ds,secsMin));
END DegToTime;

PROCEDURE Mean(g: ARRAY OF LONGREAL): LONGREAL;
VAR
  i,l: LONGINT;
  sumSin, sumCos: LONGREAL;
BEGIN
  i := 0;l := LEN(g);sumSin := 0.0;sumCos := 0.0;
  WHILE i < l  DO
    sumSin := sumSin + M.sin(g[i] * toRads);
    sumCos := sumCos + M.cos(g[i] * toRads);
    INC(i)
  END;
  RETURN M.arctan2(sumSin / l,sumCos / l) * 180 / M.pi;
END Mean;

BEGIN
  data[0] := TimeToDeg("23:00:17");
  data[1] := TimeToDeg("23:40:20");
  data[2] := TimeToDeg("00:12:45");
  data[3] := TimeToDeg("00:17:19");

  DegToTime(Mean(data),h,m,s);
  Out.String(":> ");Out.Int(h,0);Out.Char(':');Out.Int(m,0);Out.Char(':');Out.Int(s,0);Out.Ln

END AvgTimeOfDay.


let pi_twice = 2.0 *. 3.14159_26535_89793_23846_2643
let day = float (24 * 60 * 60)

let rad_of_time t =
  t *. pi_twice /. day

let time_of_rad r =
  r *. day /. pi_twice

let mean_angle angles =
  let sum_sin = List.fold_left (fun sum a -> sum +. sin a) 0.0 angles
  and sum_cos = List.fold_left (fun sum a -> sum +. cos a) 0.0 angles in
  atan2 sum_sin sum_cos

let mean_time times =
  let angles = List.map rad_of_time times in
  let t = time_of_rad (mean_angle angles) in
  if t < 0.0 then t +. day else t

let parse_time t =
  Scanf.sscanf t "%d:%d:%d" (fun h m s -> float (s + m * 60 + h * 3600))

let round x = int_of_float (floor (x +. 0.5))

let string_of_time t =
  let t = round t in
  let h = t / 3600 in
  let rem = t mod 3600 in
  let m = rem / 60 in
  let s = rem mod 60 in
  Printf.sprintf "%d:%d:%d" h m s

let () =
  let times = ["23:00:17"; "23:40:20"; "00:12:45"; "00:17:19"] in
  Printf.printf "The mean time of [%s] is: %s\n"
    (String.concat "; " times)
    (string_of_time (mean_time (List.map parse_time times)))


/* REXX ---------------------------------------------------------------
* 25.06.2014 Walter Pachl
*--------------------------------------------------------------------*/
times='23:00:17 23:40:20 00:12:45 00:17:19'
sum=0
day=86400
x=0
y=0
Do i=1 To words(times)                 /* loop over times            */
  time.i=word(times,i)                 /* pick a time                */
  alpha.i=t2a(time.i)                  /* convert to angle (degrees) */
  /* Say time.i format(alpha.i,6,9) */
  x=x+rxcalcsin(alpha.i)               /* accumulate sines           */
  y=y+rxcalccos(alpha.i)               /* accumulate cosines         */
  End
ww=rxcalcarctan(x/y)                   /* compute average angle      */
ss=ww*86400/360                        /* convert to seconds         */
If ss<0 Then ss=ss+day                 /* avoid negative value       */
m=ss%60                                /* split into hh mm ss        */
s=ss-m*60
h=m%60
m=m-h*60
Say f2(h)':'f2(m)':'f2(s)              /* show the mean time         */
Exit

t2a: Procedure Expose day              /* convert time to angle      */
  Parse Arg hh ':' mm ':' ss
  sec=(hh*60+mm)*60+ss
  If sec>(day/2) Then
    sec=sec-day
  a=360*sec/day
  Return a

f2: return right(format(arg(1),2,0),2,0)

::requires rxmath library


use strict;
use warnings;
use POSIX 'fmod';
use Math::Complex;
use List::Util qw(sum);
use utf8;

use constant τ => 2 * 3.1415926535;

# time-of-day to radians
sub tod2rad {
    ($h,$m,$s) = split /:/, @_[0];
    (3600*$h + 60*$m + $s) * τ / 86400;
}

# radians to time-of-day
sub rad2tod {
    my $x = $_[0] * 86400 / τ;
    sprintf '%02d:%02d:%02d', fm($x/3600,24), fm($x/60,60), fm($x,60);
}

# float modulus, normalized to positive values
sub fm  {
    my($n,$b) = @_;
    $x = fmod($n,$b);
    $x += $b if $x < 0;
}

sub phase     { arg($_[0]) }  # aka theta
sub cis       { cos($_[0]) + i*sin($_[0]) }
sub mean_time { rad2tod phase sum map { cis tod2rad $_ } @_ }

@times = ("23:00:17", "23:40:20", "00:12:45", "00:17:19");
print mean_time(@times) . " is the mean time of " . join(' ', @times) . "\n";


with javascript_semantics
function MeanAngle(sequence angles)
    atom x = 0, y = 0
    for i=1 to length(angles) do
        atom ai_rad = angles[i]*PI/180
        x += cos(ai_rad)
        y += sin(ai_rad)
    end for
    if abs(x)<1e-16 then return "not meaningful" end if
    return atan2(y,x)*180/PI
end function

function toSecAngle(integer hours, integer minutes, integer seconds)
    return ((hours*60+minutes)*60+seconds)/(24*60*60)*360
end function

constant Times = {toSecAngle(23,00,17),
                  toSecAngle(23,40,20),
                  toSecAngle(00,12,45),
                  toSecAngle(00,17,19)}

function toHMS(object s)
    if not string(s) then
        if s<0 then s+=360 end if
        s = 24*60*60*s/360
        atom hours = floor(s/3600),
             mins = floor(remainder(s,3600)/60),
             secs = remainder(s,60)
        s = sprintf("%02d:%02d:%02d",{hours,mins,secs})
    end if
    return s
end function

printf(1,"Mean Time is %s\n",{toHMS(MeanAngle(Times))})


<?php
function time2ang($tim) {
        if (!is_string($tim)) return $tim;
        $parts = explode(':',$tim);
        if (count($parts)!=3) return $tim;
        $sec = ($parts[0]*3600)+($parts[1]*60)+$parts[2];
        $ang = 360.0 * ($sec/86400.0);
        return $ang;
}
function ang2time($ang) {
        if (!is_numeric($ang)) return $ang;
        $sec = 86400.0 * $ang / 360.0;
        $parts = array(floor($sec/3600),floor(($sec % 3600)/60),$sec % 60);
        $tim = sprintf('%02d:%02d:%02d',$parts[0],$parts[1],$parts[2]);
        return $tim;
}
function meanang($ang) {
        if (!is_array($ang)) return $ang;
        $sins = 0.0;
        $coss = 0.0;
        foreach($ang as $a) {
                $sins += sin(deg2rad($a));
                $coss += cos(deg2rad($a));
        }
        $avgsin = $sins / (0.0+count($ang));
        $avgcos = $coss / (0.0+count($ang));
        $avgang = rad2deg(atan2($avgsin,$avgcos));
        while ($avgang < 0.0) $avgang += 360.0;
        return $avgang;
}
$bats = array('23:00:17','23:40:20','00:12:45','00:17:19');
$angs = array();
foreach ($bats as $t) $angs[] = time2ang($t);
$ma = meanang($angs);
$result = ang2time($ma);
print "The mean time of day is $result (angle $ma).\n";
?>


*process source attributes xref;
 avt: Proc options(main);
 /*--------------------------------------------------------------------
 * 25.06.2014 Walter Pachl taken from REXX
 *-------------------------------------------------------------------*/
 Dcl (addr,hbound,sin,cos,atan) Builtin;
 Dcl sysprint Print;
 Dcl times(4) Char(8) Init('23:00:17','23:40:20','00:12:45','00:17:19');
 Dcl time Char(8);
 Dcl (alpha,x,y,ss,ww) Dec Float(18) Init(0);
 Dcl day Bin Fixed(31) Init(86400);
 Dcl pi Dec Float(18) Init(3.14159265358979323846);
 Dcl (i,h,m,s) bin Fixed(31) Init(0);
 Do i=1 To hbound(times);              /* loop over times            */
  time=times(i);                       /* pick a time                */
  alpha=t2a(time);                     /* convert to angle (radians) */
  x=x+sin(alpha);                      /* accumulate sines           */
  y=y+cos(alpha);                      /* accumulate cosines         */
  End;
 ww=atan(x/y);                         /* compute average angle      */
 ss=ww*day/(2*pi);                     /* convert to seconds         */
 If ss<0 Then ss=ss+day;               /* avoid negative value       */
 m=ss/60;                              /* split into hh mm ss        */
 s=ss-m*60;
 h=m/60;
 m=m-h*60;
 Put Edit(h,':',m,':',s)(Skip,3(p'99',a));

 t2a: Procedure(t) Returns(Bin Float(18)); /* convert time to angle  */
 Dcl t Char(8);
 Dcl 1 tt Based(addr(t)),
      2 hh Pic'99',
      2 * Char(1),
      2 mm Pic'99',
      2 * Char(1),
      2 ss Pic'99';
 Dcl sec Bin Fixed(31);
 Dcl a   Bin Float(18);
 sec=(hh*60+mm)*60+ss;
 If sec>(day/2) Then
   sec=sec-day;
 a=2*pi*sec/day;
 Return (a);
 End;

 End;


function Get-MeanTimeOfDay
{
    [CmdletBinding()]
    [OutputType([timespan])]
    Param
    (
        [Parameter(Mandatory=$true,
                   ValueFromPipeline=$true,
                   ValueFromPipelineByPropertyName=$true)]
        [ValidatePattern("(?:2[0-3]|[01]?[0-9])[:.][0-5]?[0-9][:.][0-5]?[0-9]")]
        [string[]]
        $Time
    )

    Begin
    {
        [double[]]$angles = @()

        function ConvertFrom-Time ([timespan]$Time)
        {
            [double]((360 * $Time.Hours / 24) + (360 * $Time.Minutes / (24 * 60)) + (360 * $Time.Seconds / (24 * 3600)))
        }

        function ConvertTo-Time ([double]$Angle)
        {
            $t = New-TimeSpan -Hours   ([int](24 * 60 * 60 * $Angle / 360) / 3600) `
                              -Minutes (([int](24 * 60 * 60 * $Angle / 360) % 3600 - [int](24 * 60 * 60 * $Angle / 360) % 60) / 60) `
                              -Seconds ([int]((24 * 60 * 60 * $Angle / 360) % 60))

            if ($t.Days -gt 0)
            {
                return ($t - (New-TimeSpan -Hours 1))
            }

            $t
        }

        function Get-MeanAngle ([double[]]$Angles)
        {
            [double]$x,$y = 0

            for ($i = 0; $i -lt $Angles.Count; $i++)
            {
                $x += [Math]::Cos($Angles[$i] * [Math]::PI / 180)
                $y += [Math]::Sin($Angles[$i] * [Math]::PI / 180)
            }

            $result = [Math]::Atan2(($y / $Angles.Count), ($x / $Angles.Count)) * 180 / [Math]::PI

            if ($result -lt 0)
            {
                return ($result + 360)
            }

            $result
        }
    }
    Process
    {
        $angles += ConvertFrom-Time $_
    }
    End
    {
        ConvertTo-Time (Get-MeanAngle $angles)
    }
}


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

def mean_time(times):
    t = (time.split(':') for time in times)
    seconds = ((float(s) + int(m) * 60 + int(h) * 3600)
               for h, m, s in t)
    day = 24 * 60 * 60
    to_angles = [s * 360. / day for s in seconds]
    mean_as_angle = mean_angle(to_angles)
    mean_seconds = mean_as_angle * day / 360.
    if mean_seconds < 0:
        mean_seconds += day
    h, m = divmod(mean_seconds, 3600)
    m, s = divmod(m, 60)
    return '%02i:%02i:%02i' % (h, m, s)

if __name__ == '__main__':
    print( mean_time(["23:00:17", "23:40:20", "00:12:45", "00:17:19"]) )


#lang racket
(define (mean-angle/radians as)
  (define n (length as))
  (atan (* (/ 1 n) (for/sum ([αj as]) (sin αj)))
        (* (/ 1 n) (for/sum ([αj as]) (cos αj)))))
(define (mean-time times)
  (define secs/day (* 60 60 24))
  (define (time->deg time)
    (/ (for/fold ([sum 0]) ([t (map string->number (string-split time ":"))])
         (+ (* 60 sum) t))
       secs/day 1/360 (/ 180 pi)))
  (define secs
    (modulo (inexact->exact (round (* (mean-angle/radians (map time->deg times))
                                      (/ 180 pi) 1/360 secs/day)))
            secs/day))
  (let loop ([s secs] [ts '()])
    (if (zero? s) (string-join ts ":")
        (let-values ([(q r) (quotient/remainder s 60)])
          (loop q (cons (~r r #:min-width 2 #:pad-string "0") ts))))))
(mean-time '("23:00:17" "23:40:20" "00:12:45" "00:17:19"))


/* REXX ---------------------------------------------------------------
* 25.06.2014 Walter Pachl
* taken from ooRexx using my very aged sin/cos/artan functions
*--------------------------------------------------------------------*/
times='23:00:17 23:40:20 00:12:45 00:17:19'
sum=0
day=86400
pi=3.14159265358979323846264
x=0
y=0
Do i=1 To words(times)                 /* loop over times            */
  time.i=word(times,i)                 /* pick a time                */
  alpha.i=t2a(time.i)                  /* convert to angle (radians) */
  /* Say time.i format(alpha.i,6,9) */
  x=x+sin(alpha.i)                     /* accumulate sines           */
  y=y+cos(alpha.i)                     /* accumulate cosines         */
  End
ww=arctan(x/y)                         /* compute average angle      */
ss=ww*86400/(2*pi)                     /* convert to seconds         */
If ss<0 Then ss=ss+day                 /* avoid negative value       */
m=ss%60                                /* split into hh mm ss        */
s=ss-m*60
h=m%60
m=m-h*60
Say f2(h)':'f2(m)':'f2(s)              /* show the mean time         */
Exit

t2a: Procedure Expose day pi           /* convert time to angle      */
  Parse Arg hh ':' mm ':' ss
  sec=(hh*60+mm)*60+ss
  If sec>(day/2) Then
    sec=sec-day
  a=2*pi*sec/day
  Return a

f2: return right(format(arg(1),2,0),2,0)

sin: Procedure Expose pi
  Parse Arg x
  prec=digits()
  Numeric Digits (2*prec)
  Do While x>pi
    x=x-pi
    End
  Do While x<-pi
    x=x+pi
    End
  o=x
  u=1
  r=x
  Do i=3 By 2
    ra=r
    o=-o*x*x
    u=u*i*(i-1)
    r=r+(o/u)
    If r=ra Then Leave
    End
  Numeric Digits prec
  Return r+0

cos: Procedure Expose pi
  Parse Arg x
  prec=digits()
  Numeric Digits (2*prec)
  Numeric Fuzz 3
  o=1
  u=1
  r=1
  Do i=1 By 2
    ra=r
    o=-o*x*x
    u=u*i*(i+1)
    r=r+(o/u)
    If r=ra Then Leave
    End
  Numeric Digits prec
  Return r+0

arctan: Procedure
  Parse Arg x
  prec=digits()
  Numeric Digits (2*prec)
  Numeric Fuzz 3
  o=x
  u=1
  r=x
  k=0
  Do i=3 By 2
    ra=r
    o=-o*x*x
    r=r+(o/i)
    If r=ra Then
      Leave
    k=k+1
    If k//1000=0 Then
      Say i left(r,40) format(abs(o/i),15,5)
    End
  Numeric Digits (prec)
  Return r+0


def time2deg(t)
  raise "invalid time" unless m = t.match(/^(\d\d):(\d\d):(\d\d)$/)
  hh,mm,ss = m[1..3].map {|e| e.to_i}
  raise "invalid time" unless (0..23).include? hh and
                              (0..59).include? mm and
                              (0..59).include? ss
  (hh*3600 + mm*60 + ss) * 360 / 86400.0
end

def deg2time(d)
  sec = (d % 360) * 86400 / 360.0
  "%02d:%02d:%02d" % [sec/3600, (sec%3600)/60, sec%60]
end

def mean_time(times)
  deg2time(mean_angle(times.map {|t| time2deg t}))
end

puts mean_time ["23:00:17", "23:40:20", "00:12:45", "00:17:19"]


global pi
pi = acs(-1)

Print "Average of:"
for i = 1 to 4
    read t$
    print t$
    a  = time2angle(t$)
    ss = ss+sin(a)
    sc = sc+cos(a)
next
a = atan2(ss,sc)
if a < 0 then a = a + 2 * pi
print "is ";angle2time$(a)
end
data "23:00:17", "23:40:20", "00:12:45", "00:17:19"

function nn$(n)
    nn$ = right$("0";n, 2)
end function

function angle2time$(a)
    a  = int(a / 2 / pi * 24 * 60 * 60)
    ss = a mod 60
    a  = int(a / 60)
    mm=a mod 60
    hh=int(a/60)
    angle2time$=nn$(hh);":";nn$(mm);":";nn$(ss)
end function

function time2angle(time$)
    hh=val(word$(time$,1,":"))
    mm=val(word$(time$,2,":"))
    ss=val(word$(time$,3,":"))
    time2angle=2*pi*(60*(60*hh+mm)+ss)/24/60/60
end function

function atan2(y, x)
       if y <> 0 then
        atan2 = (2 * (atn((sqr((x * x) + (y * y)) - x)/ y)))
        else
        atan2 = (y=0)*(x<0)*pi
       end if
End Function


use std::f64::consts::PI;

#[derive(Debug, PartialEq, Eq)]
struct Time {
    h: u8,
    m: u8,
    s: u8,
}

impl Time {
    /// Create a Time from equivalent radian measure
    fn from_radians(mut rads: f64) -> Time {
        rads %= 2.0 * PI;
        if rads < 0.0 {
            rads += 2.0 * PI
        }
        Time {
            h: (rads * 12.0 / PI) as u8,
            m: ((rads * 720.0 / PI) % 60.0) as u8,
            s: ((rads * 43200.0 / PI) % 60.0).round() as u8,
        }
    }

    /// Create a Time from H/M/S
    fn from_parts(h: u8, m: u8, s: u8) -> Result<Time, ()> {
        if h > 23 || m > 59 || s > 59 {
            return Err(());
        }
        Ok(Time { h, m, s })
    }

    /// Return time as measure in radians
    fn as_radians(&self) -> f64 {
        ((self.h as f64 / 12.0) + (self.m as f64 / 720.0) + (self.s as f64 / 43200.0)) * PI
    }
}

/// Compute the mean time from a slice of times
fn mean_time(times: &[Time]) -> Time {
    // compute sum of sines and cosines
    let (ss, sc) = times
        .iter()
        .map(Time::as_radians)
        .map(|a| (a.sin(), a.cos()))
        .fold((0.0, 0.0), |(ss, sc), (s, c)| (ss + s, sc + c));
    // scaling does not matter for atan2, meaning we do not have to divide sums by len
    Time::from_radians(ss.atan2(sc))
}

fn main() {
    let times = [
        Time::from_parts(23, 00, 17).unwrap(),
        Time::from_parts(23, 40, 20).unwrap(),
        Time::from_parts(00, 12, 45).unwrap(),
        Time::from_parts(00, 17, 19).unwrap(),
    ];

    let mean = mean_time(&times);

    println!("{:02}:{:02}:{:02}", mean.h, mean.m, mean.s);
}


import java.time.LocalTime
import scala.compat.Platform

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 MeanBatTime extends App with MeanAnglesComputation {
  val dayInSeconds = 60 * 60 * 24

  def times = batTimes.map(t => afterMidnight(t).toDouble)

  def afterMidnight(twentyFourHourTime: String) = {
    val t = LocalTime.parse(twentyFourHourTime)
    (if (t.isBefore(LocalTime.NOON)) dayInSeconds else 0) + LocalTime.parse(twentyFourHourTime).toSecondOfDay
  }

  def batTimes = List("23:00:17", "23:40:20", "00:12:45", "00:17:19")
  assert(LocalTime.MIN.plusSeconds(meanAngle(times, dayInSeconds).round).toString == "23:47:40")
  println(s"Successfully completed without errors. [total ${Platform.currentTime - executionStart} ms]")
}


(import (scheme base)
        (scheme inexact)
        (scheme read)
        (scheme write)
        (srfi 1))         ; for fold

;; functions copied from "Averages/Mean angle" task
(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)))))

;; -- new functions for this task
(define (time->angle time)
  (let* ((time2 ; replaces : with space in string
           (string-map (lambda (c) (if (char=? c #\:) #\space c)) time))
         (string-port (open-input-string time2))
         (hour (read string-port))
         (minutes (read string-port))
         (seconds (read string-port)))
    (/ (* 360 (+ (* hour 3600) (* minutes 60) seconds))
       (* 24 60 60))))

(define (angle->time angle)
  (let* ((nom-angle (if (negative? angle) (+ 360 angle) angle))
         (time (/ (* nom-angle 24 60 60) 360))
         (hour (exact (floor (/ time 3600))))
         (minutes (exact (floor (/ (- time (* 3600 hour)) 60))))
         (seconds (exact (floor (- time (* 3600 hour) (* 60 minutes))))))
    (string-append (number->string hour)
                   ":"
                   (number->string minutes)
                   ":"
                   (number->string seconds))))

(define (mean-time-of-day times)
  (angle->time (mean-angle (map time->angle times))))

(write (mean-time-of-day '("23:00:17" "23:40:20" "00:12:45" "00:17:19")))
(newline)


--Setup table for testing
CREATE TABLE time_table(times TIME);
INSERT INTO time_table VALUES ('23:00:17'::TIME),('23:40:20'::TIME),('00:12:45'::TIME),('00:17:19'::TIME)

--Compute mean time
SELECT to_timestamp((degrees(atan2(AVG(sin),AVG(cos))))* (24*60*60)/360)::TIME
FROM
	(SELECT
	cos(radians(t*360/(24*60*60))),sin(radians(t*360/(24*60*60)))
	FROM
		(SELECT EXTRACT(epoch FROM times) t
		FROM time_table) T1
	)T2


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 (y, x) =
    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 * y, cInv * x))
}

struct DigitTime {
  var hour: Int
  var minute: Int
  var second: Int

  init?(fromString str: String) {
    let split = str.components(separatedBy: ":").compactMap(Int.init)

    guard split.count == 3 else {
      return nil
    }

    (hour, minute, second) = (split[0], split[1], split[2])
  }

  init(fromDegrees angle: Double) {
    let totalSeconds = 24 * 60 * 60 * angle / 360

    second = Int(totalSeconds.truncatingRemainder(dividingBy: 60))
    minute = Int((totalSeconds.truncatingRemainder(dividingBy: 3600) - Double(second)) / 60)
    hour = Int(totalSeconds / 3600)
  }

  func toDegrees() -> Double {
    return 360 * Double(hour) / 24.0 + 360 * Double(minute) / (24 * 60.0) + 360 * Double(second) / (24 * 3600.0)
  }
}

extension DigitTime: CustomStringConvertible {
  var description: String { String(format: "%02i:%02i:%02i", hour, minute, second) }
}

let times = ["23:00:17", "23:40:20", "00:12:45", "00:17:19"].compactMap(DigitTime.init(fromString:))

guard times.count == 4 else {
  fatalError()
}

let meanTime = DigitTime(fromDegrees: 360 + meanOfAngles(times.map({ $0.toDegrees() })))

print("Given times \(times), the mean time is \(meanTime)")


proc meanTime {times} {
    set secsPerRad [expr {60 * 60 * 12 / atan2(0,-1)}]
    set sumSin [set sumCos 0.0]
    foreach t $times {
	# Convert time to count of seconds from midnight
	scan $t "%02d:%02d:%02d" h m s
	incr s [expr {[incr m [expr {$h * 60}]] * 60}]
	# Feed into averaging
	set sumSin [expr {$sumSin + sin($s / $secsPerRad)}]
	set sumCos [expr {$sumCos + cos($s / $secsPerRad)}]
    }
    # Don't need to divide by counts; atan2() cancels that out
    set a [expr {round(atan2($sumSin, $sumCos) * $secsPerRad)}]
    # Convert back to human-readable
    format "%02d:%02d:%02d" [expr {$a / 60 / 60 % 24}] [expr {$a / 60 % 60}] [expr {$a % 60}]
}

puts [meanTime {23:00:17 23:40:20 00:12:45 00:17:19}]


Public Sub mean_time()
    Dim angles() As Double
    s = [{"23:00:17","23:40:20","00:12:45","00:17:19"}]
    For i = 1 To UBound(s)
        s(i) = 360 * TimeValue(s(i))
    Next i
    Debug.Print Format(mean_angle(s) / 360 + 1, "hh:mm:ss")
End Sub


Module Module1

    Function TimeToDegrees(time As TimeSpan) As Double
        Return 360 * time.Hours / 24.0 + 360 * time.Minutes / (24 * 60.0) + 360 * time.Seconds / (24 * 3600.0)
    End Function

    Function DegreesToTime(angle As Double) As TimeSpan
        Return New TimeSpan((24 * 60 * 60 * angle \ 360) \ 3600, ((24 * 60 * 60 * angle \ 360) Mod 3600 - (24 * 60 * 60 * angle \ 360) Mod 60) \ 60, (24 * 60 * 60 * angle \ 360) Mod 60)
    End Function

    Function MeanAngle(angles As List(Of Double)) As Double
        Dim y_part = 0.0
        Dim x_part = 0.0
        Dim numItems = angles.Count

        For Each angle In angles
            x_part += Math.Cos(angle * Math.PI / 180)
            y_part += Math.Sin(angle * Math.PI / 180)
        Next

        Return Math.Atan2(y_part / numItems, x_part / numItems) * 180 / Math.PI
    End Function

    Sub Main()
        Dim digitimes As New List(Of Double)
        Dim digitime As TimeSpan
        Dim input As String

        Console.WriteLine("Enter times, end with no input: ")
        Do
            input = Console.ReadLine
            If Not String.IsNullOrWhiteSpace(input) Then
                If TimeSpan.TryParse(input, digitime) Then
                    digitimes.Add(TimeToDegrees(digitime))
                Else
                    Console.WriteLine("Seems this is wrong input: ingnoring time")
                End If
            End If
        Loop Until String.IsNullOrWhiteSpace(input)

        If digitimes.Count > 0 Then
            Console.WriteLine("The mean time is : {0}", DegreesToTime(360 + MeanAngle(digitimes)))
        End If
    End Sub

End Module


import math

const inputs = ["23:00:17", "23:40:20", "00:12:45", "00:17:19"]

fn main() {
    angles := inputs.map(time_to_degs(it))
    println('Mean time of day is: ${degs_to_time(mean_angle(angles))}')
}
fn mean_angle(angles []f64) f64 {
    n := angles.len
    mut sin_sum := f64(0)
    mut cos_sum := f64(0)
    for angle in angles {
        sin_sum += math.sin(angle * math.pi / 180)
        cos_sum += math.cos(angle * math.pi / 180)
    }
    return math.atan2(sin_sum/n, cos_sum/n) * 180 / math.pi
}

fn degs_to_time(dd f64) string{
    mut d := dd
    for d < 0 {
        d += 360
    }
    mut s := math.round(d * 240)
    h := math.floor(s/3600)
    mut m := math.fmod(s, 3600)
    s = math.fmod(m, 60)
    m = math.floor(m / 60)
    return "${h:02}:${m:02}:${s:02}"
}

fn time_to_degs(time string) f64 {
    t := time.split(":")
    h := t[0].f64() * 3600
    m := t[1].f64() * 60
    s := t[2].f64()
    return (h + m + s) / 240
}


import "/fmt" for Fmt

var timeToDegs = Fn.new { |time|
    var t = time.split(":")
    var h = Num.fromString(t[0]) * 3600
    var m = Num.fromString(t[1]) * 60
    var s = Num.fromString(t[2])
    return (h + m + s) / 240
}

var degsToTime = Fn.new { |d|
    while (d < 0) d = d + 360
    var s = (d * 240).round
    var h = (s/3600).floor
    var m = s % 3600
    s = m % 60
    m = (m / 60).floor
    return "%(Fmt.d(2, h)):%(Fmt.d(2, m)):%(Fmt.d(2, s))"
}

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 times = ["23:00:17", "23:40:20", "00:12:45", "00:17:19"]
var angles = times.map { |t| timeToDegs.call(t) }.toList
System.print("Mean time of day is : %(degsToTime.call(meanAngle.call(angles)))")


include c:\cxpl\codes;

proc NumOut(N);                 \Display 2-digit N with leading zero
int  N;
[if N<10 then ChOut(0, ^0);
IntOut(0, N);
];

proc TimeOut(Sec);              \Display real seconds as HH:MM:SS
real Sec;
[NumOut(fix(Sec)/3600);  ChOut(0, ^:);
 NumOut(rem(0)/60);      ChOut(0, ^:);
 NumOut(rem(0));
];

func real HMS2Sec(H, M, S);     \Convert hours, minutes, seconds to real seconds
int  H, M, S;
return float(((H*60 + M)*60) + S);

func real MeanTime(A);          \Return the mean of the given list of times
int  A;
real X, Y, Sec;
int  I;
def Pi  = 3.14159265358979323846;
def S2R = Pi/(12.*60.*60.);     \coefficient to convert seconds to radians
[X:= 0.0;  Y:= 0.0;
for I:= 1 to A(0) do
    [Sec:= HMS2Sec(A(I,0), A(I,1), A(I,2));
    X:= X + Cos(Sec*S2R);
    Y:= Y + Sin(Sec*S2R);
    ];
Sec:= ATan2(Y,X)/S2R;
if Sec < 0.0 then Sec:= Sec + 24.*60.*60.;
return Sec;
];

TimeOut(MeanTime([4, [23,00,17], [23,40,20], [00,12,45], [00,17,19]]))


sub atan2(y, x)
    return 2 * atan((sqrt(x **2 + y ** 2) - x) / y)
end sub

sub MeanAngle(angles())
    local x, y, ai_rad, l, i

    l = arraysize(angles(), 1)

    for i = 1 to l
        ai_rad = angles(i) * PI / 180
        x = x + cos(ai_rad)
        y = y + sin(ai_rad)
    next i
    if abs(x) < 1e-16 return false
    return atan2(y, x) * 180 / PI
end sub

sub toSecAngle(hours, minutes, seconds)
    return ((hours * 60 + minutes) * 60 + seconds) / (24 * 60 * 60) * 360
end sub

dim Times(4)

Times(1) = toSecAngle(23,00,17)
Times(2) = toSecAngle(23,40,20)
Times(3) = toSecAngle(00,12,45)
Times(4) = toSecAngle(00,17,19)

sub toHMS$(t)
    local s$

    if t then
        if t < 0 t = t + 360
        t = 24 * 60 * 60 * t / 360
        s$ = str$(int(t / 3600), "%02g") + ":" + str$(int(mod(t, 3600) / 60), "%02g") + ":" + str$(int(mod(t, 60)), "%02g")
    else
	s$ = "not meaningful"
    end if
    return s$
end sub

print "Mean Time is ", toHMS$(MeanAngle(Times()))

// Output: Mean Time is 23:47:43


var D=Time.Date;
fcn meanT(t1,t2,etc){
   ts:=vm.arglist.apply(fcn(hms){
     (D.toFloat(hms.split(":").xplode())*15).toRad()
   });
   n:=ts.len();
   mt:=(ts.apply("sin").sum(0.0)/n)
       .atan2(ts.apply("cos").sum(0.0)/n)
       .toDeg() /15;
   if(mt<0) mt+=24;  //-0.204622-->23.7954
   D.toHour(mt).concat(":")
}


INCLUDE "H6:REALMATH.ACT"

DEFINE PTR="CARD"

PROC Sort(PTR ARRAY a INT count)
  INT i,j,minpos
  REAL POINTER tmp

  FOR i=0 TO count-2
  DO
    minpos=i
    FOR j=i+1 TO count-1
    DO
      IF RealGreaterOrEqual(a(minpos),a(j)) THEN
        minpos=j
      FI
    OD

    IF minpos#i THEN
      tmp=a(i)
      a(i)=a(minpos)
      a(minpos)=tmp
    FI
  OD
RETURN

PROC Median(PTR ARRAY a INT count REAL POINTER res)
  IF count=0 THEN Break() FI
  Sort(a,count)
  IF (count&1)=0 THEN
    RealAdd(a(count RSH 1-1),a(count RSH 1),res)
    RealMult(res,half,res)
  ELSE
    RealAssign(a(count RSH 1),res)
  FI
RETURN

PROC Test(PTR ARRAY a INT count)
  INT i
  REAL res

  FOR i=0 TO count-1
  DO
    PrintR(a(i)) Put(32)
  OD
  Median(a,count,res)
  Print("-> ")
  PrintRE(res)
RETURN

PROC Main()
  PTR ARRAY a(8)
  REAL r1,r2,r3,r4,r5,r6,r7,r8
  BYTE i

  Put(125) PutE() ;clear the screen
  MathInit()
  ValR("3.2",r1)  ValR("-4.1",r2)
  ValR("0.6",r3)  ValR("9.8",r4)
  ValR("5.1",r5)  ValR("-1.4",r6)
  ValR("0.3",r7) ValR("2.2",r8)
  FOR i=1 TO 8
  DO
    a(0)=r1 a(1)=r2 a(2)=r3 a(3)=r4
    a(4)=r5 a(5)=r6 a(6)=r7 a(7)=r8
    Test(a,i)
  OD
RETURN


with Ada.Text_IO, Ada.Float_Text_IO;

procedure FindMedian is

    f: array(1..10) of float := ( 4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5 );
    min_idx: integer;
    min_val, median_val, swap: float;

begin
    for i in f'range loop
        min_idx := i;
        min_val := f(i);
        for j in i+1 .. f'last loop
            if f(j) < min_val then
                min_idx := j;
                min_val := f(j);
            end if;
        end loop;
        swap := f(i); f(i) := f(min_idx); f(min_idx) := swap;
    end loop;

    if f'length mod 2 /= 0 then
        median_val := f( f'length/2+1 );
    else
        median_val := ( f(f'length/2) + f(f'length/2+1) ) / 2.0;
    end if;

    Ada.Text_IO.Put( "Median value: " );
    Ada.Float_Text_IO.Put( median_val );
    Ada.Text_IO.New_line;
end FindMedian;


INT max_elements = 1000000;

# Return the k-th smallest item in array x of length len #
PROC quick_select = (INT k, REF[]REAL x) REAL:
   BEGIN

      PROC swap = (INT a, b) VOID:
         BEGIN
	    REAL t = x[a];
	    x[a] := x[b]; x[b] := t
         END;

      INT left := 1, right := UPB x;
      INT pos, i;
      REAL pivot;

      WHILE left < right DO
	 pivot := x[k];
	 swap (k, right);
	 pos := left;
	 FOR i FROM left TO right DO
	    IF x[i] < pivot THEN
	       swap (i, pos);
	       pos +:= 1
	    FI
	 OD;
	 swap (right, pos);
	 IF pos = k THEN break FI;
	 IF pos < k THEN left := pos + 1
	 ELSE right := pos - 1
         FI
      OD;
break:
      SKIP;
      x[k]
   END;

 # Initialize random length REAL array with random doubles #
 INT length = ENTIER (next random * max_elements);
 [length]REAL x;
 FOR i TO length DO
    x[i] := (next random * 1e6 - 0.5e6)
 OD;

 REAL median :=
    IF NOT ODD length THEN
       # Even number of elements, median is average of middle two #
       (quick_select (length % 2, x) + quick_select(length % 2 - 1, x)) / 2
    ELSE
       # select middle element #
       quick_select(length % 2, x)
    FI;

 # Sanity testing of median #
 INT less := 0, more := 0, eq := 0;
 FOR i TO length DO
    IF x[i] < median THEN less +:= 1
    ELIF x[i] > median THEN more +:= 1
    ELSE eq +:= 1
    FI
 OD;
 print (("length: ", whole (length,0), new line, "median: ", median, new line,
	 "<: ", whole (less,0), new line,
	 ">: ", whole (more, 0), new line,
	 "=: ", whole (eq, 0), new line))


median←{v←⍵[⍋⍵]⋄.5×v[⌈¯1+.5×⍴v]+v[⌊.5×⍴v]} ⍝ Assumes ⎕IO←0


set alist to {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}
set med to medi(alist)

on medi(alist)

    set temp to {}
    set lcount to count alist
    if lcount is equal to 2 then
        return ((item 1 of alist) + (item 2 of alist)) / 2
    else if lcount is less than 2 then
        return item 1 of alist
    else --if lcount is greater than 2
        set min to findmin(alist)
        set max to findmax(alist)
        repeat with x from 1 to lcount
            if x is not equal to min and x is not equal to max then set end of temp to item x of alist
        end repeat
        set med to medi(temp)
    end if
    return med

end medi

on findmin(alist)

    set min to 1
    set alength to count every item of alist
    repeat with x from 1 to alength
        if item x of alist is less than item min of alist then set min to x
    end repeat
    return min

end findmin

on findmax(alist)

    set max to 1
    set alength to count every item of alist
    repeat with x from 1 to alength
        if item x of alist is greater than item max of alist then set max to x
    end repeat
    return max

end findmax


 100 REMMEDIAN
 110 K = INT(L/2) : GOSUB 150
 120 R = X(K)
 130 IF L - 2 *  INT (L / 2) THEN R = (R + X(K + 1)) / 2
 140 RETURN

 150 REMQUICK SELECT
 160 LT = 0:RT = L - 1
 170 FOR J = LT TO RT STEP 0
 180     PT = X(K)
 190     P1 = K:P2 = RT: GOSUB 300
 200     P = LT
 210     FOR I = P TO RT - 1
 220         IF X(I) < PT THEN P1 = I:P2 = P: GOSUB 300:P = P + 1
 230     NEXT I
 240     P1 = RT:P2 = P: GOSUB 300
 250     IF P = K THEN  RETURN
 260     IF P < K THEN LT = P + 1
 270     IF P >  = K THEN RT = P - 1
 280 NEXT J
 290 RETURN

 300 REMSWAP
 310 H = X(P1):X(P1) = X(P2)
 320 X(P2) = H: RETURN


arr:  [1 2 3 4 5 6 7]
arr2: [1 2 3 4 5 6]

print median arr
print median arr2


seq = 4.1, 7.2, 1.7, 9.3, 4.4, 3.2, 5
MsgBox % median(seq, "`,")  ; 4.1

median(seq, delimiter)
{
  Sort, seq, ND%delimiter%
  StringSplit, seq, seq, % delimiter
  median := Floor(seq0 / 2)
  Return seq%median%
}


#!/usr/bin/awk -f

BEGIN {
    d[1] = 3.0
    d[2] = 4.0
    d[3] = 1.0
    d[4] = -8.4
    d[5] = 7.2
    d[6] = 4.0
    d[7] = 1.0
    d[8] = 1.2
    showD("Before: ")
    gnomeSortD()
    showD("Sorted: ")
    printf "Median: %f\n", medianD()
    exit
}

function medianD(     len, mid) {
    len = length(d)
    mid = int(len/2) + 1
    if (len % 2) return d[mid]
    else return (d[mid] + d[mid-1]) / 2.0
}

function gnomeSortD(    i) {
    for (i = 2; i <= length(d); i++) {
        if (d[i] < d[i-1]) gnomeSortBackD(i)
    }
}

function gnomeSortBackD(i,     t) {
    for (; i > 1 && d[i] < d[i-1]; i--) {
        t = d[i]
        d[i] = d[i-1]
        d[i-1] = t
    }
}

function showD(p,   i) {
    printf p
    for (i = 1; i <= length(d); i++) {
        printf d[i] " "
    }
    print ""
}


DECLARE a[] = { 4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2 } TYPE FLOATING
DECLARE b[] = { 4.1, 7.2, 1.7, 9.3, 4.4, 3.2 } TYPE FLOATING

DEF FN Dim(x) = SIZEOF(x) / SIZEOF(double)

DEF FN Median(x) = IIF(ODD(Dim(x)), x[(Dim(x)-1)/2], (x[Dim(x)/2-1]+x[Dim(x)/2])/2 )

SORT a
PRINT "Median of a: ", Median(a)

SORT b
PRINT "Median of b: ", Median(b)


DECLARE FUNCTION median! (vector() AS SINGLE)

DIM vec1(10) AS SINGLE, vec2(11) AS SINGLE, n AS INTEGER

RANDOMIZE TIMER

FOR n = 0 TO 10
    vec1(n) = RND * 100
    vec2(n) = RND * 100
NEXT
vec2(11) = RND * 100

PRINT median(vec1())
PRINT median(vec2())

FUNCTION median! (vector() AS SINGLE)
    DIM lb AS INTEGER, ub AS INTEGER, L0 AS INTEGER
    lb = LBOUND(vector)
    ub = UBOUND(vector)
    REDIM v(lb TO ub) AS SINGLE
    FOR L0 = lb TO ub
        v(L0) = vector(L0)
    NEXT
    quicksort v(), lb, ub
    IF ((ub - lb + 1) MOD 2) THEN
        median = v((ub + lb) / 2)
    ELSE
        median = (v(INT((ub + lb) / 2)) + v(INT((ub + lb) / 2) + 1)) / 2
    END IF
END FUNCTION


      INSTALL @lib$+"SORTLIB"
      Sort% = FN_sortinit(0,0)

      DIM a(6), b(5)
      a() = 4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2
      b() = 4.1, 7.2, 1.7, 9.3, 4.4, 3.2

      PRINT "Median of a() is " ; FNmedian(a())
      PRINT "Median of b() is " ; FNmedian(b())
      END

      DEF FNmedian(a())
      LOCAL C%
      C% = DIM(a(),1) + 1
      CALL Sort%, a(0)
      = (a(C% DIV 2) + a((C%-1) DIV 2)) / 2


(median=
  begin decimals end int list med med1 med2 num number
.   0:?list
  &   whl
    ' ( @( !arg
         :   ?
             ((%@:~" ":~",") ?:?number)
             ((" "|",") ?arg|:?arg)
         )
      & @( !number
         : (   #?int "." [?begin #?decimals [?end
             & !int+!decimals*10^(!begin+-1*!end):?num
           | ?num
           )
         )
      & (!num.)+!list:?list
      )
  & !list:?+[?end
  & (   !end*1/2:~/
      & !list:?+[!(=1/2*!end+-1)+(?med1.)+(?med2.)+?
      & !med1*1/2+!med2*1/2:?med
    | !list:?+[(div$(1/2*!end,1))+(?med.)+?
    )
  & !med
);


#include <stdio.h>
#include <stdlib.h>

typedef struct floatList {
    float *list;
    int   size;
} *FloatList;

int floatcmp( const void *a, const void *b) {
    if (*(const float *)a < *(const float *)b) return -1;
    else return *(const float *)a > *(const float *)b;
}

float median( FloatList fl )
{
    qsort( fl->list, fl->size, sizeof(float), floatcmp);
    return 0.5 * ( fl->list[fl->size/2] + fl->list[(fl->size-1)/2]);
}

int main()
{
    static float floats1[] = { 5.1, 2.6, 6.2, 8.8, 4.6, 4.1 };
    static struct floatList flist1 = { floats1, sizeof(floats1)/sizeof(float) };

    static float floats2[] = { 5.1, 2.6, 8.8, 4.6, 4.1 };
    static struct floatList flist2 = { floats2, sizeof(floats2)/sizeof(float) };

    printf("flist1 median is %7.2f\n", median(&flist1)); /* 4.85 */
    printf("flist2 median is %7.2f\n", median(&flist2)); /* 4.60 */
    return 0;
}


using System;
using System.Linq;

namespace Test
{
    class Program
    {
        static void Main()
        {
            double[] myArr = new double[] { 1, 5, 3, 6, 4, 2 };

            myArr = myArr.OrderBy(i => i).ToArray();
            // or Array.Sort(myArr) for in-place sort

            int mid = myArr.Length / 2;
            double median;

            if (myArr.Length % 2 == 0)
            {
                //we know its even
                median = (myArr[mid] + myArr[mid - 1]) / 2.0;
            }
            else
            {
                //we know its odd
                median = myArr[mid];
            }

            Console.WriteLine(median);
            Console.ReadLine();
        }
    }
}


#include <algorithm>

// inputs must be random-access iterators of doubles
// Note: this function modifies the input range
template <typename Iterator>
double median(Iterator begin, Iterator end) {
  // this is middle for odd-length, and "upper-middle" for even length
  Iterator middle = begin + (end - begin) / 2;

  // This function runs in O(n) on average, according to the standard
  std::nth_element(begin, middle, end);

  if ((end - begin) % 2 != 0) { // odd length
    return *middle;
  } else { // even length
    // the "lower middle" is the max of the lower half
    Iterator lower_middle = std::max_element(begin, middle);
    return (*middle + *lower_middle) / 2.0;
  }
}

#include <iostream>

int main() {
  double a[] = {4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2};
  double b[] = {4.1, 7.2, 1.7, 9.3, 4.4, 3.2};

  std::cout << median(a+0, a + sizeof(a)/sizeof(a[0])) << std::endl; // 4.4
  std::cout << median(b+0, b + sizeof(b)/sizeof(b[0])) << std::endl; // 4.25

  return 0;
}


(defn median [ns]
  (let [ns (sort ns)
        cnt (count ns)
        mid (bit-shift-right cnt 1)]
    (if (odd? cnt)
      (nth ns mid)
      (/ (+ (nth ns mid) (nth ns (dec mid))) 2))))


((defun select-nth (n list predicate)
  "Select nth element in list, ordered by predicate, modifying list."
  (do ((pivot (pop list))
       (ln 0) (left '())
       (rn 0) (right '()))
      ((endp list)
       (cond
        ((< n ln) (select-nth n left predicate))
        ((eql n ln) pivot)
        ((< n (+ ln rn 1)) (select-nth (- n ln 1) right predicate))
        (t (error "n out of range."))))
    (if (funcall predicate (first list) pivot)
      (psetf list (cdr list)
             (cdr list) left
             left list
             ln (1+ ln))
      (psetf list (cdr list)
             (cdr list) right
             right list
             rn (1+ rn)))))

(defun median (list predicate)
  (select-nth (floor (length list) 2) list predicate))


import std.stdio, std.algorithm;

T median(T)(T[] nums) pure nothrow {
    nums.sort();
    if (nums.length & 1)
        return nums[$ / 2];
    else
        return (nums[$ / 2 - 1] + nums[$ / 2]) / 2.0;
}

void main() {
    auto a1 = [5.1, 2.6, 6.2, 8.8, 4.6, 4.1];
    writeln("Even median: ", a1.median);

    auto a2 = [5.1, 2.6, 8.8, 4.6, 4.1];
    writeln("Odd median:  ", a2.median);
}


program AveragesMedian;

{$APPTYPE CONSOLE}

uses Generics.Collections, Types;

function Median(aArray: TDoubleDynArray): Double;
var
  lMiddleIndex: Integer;
begin
  TArray.Sort<Double>(aArray);

  lMiddleIndex := Length(aArray) div 2;
  if Odd(Length(aArray)) then
    Result := aArray[lMiddleIndex]
  else
    Result := (aArray[lMiddleIndex - 1] + aArray[lMiddleIndex]) / 2;
end;

begin
  Writeln(Median(TDoubleDynArray.Create(4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2)));
  Writeln(Median(TDoubleDynArray.Create(4.1, 7.2, 1.7, 9.3, 4.4, 3.2)));
end.


def median(list) {
    def sorted := list.sort()
    def count := sorted.size()
    def mid1 := count // 2
    def mid2 := (count - 1) // 2
    if (mid1 == mid2) {          # avoid inexact division
        return sorted[mid1]
    } else {
        return (sorted[mid1] + sorted[mid2]) / 2
    }
}


func quickselect k . list[] res .
  #
  subr partition
    swap list[(left + right) / 2] list[left]
    mid = left
    for i = left + 1 to right
      if list[i] < list[left]
        mid += 1
        swap list[i] list[mid]
      .
    .
    swap list[left] list[mid]
  .
  left = 0
  right = len list[] - 1
  while left < right
    call partition
    if mid < k
      left = mid + 1
    elif mid > k
      right = mid - 1
    else
      left = right
    .
  .
  res = list[k]
.
func median . list[] res .
  h = len list[] / 2
  call quickselect h list[] res
  if len list[] mod 2 = 0
    call quickselect h - 1 list[] h
    res = (res + h) / 2
  .
.
test[] = [ 4.1 5.6 7.2 1.7 9.3 4.4 3.2 ]
call median test[] med
print med
test[] = [ 4.1 7.2 1.7 9.3 4.4 3.2 ]
call median test[] med
print med


(define (median L) ;; O(n log(n))
	(set! L (vector-sort! < (list->vector L)))
	(define dim (// (vector-length L) 2))
	(if (integer? dim)
		(// (+ [L dim] [L (1- dim)]) 2)
		[L (floor dim)]))

(median '( 3 4 5))
   → 4
(median '(6 5 4 3))
   → 4.5
(median (iota 10000))
   → 4999.5
(median (iota 10001))
   → 5000


import system'routines;
import system'math;
import extensions;

extension op
{
    get Median()
    {
        var sorted := self.ascendant();

        var len := sorted.Length;
        if (len == 0)
        {
            ^ nil
        }
        else
        {
            var middleIndex := len / 2;
            if (len.mod:2 == 0)
            {
                ^ (sorted[middleIndex - 1] + sorted[middleIndex]) / 2
            }
            else
            {
                ^ sorted[middleIndex]
            }
        }
    }
}

public program()
{
    var a1 := new real[]{4.1r, 5.6r, 7.2r, 1.7r, 9.3r, 4.4r, 3.2r};
    var a2 := new real[]{4.1r, 7.2r, 1.7r, 9.3r, 4.4r, 3.2r};

    console.printLine("median of (",a1.asEnumerable(),") is ",a1.Median);
    console.printLine("median of (",a2.asEnumerable(),") is ",a2.Median);

    console.readChar()
}


defmodule Average do
  def median([]), do: nil
  def median(list) do
    len = length(list)
    sorted = Enum.sort(list)
    mid = div(len, 2)
    if rem(len,2) == 0, do: (Enum.at(sorted, mid-1) + Enum.at(sorted, mid)) / 2,
                      else: Enum.at(sorted, mid)
  end
end

median = fn list -> IO.puts "#{inspect list} => #{inspect Average.median(list)}" end
median.([])
Enum.each(1..6, fn i ->
  (for _ <- 1..i, do: :rand.uniform(6)) |> median.()
end)


-module(median).
-import(lists, [nth/2, sort/1]).
-compile(export_all).

test(MaxInt,ListSize,TimesToRun) ->
    test(MaxInt,ListSize,TimesToRun,[[],[]]).

test(_,_,0,[GMAcc, OMAcc]) ->
    Len = length(GMAcc),
    {GMT,GMV} = lists:foldl(fun({T, V}, {AT,AV}) -> {AT + T, AV + V} end, {0,0}, GMAcc),
    {OMT,OMV} = lists:foldl(fun({T, V}, {AT,AV}) -> {AT + T, AV + V} end, {0,0}, OMAcc),
    io:format("QuickSelect Time: ~p, Val: ~p~nOriginal Time: ~p, Val: ~p~n", [GMT/Len, GMV/Len, OMT/Len, OMV/Len]);
test(M,N,T,[GMAcc, OMAcc]) ->
    L = [rand:uniform(M) || _ <- lists:seq(1,N)],
    GM = timer:tc(fun() -> qs_median(L) end),
    OM = timer:tc(fun() -> median(L) end),
    test(M,N,T-1,[[GM|GMAcc], [OM|OMAcc]]).

median(Unsorted) ->
    Sorted = sort(Unsorted),
    Length = length(Sorted),
    Mid = Length div 2,
    Rem = Length rem 2,
    (nth(Mid+Rem, Sorted) + nth(Mid+1, Sorted)) / 2.

% ***********************************************************
% median based on quick select with optimizations for repeating numbers
% if it really matters it's a little faster
% by Roman Rabinovich
% ***********************************************************

qs_median([]) -> error;
qs_median([X]) -> X;
qs_median([P|_Tail] = List) ->
    TargetPos = length(List)/2 + 0.5,
    qs_median(List, TargetPos, P, 0).

qs_median([X], 1, _, 0) ->  X;
qs_median([X], 1, _, Acc) ->  (X + Acc)/2;
qs_median([P|Tail], TargetPos, LastP, Acc) ->
    Smaller = [X || X <- Tail, X < P],
    LS = length(Smaller),
    qs_continue(P, LS, TargetPos, LastP, Smaller, Tail, Acc).

qs_continue(P, LS, TargetPos, _, _, _, 0) when LS + 1 == TargetPos -> P;
qs_continue(P, LS, TargetPos, _, _, _, Acc) when LS + 1 == TargetPos -> (P + Acc)/2;
qs_continue(P, 0, TargetPos, LastP, _SM, _TL, _Acc) when TargetPos == 0.5 ->
    (P+LastP)/2;
qs_continue(P, LS, TargetPos, _LastP, SM, _TL, _Acc) when TargetPos == LS + 0.5 ->
    qs_median(SM, TargetPos - 0.5, P, P);
qs_continue(P, LS, TargetPos, _LastP, SM, _TL, Acc) when LS + 1 > TargetPos  ->
    qs_median(SM, TargetPos, P, Acc);
qs_continue(P, LS, TargetPos, _LastP, _SM, TL, Acc) ->
    Larger = [X || X <- TL, X >= P],
    NewPos= TargetPos - LS -1,
    case NewPos == 0.5 of
        true ->
            qs_median(Larger, 1, P, P);
        false ->
            qs_median(Larger, NewPos, P, Acc)
    end.


PROGRAM MEDIAN

DIM X[10]

PROCEDURE QUICK_SELECT
    LT=0 RT=L-1
    J=LT
    REPEAT
        PT=X[K]
        SWAP(X[K],X[RT])
        P=LT
        FOR I=P TO RT-1 DO
            IF X[I]<PT THEN SWAP(X[I],X[P]) P=P+1 END IF
        END FOR
        SWAP(X[RT],X[P])
        IF P=K THEN EXIT PROCEDURE END IF
        IF P<K THEN LT=P+1 END IF
        IF P>=K THEN RT=P-1 END IF
    UNTIL J>RT
END PROCEDURE

PROCEDURE MEDIAN
    K=INT(L/2)
    QUICK_SELECT
    R=X[K]
    IF L-2*INT(L/2)<>0 THEN R=(R+X[K+1])/2 END IF
END PROCEDURE

BEGIN
   PRINT(CHR$(12);) !CLS
   X[0]=4.4 X[1]=2.3 X[2]=-1.7 X[3]=7.5 X[4]=6.6 X[5]=0
   X[6]=1.9 X[7]=8.2 X[8]=9.3 X[9]=4.5 X[10]=-11.7
   L=11
   MEDIAN
   PRINT(R)
END PROGRAM


>type median
 function median (x, v: none, p)

 ## Default for v : none
 ## Default for p : 0.5

     m=rows(x);
     if m>1 then
         y=zeros(m,1);
         loop 1 to m;
             y[#]=median(x[#],v,p);
         end;
         return y;
     else
         if v<>none then
             {xs,i}=sort(x); vsh=v[i];
             n=cols(xs);
             ns=sum(vsh);
             i=1+p*(ns-1); i0=floor(i);
             vs=cumsum(vsh);
             loop 1 to n
                 if vs[#]>i0 then
                     return xs[#];
                 elseif vs[#]+1>i0 then
                     k=#+1;
                     repeat;
                         if vsh[k]>0 or k>n then break; endif;
                         k=k+1;
                     end;
                     return (1-(i-i0))*xs[#]+(i-i0)*xs[k]+0;
                 endif;
             end;
             return xs[n];
         else
             xs=sort(x);
             n=cols(x);
             i=1+p*(n-1); i0=floor(i);
             if i0==n then return xs[n]; endif;
             return (i-i0)*xs[i+1]+(1-(i-i0))*xs[i];
         endif;
     endif;
 endfunction
>median(1:10)
 5.5
>median(1:9)
 5
>median(1:10,p=0.2)
 2.8
>0.2*10+0.8*1
 2.8


function median(sequence s)
    atom min,k
    -- Selection sort of half+1
    for i = 1 to length(s)/2+1 do
        min = s[i]
        k = 0
        for j = i+1 to length(s) do
            if s[j] < min then
                min = s[j]
                k = j
            end if
        end for
        if k then
            s[k] = s[i]
            s[i] = min
        end if
    end for
    if remainder(length(s),2) = 0 then
        return (s[$/2]+s[$/2+1])/2
    else
        return s[$/2+1]
    end if
end function

? median({ 4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5 })


let rec splitToFives list =
    match list with
        | a::b::c::d::e::tail ->
            ([a;b;c;d;e])::(splitToFives tail)
        | [] -> []
        | _ ->
                let left = 5 - List.length (list)
                let last = List.append list (List.init left (fun _ -> System.Double.PositiveInfinity) )
                in [last]

let medianFromFives =
    List.map ( fun (i:float list) ->
        List.nth (List.sort i) 2 )

let start l =
    let rec magicFives list k =
        if List.length(list) <= 10 then
            List.nth (List.sort list) (k-1)
        else
            let s = splitToFives list
            let M = medianFromFives s
            let m = magicFives M (int(System.Math.Ceiling((float(List.length M))/2.)))
            let (ll,lg) = List.partition ( fun i -> i < m ) list
            let (le,lg) = List.partition ( fun i -> i = m ) lg
            in
               if (List.length ll >= k) then
                    magicFives ll k
               else if (List.length ll + List.length le >= k ) then m
               else
                    magicFives lg (k-(List.length ll)-(List.length le))
    in
        let len = List.length l in
        if (len % 2 = 1) then
            magicFives l ((len+1)/2)
        else
            let a = magicFives l (len/2)
            let b = magicFives l ((len/2)+1)
            in (a+b)/2.

let z = [1.;5.;2.;8.;7.;2.]
start z
let z' = [1.;5.;2.;8.;7.]
start z'


USING: arrays kernel locals math math.functions random sequences ;
IN: median

: pivot ( seq -- pivot ) random ;

: split ( seq pivot -- {lt,eq,gt} )
  [ [ < ] curry partition ] keep
  [ = ] curry partition
  3array ;

DEFER: nth-in-order
:: nth-in-order-recur ( seq ind -- elt )
  seq dup pivot split
  dup [ length ] map  0 [ + ] accumulate nip
  dup [ ind <= [ 1 ] [ 0 ] if ] map sum 1 -
  [ swap nth ] curry [email protected]
  ind swap -
  nth-in-order ;

: nth-in-order ( seq ind -- elt )
  dup 0 =
  [ drop first ]
  [ nth-in-order-recur ]
  if ;

: median ( seq -- median )
  dup length 1 - 2 / floor nth-in-order ;


-1 cells constant -cell
: cell-   -cell + ;

defer lessthan ( [email protected] [email protected] -- ? )   ' < is lessthan

: mid ( l r -- mid ) over - 2/ -cell and + ;

: exch ( addr1 addr2 -- ) dup @ >r over @ swap ! r> swap ! ;

: part ( l r -- l r r2 l2 )
  2dup mid @ >r ( r: pivot )
  2dup begin
    swap begin dup @  [email protected] lessthan while cell+ repeat
    swap begin [email protected] over @ lessthan while cell- repeat
    2dup <= if 2dup exch >r cell+ r> cell- then
  2dup > until  r> drop ;

0 value midpoint

: select ( l r -- )
  begin 2dup < while
    part
    dup  midpoint >= if nip nip ( l l2 ) else
    over midpoint <= if drop rot drop swap ( r2 r ) else
    2drop 2drop exit then then
  repeat 2drop ;

: median ( array len -- m )
  1- cells over +  2dup mid to midpoint
  select           midpoint @ ;


program Median_Test

  real            :: a(7) = (/ 4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2 /), &
                     b(6) = (/ 4.1, 7.2, 1.7, 9.3, 4.4, 3.2 /)

  print *, median(a)
  print *, median(b)

contains

  function median(a, found)
    real, dimension(:), intent(in) :: a
      ! the optional found argument can be used to check
      ! if the function returned a valid value; we need this
      ! just if we suspect our "vector" can be "empty"
    logical, optional, intent(out) :: found
    real :: median

    integer :: l
    real, dimension(size(a,1)) :: ac

    if ( size(a,1) < 1 ) then
       if ( present(found) ) found = .false.
    else
       ac = a
       ! this is not an intrinsic: peek a sort algo from
       ! Category:Sorting, fixing it to work with real if
       ! it uses integer instead.
       call sort(ac)

       l = size(a,1)
       if ( mod(l, 2) == 0 ) then
          median = (ac(l/2+1) + ac(l/2))/2.0
       else
          median = ac(l/2+1)
       end if

       if ( present(found) ) found = .true.
    end if

  end function median

end program Median_Test


' FB 1.05.0 Win64

Sub quicksort(a() As Double, first As Integer, last As Integer)
  Dim As Integer length = last - first + 1
  If length < 2 Then Return
  Dim pivot As Double = a(first + length\ 2)
  Dim lft As Integer = first
  Dim rgt As Integer = last
  While lft <= rgt
    While a(lft) < pivot
      lft +=1
    Wend
    While a(rgt) > pivot
      rgt -= 1
    Wend
    If lft <= rgt Then
       Swap a(lft), a(rgt)
       lft += 1
       rgt -= 1
    End If
  Wend
  quicksort(a(), first, rgt)
  quicksort(a(), lft, last)
End Sub

Function median(a() As Double) As Double
  Dim lb As Integer = LBound(a)
  Dim ub As Integer = UBound(a)
  Dim length As Integer = ub - lb + 1
  If length = 0 Then Return 0.0/0.0 '' NaN
  If length = 1 Then Return a(ub)
  Dim mb As Integer = (lb + ub) \2
  If length Mod 2 = 1 Then Return a(mb)
  Return (a(mb) + a(mb + 1))/2.0
End Function

Dim a(0 To 9) As Double = {4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5}
quicksort(a(), 0, 9)
Print "Median for all 10 elements  : "; median(a())
' now get rid of final element
Dim b(0 To 8) As Double = {4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3}
quicksort(b(), 0, 8)
Print "Median for first 9 elements : "; median(b())
Print
Print "Press any key to quit"
Sleep


package main

import (
    "fmt"
    "sort"
)

func main() {
    fmt.Println(median([]float64{3, 1, 4, 1}))    // prints 2
    fmt.Println(median([]float64{3, 1, 4, 1, 5})) // prints 3
}

func median(a []float64) float64 {
    sort.Float64s(a)
    half := len(a) / 2
    m := a[half]
    if len(a)%2 == 0 {
        m = (m + a[half-1]) / 2
    }
    return m
}


def median(Iterable col) {
    def s = col as SortedSet
    if (s == null) return null
    if (s.empty) return 0
    def n = s.size()
    def m = n.intdiv(2)
    def l = s.collect { it }
    n%2 == 1 ? l[m] : (l[m] + l[m-1])/2
}


import Data.List (partition)

nth :: Ord t => [t] -> Int -> t
nth (x:xs) n
  | k == n = x
  | k > n = nth ys n
  | otherwise = nth zs $ n - k - 1
  where
    (ys, zs) = partition (< x) xs
    k = length ys

medianMay :: (Fractional a, Ord a) => [a] -> Maybe a
medianMay xs
  | n < 1 = Nothing
  | even n = Just ((nth xs (div n 2) + nth xs (div n 2 - 1)) / 2.0)
  | otherwise = Just (nth xs (div n 2))
  where
    n = length xs

main :: IO ()
main =
  mapM_
    (printMay . medianMay)
    [[], [7], [5, 3, 4], [5, 4, 2, 3], [3, 4, 1, -8.4, 7.2, 4, 1, 1.2]]
  where
    printMay = maybe (putStrLn "(not defined)") print


REAL :: n=10, vec(n)

vec = RAN(1)
SORT(Vector=vec, Sorted=vec) ! in-place Merge-Sort

IF( MOD(n,2) ) THEN  ! odd n
    median = vec( CEILING(n/2) )
ELSE
    median = ( vec(n/2) + vec(n/2 + 1) ) / 2
ENDIF


procedure main(args)
    write(median(args))
end

procedure median(A)
    A := sort(A)
    n := *A
    return if n % 2 = 1 then A[n/2+1]
           else (A[n/2]+A[n/2+1])/2.0 | 0  # 0 if empty list
end


  require 'stats/base'
  median 1 9 2 4
3


// Note: this function modifies the input list
public static double median(List<Double> list) {
    Collections.sort(list);
    return (list.get(list.size() / 2) + list.get((list.size() - 1) / 2)) / 2;
}


function median(ary) {
    if (ary.length == 0)
        return null;
    ary.sort(function (a,b){return a - b})
    var mid = Math.floor(ary.length / 2);
    if ((ary.length % 2) == 1)  // length is odd
        return ary[mid];
    else
        return (ary[mid - 1] + ary[mid]) / 2;
}

median([]);   // null
median([5,3,4]);  // 4
median([5,4,2,3]);  // 3.5
median([3,4,1,-8.4,7.2,4,1,1.2]);  // 2.1


def median:
  length as $length
  | sort as $s
  | if $length == 0 then null
    else ($length / 2 | floor) as $l2
      | if ($length % 2) == 0 then
          ($s[$l2 - 1] + $s[$l2]) / 2
        else $s[$l2]
        end
  end ;


using Statistics
function median2(n)
	s = sort(n)
	len = length(n)
	if len % 2 == 0
		return (s[floor(Int, len / 2) + 1] + s[floor(Int, len / 2)]) / 2
	else
		return  s[floor(Int, len / 2) + 1]
	end
end

a = [4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]
b = [4.1, 7.2, 1.7, 9.3, 4.4, 3.2]

@show a b median2(a) median(a) median2(b) median(b)