Averages/Mean time of day: Difference between revisions

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

{{trans|Python}}

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

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

R ‘#02:#02:#02’.format(h, m, s)

{{out}}

<pre>23:47:43</pre>

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

DEFINE PTR="CARD"

AverageTime(times,COUNT,t)

Print("Mean time is ") PrintTime(t)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Mean_time_of_day.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Command_Line;

with Ada.Numerics.Elementary_Functions;

Ada.Text_IO.Put_Line ("Usage: mean_time_of_day <time-1> ...");

Ada.Text_IO.Put_Line (" <time-1> ... 'HH:MM:SS' format");

{{out}}

<pre>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

MeanTime(t, x=0, y=0) {

atan2(x, y) {

return dllcall("msvcrt\atan2", "Double",y, "Double",x, "CDECL Double")

{{out}}

<pre>The mean time is: 23:47:43</pre>

=={{header|AWK}}==

{

c = atan2(0,-1)/(12*60*60);

if (p<0) p += 24*60*60;

print strftime("%T",p,1);

<pre>$ echo 23:00:17, 23:40:20, 00:12:45, 00:17:19 | awk -f mean_time_of_day.awk

23:47:43</pre>

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

{{works with|BBC BASIC for Windows}}

DATA 23:00:17, 23:40:20, 00:12:45, 00:17:19

DEF FNatan2(y,x) : ON ERROR LOCAL = SGN(y)*PI/2

{{out}}

<pre>

=={{header|C}}==

#include<math.h>

#include<stdio.h>

meanTime.second);

return 0;

{{out}}

<pre>

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

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>

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

#include <iostream>

#include <vector>

return 0;

{{out}}

<pre>23:47:43</pre>

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

{{trans|Echo Lisp}}

(eval-when (:compile-toplevel :load-toplevel :execute)

(ql:quickload '("split-sequence")))

(reduce #'+ (mapcar (lambda (time)

(make-polar 1 (time->radian time))) times)))))

{{out}}

=={{header|D}}==

{{trans|Python}}

std.format, std.conv;

void main() @safe {

["23:00:17", "23:40:20", "00:12:45", "00:17:19"].meanTime.writeln;

{{out}}

<pre>23:47:43</pre>

{{libheader| System.Math}}

{{Trans|Go}}

program Averages_Mean_time_of_day;

writeln(TimeToStr(MeanTime(ToTimes(Inputs))));

readln;

=={{header|EchoLisp}}==

;; string hh:mm:ss to radians

(define (time->radian time)

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

→ "23:47:43"

=={{header|Erlang}}==

-module( mean_time_of_day ).

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

Secs = Seconds - (Hours * 3600) - (Minutes * 60),

lists:flatten( io_lib:format("~2.10.0B:~2.10.0B:~2.10.0B", [Hours, Minutes, Secs]) ).

{{out}}

<pre>

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

include std/console.e

include std/math.e

if getc(0) then end if

{{out}}

<pre>

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

open System.Numerics

|> deg2time |> fun t -> t.ToString(@"hh\:mm\:ss")

|> printfn "%s: %s" msg

{{out}}

<pre>>RosettaCode 23:00:17 23:40:20 00:12:45 00:17:19

=={{header|Factor}}==

math.functions math.libm math.parser math.trig qw sequences

splitting ;

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

{{out}}

<pre>

=={{header|Fortran}}==

{{works with|gfortran 5.1.0}}

program mean_time_of_day

implicit none

end function

end program

{{out}}

<pre>

=={{header|FreeBASIC}}==

Const pi As Double = 3.1415926535897932

Print

Print "Press any key to quit"

{{out}}

=={{header|Go}}==

import (

_, dayFrac := math.Modf(1 + math.Atan2(ssum, csum)/(2*math.Pi))

return mean.Add(time.Duration(dayFrac * 24 * float64(time.Hour))), nil

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

final format = 'HH:mm:ss', clock = PI / 12, millisPerHr = 3600*1000

def times = timeStrings.collect(parseTime)

formatTime(atan2( mean(times) { sin(it * clock) }, mean(times) { cos(it * clock) }) / clock)

Test:

{{out}}

=={{header|Haskell}}==

import Data.List.Split (splitOn)

import Text.Printf (printf)

main :: IO ()

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

{{out}}

<pre>23:47:43</pre>

every (sumCosines := 0.0) +:= cos(dtor(!A))

return rtod(atan(sumSines/*A,sumCosines/*A))

Sample run:

=={{header|J}}==

use <code>avgAngleR</code> from [[Averages/Mean angle#J]]

parseTimes=: ([: _&".;._2 ,&':');._2

secsFromTime=: 24 60 60 #. ] NB. convert from time to seconds

rft=: 2r86400p1 * secsFromTime NB. convert from time to radians

{{out|Example Use}}

=={{header|Java}}==

{{trans|Kotlin}}

static double meanAngle(double[] angles) {

System.out.println("Average time is : " + degreesToTime(mean));

}

{{out}}

=={{header|Javascript}}==

{{works with|Node.js}}

function time_to_seconds( hms ) {

var seconds = Math.floor( sum / count )

console.log( 'Mean time is ', seconds_to_time(seconds));

{{out}}

<pre>

The "mean time" of two times that differ by 12 hours (e.g. ["00:00:00", "12:00:00"]) is not very well-defined, and is accordingly computed as null here.

def mean_time_of_day:

def pi: 4 * (1|atan);

| round

| secs2time

'''Examples'''

["0:0:0", "24:0:0" ],

["1:0:0", "1:0:0" ],

["23:0:0", "23:0:0" ],

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

{{out}}

null

00:00:00

00:00:01

23:00:00

=={{header|Julia}}==

{{works with|Julia|0.6}}

{{trans|MATLAB}}

function meantime(times::Array, dlm::String=":")

println("Times:")

println.(times)

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

fun meanAngle(angles: DoubleArray): Double {

val mean = meanAngle(angles)

println("Average time is : ${degreesToTime(mean)}")

{{out}}

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

global pi

pi = acs(-1)

atan2 = (y=0)*(x<0)*pi

End Function

{{out}}

=={{header|Lua}}==

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

print(angleToTime(meanAngle(times)))

{{out}}

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

StringJoin@

Riffle[ToString /@

Exp[FromDigits[ToExpression@StringSplit[#, ":"], 60] & /@

list/(24*60*60) 2 Pi I]]]/(2 Pi)], ":"];

{{Out}}

<pre>23:47:43</pre>

=={{header|MATLAB}} / {{header|Octave}}==

c = pi/(12*60*60);

for k=1:length(t)

if (d<0) d += 1;

t = datestr(d,"HH:MM:SS");

<pre>mean_time_of_day({'23:00:17', '23:40:20', '00:12:45', '00:17:19'})

ans = 23:47:43

=={{header|Nim}}==

{{works with|Nim|0.20.0+}}

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

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

{{out}}

<pre>23:47:43</pre>

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

{{works with|oo2c}}

MODULE AvgTimeOfDay;

IMPORT

END AvgTimeOfDay.

{{Out}}

<pre>

=={{header|OCaml}}==

let day = float (24 * 60 * 60)

Printf.printf "The mean time of [%s] is: %s\n"

(String.concat "; " times)

{{out}}

The mean time of [23:00:17; 23:40:20; 00:12:45; 00:17:19] is: 23:47:43

=={{header|ooRexx}}==

* 25.06.2014 Walter Pachl

*--------------------------------------------------------------------*/

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

{{out}}

<pre>23:47:43</pre>

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

meanTime(v)=my(x=meanAngle(2*Pi*apply(u->u[1]/24+u[2]/1440+u[3]/86400, v))*12/Pi); [x\1, 60*(x-=x\1)\1, round(60*(60*x-60*x\1))]

{{out}}

<pre>[23, 47, 43]</pre>

Using the core module <code>Math::Complex</code> to enable use of complex numbers. The <code>POSIX</code> CPAN module provides the <code>fmod</code> routine for non-integer modulus calculations.

{{trans|Raku}}

use warnings;

use POSIX 'fmod';

@times = ("23:00:17", "23:40:20", "00:12:45", "00:17:19");

{{out}}

<pre>23:47:43 is the mean time of 23:00:17 23:40:20 00:12:45 00:17:19</pre>

===v5.36===

As previous, but using features from an up-to-date release of Perl, e.g. strict/warn/subroutine signatures without the <code>use</code> boilerplate.

use POSIX 'fmod';

use Math::Complex;

my @times = <23:00:17 23:40:20 00:12:45 00:17:19>;

{{out}}

<pre>23:47:43 is the mean time of 23:00:17 23:40:20 00:12:45 00:17:19</pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">MeanAngle</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">angles</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Mean Time is %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">toHMS</span><span style="color: #0000FF;">(</span><span style="color: #000000;">MeanAngle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">Times</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

=={{header|PHP}}==

<?php

function time2ang($tim) {

print "The mean time of day is $result (angle $ma).\n";

?>

{{out}}

=={{header|PicoLisp}}==

(de meanTime (Lst)

(sum '((S) (cos (*/ ($tim S) pi 43200))) Lst) )

43200 pi )

{{out|Test}}

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

avt: Proc options(main);

/*--------------------------------------------------------------------

End;

{{out}}

<pre>23:47:43</pre>

=={{header|PowerShell}}==

function Get-MeanTimeOfDay

{

}

}

[timespan]$meanTimeOfDay = "23:00:17","23:40:20","00:12:45","00:17:19" | Get-MeanTimeOfDay

"Mean time is {0}" -f (Get-Date $meanTimeOfDay.ToString()).ToString("hh:mm:ss tt")

{{Out}}

<pre>

=={{header|Python}}==

from math import radians, degrees

if __name__ == '__main__':

{{out}}

<pre>23:47:43</pre>

=={{header|Racket}}==

#lang racket

(define (mean-angle/radians as)

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

{{out}}

<pre>"23:47:43"</pre>

{{works with|Rakudo|2015.12}}

sub rad2tod ($r) {

my @times = ["23:00:17", "23:40:20", "00:12:45", "00:17:19"];

{{out}}

=={{header|REXX}}==

* 25.06.2014 Walter Pachl

* taken from ooRexx using my very aged sin/cos/artan functions

End

Numeric Digits (prec)

{{out}}

<pre>23:47:43</pre>

Using the methods at [[http://rosettacode.org/wiki/Averages/Mean_angle#Ruby|Averages/Mean angle]]

raise "invalid time" unless m = t.match(/^(\d\d):(\d\d):(\d\d)$/)

hh,mm,ss = m[1..3].map {|e| e.to_i}

end

{{out}}

23:47:43

=={{header|Run BASIC}}==

pi = acs(-1)

atan2 = (y=0)*(x<0)*pi

end if

=={{header|Rust}}==

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

}

{{out}}

<pre>

=={{header|Scala}}==

import scala.compat.Platform

assert(LocalTime.MIN.plusSeconds(meanAngle(times, dayInSeconds).round).toString == "23:47:40")

println(s"Successfully completed without errors. [total ${Platform.currentTime - executionStart} ms]")

=={{header|Scheme}}==

To be self-contained, this starts with the functions from [[Averages/Mean angle]]

(import (scheme base)

(scheme inexact)

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

(newline)

{{out}}

{{trans|Ruby}}

Using the '''mean_angle()''' function from: [http://rosettacode.org/wiki/Averages/Mean_angle#Sidef "Averages/Mean angle"]

(var m = t.match(/^(\d\d):(\d\d):(\d\d)$/)) || die "invalid time"

var (hh,mm,ss) = m.cap.map{.to_i}...

}

 

{{out}}

<pre>23:47:43</pre>

=={{header|SQL}}/{{header|PostgreSQL}}==

{{trans|Python}}

--Setup table for testing

CREATE TABLE time_table(times time);

(SELECT EXTRACT(epoch from times) t

FROM time_table) T1

Output:

=={{header|Swift}}==

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

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

{{out}}

=={{header|Tcl}}==

set secsPerRad [expr {60 * 60 * 12 / atan2(0,-1)}]

set sumSin [set sumCos 0.0]

}

{{out}}

23:47:43

=={{header|VBA}}==

Uses Excel and [[Averages/Mean_angle#VBA|mean angle]].

Dim angles() As Double

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

Next i

Debug.Print Format(mean_angle(s) / 360 + 1, "hh:mm:ss")

<pre>23:47:43</pre>

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

{{trans|C#}}

Function TimeToDegrees(time As TimeSpan) As Double

End Sub

{{out}}

<pre>Enter times, end with no input:

=={{header|Vlang}}==

{{trans|Wren}}

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

s := t[2].f64()

return (h + m + s) / 240

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

var timeToDegs = Fn.new { |time|

var times = ["23:00:17", "23:40:20", "00:12:45", "00:17:19"]

var angles = times.map { |t| timeToDegs.call(t) }.toList

{{out}}

=={{header|XPL0}}==

proc NumOut(N); \Display 2-digit N with leading zero

];

{{out}}

<pre>

=={{header|Yabasic}}==

{{trans|Phix}}

return 2 * atan((sqrt(x **2 + y ** 2) - x) / y)

end sub

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

=={{header|zkl}}==

to task "Averages/Mean angle" and some on-the-fly

time-to-angle and back conversions.

fcn meanT(t1,t2,etc){

ts:=vm.arglist.apply(fcn(hms){

if(mt<0) mt+=24; //-0.204622-->23.7954

D.toHour(mt).concat(":")

Time.Date.toFloat/toHour convert 24hr HMS to fractional time and back. Multiplying fractional time by 360/24=15 yields angle.

{{out}}