Show the epoch: Difference between revisions

 

=={{header|ABAP}}==

 

lv_date = 0.

 

WRITE: / lv_date.

{{out}}

<pre>

</pre>

===Simplified===

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

There are no fewer than three epochs associated with Mac OS. The original was 1st January 1904 00:00:00. This is stated in the 1999 AppleScript Language Guide, but I don't recall there ever having been a way to find it out by script and I don't think time zone was considered. Mac OS X was introduced in 2001 with a "Cocoa" framework whose epoch was the first instant (UTC) of that year and "underlying UNIX functionality". The <tt>do shell script</tt> added to AppleScript later that year made it possible for scripts to discover the Unix epoch. Since Mac OS X 10.9 (for library scripts) and Mac OS 10.10 (for running scripts), AppleScript's been able to access parts of the Cocoa system without needing add-ons and is thereby able to get the Cocoa epoch.

 

use framework "Foundation"

use scripting additions

 

 

-- Get the date 0 seconds from the Cocoa epoch.

-- The way it's rendered in its 'description' is good enough for the current purpose.

 

-- Get the date 0 seconds from the Unix epoch and format it in the same way.

set UnixEpoch to (do shell script "date -ur 0 '+%F %T %z'")

 

 

{{output}}

 

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

 

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

{{out}}

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

 

=={{header|Factor}}==

 

{{out}}

<pre>

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

Lingo's date object is not based on an epoch, but instead on runtime date calculations. A new date object is created by specifying "year, month, day", based on gregorian calendar. In arithmetic context, date objects are casted to "days" (AD), not to seconds or milliseconds (see below).

 

put now

-- date( 2018, 3, 21 )

-- print approx. year difference between "babylonianDate" and now

put (now-babylonianDate)/365.2425

 

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

The usual localtime() method for simple time extraction is available, but the built in Calendar module is a more diverse tool.

object cal = Calendar.ISO->set_timezone("UTC");

write( cal.Second(0)->format_iso_short() );

{{Out}}

<pre>19700101T00:00:00</pre>

 

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

=={{header|Raku}}==

(formerly Perl 6)

{{out}}

<pre>

=={{header|REXX}}==

The epoch for the REXX language BIF &nbsp; (<u>B</u>uilt-<u>I</u>n <u>F</u>unction) &nbsp; '''DATE''' &nbsp; is: &nbsp; January 1st, year 1.

 

say ' today is: ' date() /*today's is format: mm MON YYYY */

/* ↑ ┌───◄─── This BIF (Built-In Function) is only */

/* └─────────◄──────┘ for newer versions of REXX that */

{{output|out}}

<pre>

 

=={{header|Ring}}==

load "guilib.ring"

 

exec()

}

Output:

[[File:CalmoSoftShowEpoch.jpg]]

 

=={{header|Ruby}}==

The Date class however uses the Julian date -4712-1-1 as default when no parameters are supplied

Date.new # => #<Date: -4712-01-01 ((0j,0s,0n),+0s,2299161j)>

 

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

cDate$ = date$(0) ' 01/01/1901

 

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

{{libheader|Wren-date}}

The epoch (or zero date/time) for the above module is midnight on 1st January, 0001 UTC according to the Gregorian proleptic calendar, though it can also cater for the Unix epoch as well.

 

Date.default = Date.isoFull

 

var dt2 = Date.unixEpoch

 

{{out}}

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