Averages/Mean time of day: Difference between revisions

{{task|Date and time}}

 

 

A particular activity of bats occurs at these times of the day:

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

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

DEFINE PTR="CARD"

 

=={{header|Ada}}==

with Ada.Command_Line;

with Ada.Numerics.Elementary_Functions;

<pre>

% ./mean_time_of_day 23:00:17 23:40:20 00:12:45 00:17:19

23:47:43

</pre>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

 

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

 

=={{header|AWK}}==

{

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

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

{{works with|BBC BASIC for Windows}}

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

 

=={{header|C}}==

#include<math.h>

#include<stdio.h>

 

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

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

{

{

 

 

 

}

}

 

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

#include <iostream>

#include <vector>

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

{{trans|Echo Lisp}}

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

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

=={{header|D}}==

{{trans|Python}}

std.format, std.conv;

 

{{libheader| System.Math}}

{{Trans|Go}}

program Averages_Mean_time_of_day;

 

readln;

end.</syntaxhighlight>

=={{header|EchoLisp}}==

;; string hh:mm:ss to radians

(define (time->radian time)

→ "23:47:43"

</syntaxhighlight>

 

=={{header|Erlang}}==

-module( mean_time_of_day ).

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

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

include std/console.e

include std/math.e

 

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

open System.Numerics

 

 

=={{header|Factor}}==

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

splitting ;

=={{header|Fortran}}==

{{works with|gfortran 5.1.0}}

program mean_time_of_day

implicit none

 

=={{header|FreeBASIC}}==

 

Const pi As Double = 3.1415926535897932

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

Solution:

 

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

 

Test:

 

{{out}}

 

=={{header|Haskell}}==

import Data.List.Split (splitOn)

import Text.Printf (printf)

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

 

every put(B := [], ct2a(!A))

write(ca2t(meanAngle(B)))

=={{header|J}}==

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

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

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

meanTime=: 'hh:mm:ss' fmtTime [: secsFromTime [: avgAngleR&.rft parseTimes</syntaxhighlight>

{{out|Example Use}}

23:47:43</syntaxhighlight>

 

=={{header|Java}}==

{{trans|Kotlin}}

static double meanAngle(double[] angles) {

=={{header|Javascript}}==

{{works with|Node.js}}

 

function time_to_seconds( hms ) {

 

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

end ;</syntaxhighlight>

'''Examples'''

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

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

| mean_time_of_day</syntaxhighlight>

{{out}}

null

00:00:00

{{works with|Julia|0.6}}

{{trans|MATLAB}}

 

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

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun meanAngle(angles: DoubleArray): Double {

 

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

global pi

pi = acs(-1)

 

=={{header|Lua}}==

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

 

 

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

StringJoin@

Riffle[ToString /@

 

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

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

for k=1:length(t)

=={{header|Nim}}==

{{works with|Nim|0.20.0+}}

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

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

{{works with|oo2c}}

MODULE AvgTimeOfDay;

IMPORT

 

=={{header|OCaml}}==

let day = float (24 * 60 * 60)

 

 

=={{header|ooRexx}}==

* 25.06.2014 Walter Pachl

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

 

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

meanTime([[23,0,17], [23,40,20], [0,12,45], [0,17,19]])</syntaxhighlight>

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

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

 

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

 

=={{header|PHP}}==

<?php

function time2ang($tim) {

 

=={{header|PicoLisp}}==

 

(de meanTime (Lst)

(tim$ (% (+ Tim 86400) 86400) T) ) )</syntaxhighlight>

{{out|Test}}

-> "23:47:43"</syntaxhighlight>

 

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

avt: Proc options(main);

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

 

=={{header|PowerShell}}==

function Get-MeanTimeOfDay

{

}

</syntaxhighlight>

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

 

=={{header|Python}}==

from math import radians, degrees

 

 

=={{header|Racket}}==

#lang racket

(define (mean-angle/radians as)

{{works with|Rakudo|2015.12}}

 

sub rad2tod ($r) {

 

=={{header|REXX}}==

* 25.06.2014 Walter Pachl

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

{{out}}

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

 

=={{header|Ruby}}==

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}

 

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

pi = acs(-1)

End Function</syntaxhighlight>

=={{header|Rust}}==

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

 

 

=={{header|Scala}}==

import scala.compat.Platform

 

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

 

(import (scheme base)

(scheme inexact)

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

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

{{trans|Python}}

--Setup table for testing

CREATE TABLE time_table(times time);

=={{header|Swift}}==

 

 

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

 

=={{header|Tcl}}==

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

set sumSin [set sumCos 0.0]

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

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

{{trans|C#}}

 

Function TimeToDegrees(time As TimeSpan) As Double

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

 

{{trans|Wren}}

 

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

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var timeToDegs = Fn.new { |time|

s = m % 60

m = (m / 60).floor

}

 

 

=={{header|XPL0}}==

 

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

=={{header|Yabasic}}==

{{trans|Phix}}

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

end sub

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