Show the epoch: Difference between revisions

 

=={{header|ABAP}}==

 

lv_date = 0.

 

WRITE: / lv_date.

{{out}}

<pre>

 

However, conversion from unix epoch seconds is also supported and shown below.

with Ada.Calendar; use Ada.Calendar;

with Ada.Calendar.Formatting; use Ada.Calendar.Formatting;

begin

Put_Line (Image (Date => etime));

{{out}}

<pre>1970-01-01 00:00:00</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f SHOW_THE_EPOCH.AWK

# requires GNU Awk 4.0.1 or later

exit(0)

}

{{out}}

<pre>

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

{{works with|BBC BASIC for Windows}}

'''Output:'''

<pre>

 

=={{header|C}}==

#include <stdio.h>

 

printf("%s", asctime(gmtime(&t)));

return 0;

{{out}}

<pre>Thu Jan 1 00:00:00 1970</pre>

FileTime, from the Win32 API, uses a different epoch.

{{libheader|Win32}}

#include <stdio.h>

#include <wchar.h>

wprintf(L"FileTime epoch is %ls, at %ls (UTC).\n", date, time);

return 0;

{{out}}

<pre>FileTime epoch is Monday, January 01, 1601, at 12:00:00 AM (UTC).</pre>

 

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

 

class Program

Console.WriteLine(new DateTime());

}

{{out}}

<pre>1-1-0001 0:00:00</pre>

{{works with|gcc|4.5.3}}

Doesn't work with MSVC 10 SP1

#include <chrono>

#include <ctime>

std::cout << std::asctime(std::gmtime(&t)) << '\n';

return 0;

{{out}}

<pre>Thu Jan 1 00:00:00 1970</pre>

{{libheader|boost}}

#include <boost/date_time.hpp>

int main()

std::cout << boost::posix_time::ptime( boost::posix_time::min_date_time ) << '\n';

return 0;

{{out}}

<pre>1400-Jan-01 00:00:00</pre>

 

=={{header|Clojure}}==

Output (since Clojure 1.5)

 

=={{header|COBOL}}==

PROGRAM-ID. epoch.

 

 

GOBACK

 

{{out}}

 

=={{header|CoffeeScript}}==

{{out}}

<pre>Thu, 01 Jan 1970 00:00:00 GMT</pre>

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

{{out}}

<pre>1900-01-01 00:00:00</pre>

 

=={{header|Dart}}==

print(new Date.fromEpoch(0,new TimeZone.utc()));

{{out}}

<pre>1970-01-01 00:00:00.000Z</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

begin

Writeln(FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', 0));

{{out}}

<pre>1899-12-30 00:00:00.000</pre>

{{0,1,1},{0,0,0}}

</pre>

 

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

{{out}}

<pre>0001-01-01 00:00:00Z</pre>

 

=={{header|Factor}}==

 

=={{header|Forth}}==

{{works with|4tH|3.61.3}}

{{out}}

<pre>

 

Date/time values in FB are always based on the current regional settings and so, if values are needed for other time-zones (or UTC), the appropriate adjustments must be made.

 

#Include "vbcompat.bi"

Print

Print "Press any key to quit"

 

{{out}}

December 17, 1680 00:00:00

</pre>

 

=={{header|FutureBasic}}==

 

print date$

print

print time$("h:mm a ZZZZ "); date$("MMMM d, yyyy G")

Output:

<pre>

 

=={{header|Go}}==

import ("fmt"; "time")

 

func main() {

fmt.Println(time.Time{})

{{out}}

This is UNIX format. The 1 on the end is the full year, not two or four digit year.

=={{header|Groovy}}==

Groovy uses the UNIX epoch.

def format = new java.text.SimpleDateFormat('yyyy-MM-dd\'T\'HH:mm:ss.SSSZ')

format.timeZone = TimeZone.getTimeZone('UTC')

{{out}}

<pre>1970-01-01T00:00:00.000+0000</pre>

The <code>ClockTime</code> type is abstract in Haskell 98, but is defined in GHC.

{{works with|GHC}}

 

{{out}}

<pre>Thu Jan 1 00:00:00 UTC 1970</pre>

===New time library===

{{works with|GHC}}

 

{{out}}

<pre>1858-11-17 00:00:00 UTC</pre>

* [http://www.cs.arizona.edu/icon/library/src/procs/datetime.icn datetime routines] use a global variable 'DateBaseYear' which defaults to Jan 1, 1970 00:00:00 but can be set if desired.

* The example below uses only a couple of the datetime procedures

 

procedure main()

now := DateToSec(&date) + ClockToSec(&clock)

printf("Now is also %s and %s\n",SecToDate(now),SecToDateLine(now))

{{out|Sample Output}}

<pre>&now and gettimeofday().sec are equal

=={{header|J}}==

J does not have an epoch. J's native representation of date and time is a six element list: year, month, day, hour, minute, second. For example:

(August 8, 2011, 8:25:44 pm)

 

That said, the <code>'dates'</code> library does have an epoch:

todate 0

 

=={{header|Java}}==

<code>DateFormat</code> is needed to set the timezone. Printing <code>date</code> alone would show this date in the timezone/locale of the machine that the program is running on. The epoch used in <code>java.util.Date</code> (as well as <code>java.sql.Date</code>, which can be subbed into this example) is actually in GMT, but there isn't a significant difference between that and UTC for lots of applications ([http://download.oracle.com/javase/7/docs/api/java/util/Date.html#getTime() documentation for java.util.Date]).

import java.util.Date;

import java.util.TimeZone;

System.out.println(format.format(date));

}

{{out}}

<pre>Jan 1, 1970 12:00:00 AM</pre>

On my PC I see

<pre>01.01.1970 00:00:00</pre>

 

=={{header|JavaScript}}==

{{out}}

<pre>Thu, 01 Jan 1970 00:00:00 GMT</pre>

 

=={{header|jq}}==

{{out}}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.util.Date

format.timeZone = TimeZone.getTimeZone("UTC")

println(format.format(epoch))

 

{{out}}

 

=={{header|Lasso}}==

 

{{out}}

 

=={{header|Limbo}}==

 

include "sys.m"; sys: Sys;

daytime = load Daytime Daytime->PATH;

sys->print("%s\n", daytime->text(daytime->gmt(0)));

 

Of course, this could also be done by mangling the namespace and forging the current date, locking it to the epoch:

 

 

include "sys.m"; sys: Sys;

sys->print("%s\n", daytime->text(daytime->gmt(daytime->now())));

}

 

{{out}}

<pre>Thu Jan 01 00:00:00 GMT 1970

</pre>

 

=={{header|LiveCode}}==

LiveCode uses midnight, January 1, 1970 as the start of the eon

convert somedate to internet date

put somedate

-- output GMT (localised)

-- Thu, 1 Jan 1970 10:00:00 +1000

 

=={{header|LotusScript}}==

Uses LotusScript to calculate difference between current time and epoch start date. This example: a button which prints the result. Of course, change the <code>timeStamp</code> variable to whatever suits your need.

 

Sub Click(Source As Button)

'Create timestamp as of now

 

End Sub

 

Output:

 

=={{header|Lua}}==

{{out}}

<pre>Thu Jan 1 00:00:00 1970</pre>

 

 

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

Matlab and Octave store date/time number in a floating point number counting the days.

for k=1:length(d)

printf('day %f\t%s\n',d(k),datestr(d(k),0))

disp(datevec(d(k)))

{{out}}

<pre>day 0.000000 31-Dec--001 00:00:00

 

=={{header|Maxima}}==

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

say zulu.format(edate)

return

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

 

=={{header|Objective-C}}==

 

int main(int argc, const char *argv[]) {

}

return 0;

{{out|Log}}

<pre>2001-01-01 00:00:00 +0000</pre>

 

=={{header|OCaml}}==

 

let months = [| "January"; "February"; "March"; "April"; "May"; "June";

let () =

let t = Unix.gmtime 0.0 in

{{out|Execution}}

<pre>$ ocaml unix.cma epoch.ml

=={{header|Oforth}}==

 

 

 

{{out}}

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

GP has no built-in date or time system.

 

PARI, as usual, has access to the same resources as [[#C|C]].

=={{header|Pascal}}==

This works with [[Free_Pascal| Free Pascal]]:

 

uses

Writeln(FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', Now));

Writeln(FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', 0));

{{out}}

<pre>

 

=={{header|Perl}}==

{{out}}

<pre>Thu Jan 1 00:00:00 1970</pre>

 

=={{header|Phix}}==

The standard Phix file builtins/datetime.e does not use an epoch, but instead expects absolute values, eg Jan 1st 1970 is {1970,1,1,...}. I suppose the closest we can get is:

<pre>

"0000-01-01"

 

=={{header|PHP}}==

echo gmdate('r', 0), "\n";

{{out}}

<pre>Thu, 01 Jan 1970 00:00:00 +0000</pre>

=={{header|PicoLisp}}==

The 'date' function in PicoLisp returns a day number, starting first of March of the year zero. Calculated according to the gregorian calendar (despite that that calendar wasn't used in 0 AD yet).

 

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

epoch: Proc Options(main);

/*********************************************************************

Put Edit(d ,days(d))

(Skip,a,f(15));

Result:

<pre>

=={{header|PowerShell}}==

PowerShell uses .NET's <code>DateTime</code> structure and an integer can simply be casted appropriately:

{{out}}

<pre>Monday, January 01, 0001 12:00:00 AM</pre>

===Three Alternates===

<code>Get-Date</code> always returns its '''Kind''' property as Local:

Get-Date -Year 1 -Month 1 -Day 1 -Hour 0 -Minute 0 -Second 0 -Millisecond 0

{{Out}}

<pre>

</pre>

This approach returns its '''Kind''' property as Unspecified:

New-Object -TypeName System.DateTime

{{Out}}

<pre>

Here you could describe the epoch date's '''Kind''' property as being Utc.

Formatting the output as a list for demonstration:

New-Object -TypeName System.DateTime -ArgumentList 1, 1, 1, 0, 0, 0, ([DateTimeKind]::Utc) | Format-List

{{Out}}

<pre>

 

=={{header|PureBasic}}==

PrintN(FormatDate("Y = %yyyy M = %mm D = %dd, %hh:%ii:%ss", 0))

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>Y = 1970 M = 01 D = 01, 00:00:00</pre>

 

=={{header|Python}}==

>>> time.asctime(time.gmtime(0))

'Thu Jan 1 00:00:00 1970'

 

=={{header|R}}==

> class(epoch) <- class(Sys.time())

> format(epoch, "%Y-%m-%d %H:%M:%S %Z")

 

=={{header|Racket}}==

#lang racket

(require racket/date)

(date->string (seconds->date 0 #f))

 

Output:

</pre>

 

 

 

 

 

</pre>

 

=={{header|Ring}}==

load "guilib.ring"

 

exec()

}

Output:

[[File:CalmoSoftShowEpoch.jpg]]

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

 

use time::{at_utc, Timespec};

let epoch = at_utc(Timespec::new(0, 0));

println!("{}", epoch.asctime());

{{out}}

<pre>Thu Jan 1 00:00:00 1970</pre>

 

=={{header|Scala}}==

import java.text.DateFormat

 

val df=DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.ENGLISH)

df.setTimeZone(TimeZone.getTimeZone("UTC"))

{{out}}

<pre>January 1, 1970 12:00:00 AM UTC</pre>

 

=={{header|Seed7}}==

negative years exist and that the year preceding 1 is 0.

Therefore the epoch is the beginning of the year 0.

include "time.s7i";

 

begin

writeln(time.value);

{{out}}

<pre>

 

=={{header|Sidef}}==

{{out}}

<pre>Thu Jan 1 00:00:00 1970</pre>

 

=={{header|Standard ML}}==

 

=={{header|Stata}}==

01jan1960

. di %tc 0

 

=={{header|Tcl}}==

 

=={{header|TUSCRIPT}}==

- epoch

number=1

dayofweeknr=DATE (today,day,month,year,number)

date=JOIN (year,"-",month,day)

{{out}}

<pre>

</pre>

 

=={{header|UNIX Shell}}==

The nonstandard option <code>date -r</code> takes seconds from the epoch, and prints date and time. See [http://www.openbsd.org/cgi-bin/man.cgi?query=date&apropos=0&sektion=1&manpath=OpenBSD+Current&arch=i386&format=html date(1) manual].

{{works with|OpenBSD}}

 

On systems with GNU date, you can do

$ TZ=UTC date --date "$(date +%s) seconds ago"

Thu Jan 1 00:00:00 UTC 1970

 

=={{header|Visual Basic}}==

Debug.Print Format(0, "dd mmm yyyy hh:mm")

{{out|Output (in debug window)}}

30 Dec 1899 00:00

 

=={{header|zkl}}==

Using the method tickToTock(time_t,useLocalTime) on Linux. tickToTock converts a time_t (seconds since the epoch) to "human" time. False means use UTC (vs local time, the default).

 

 

{{omit from|Locomotive Basic}}

{{omit from|ZX Spectrum Basic}}