Free datetime format excel software for linux

DateTime::Format::Excel is a Perl module that can convert between DateTime and Excel dates.

SYNOPSIS

use DateTime::Format::Excel;

# From Excel via class method:

my $datetime = DateTime::Format::Excel->parse_datetime( 37680 );
print $datetime->ymd(.); # 2003.02.28

# or via an object

my $excel = DateTime::Format::Excel->new();
print $excel->parse_datetime( 25569 )->ymd; # 1970-01-01

# Back to Excel number:

use DateTime;
my $dt = DateTime->new( year => 1979, month => 7, day => 16 );
my $daynum = DateTime::Format::Excel->format_datetime( $dt );
print $daynum; # 29052

# or via an object
my $other_daynum = $excel->format_datetime( $dt );
print $other_daynum; # 29052

Excel uses a different system for its dates than most Unix programs. This module allows you to convert between a few of the Excel raw formats and DateTime objects, which can then be further converted via any of the other DateTime::Format::* modules, or just with DateTimes methods.

If you happen to be dealing with dates between 1 Jan 1900 and 1 Mar 1900 please read the notes on epochs.

If youre wanting to handle actual spreadsheet files, you may find Spreadsheet::WriteExcel and Spreadsheet::ParseExcel of use.

DateTime::Format::Pg is a Perl module to parse and format PostgreSQL dates and times.

SYNOPSIS

use DateTime::Format::Pg;

my $dt = DateTime::Format::Pg->parse_datetime( 2003-01-16 23:12:01 );

# 2003-01-16T23:12:01+0200
DateTime::Format::Pg->format_datetime($dt);

This module understands the formats used by PostgreSQL for its DATE, TIME, TIMESTAMP, and INTERVAL data types. It can be used to parse these formats in order to create DateTime or DateTime::Duration objects, and it can take a DateTime or DateTime::Duration object and produce a string representing it in a format accepted by PostgreSQL.

CONSTRUCTORS

The following methods can be used to create DateTime::Format::Pg objects.
new( name => value, ... )

Creates a new DateTime::Format::Pg instance. This is generally not required for simple operations. If you wish to use a different parsing style from the default then it is more comfortable to create an object.

my $parser = DateTime::Format::Pg->new()
my $copy = $parser->new( european => 1 );

This method accepts the following options:

european

If european is set to non-zero, dates are assumed to be in european dd/mm/yyyy format. The default is to assume US mm/dd/yyyy format (because this is the default for PostgreSQL).

This option only has an effect if PostgreSQL is set to output dates in the PostgreSQL (DATE only) and SQL (DATE and TIMESTAMP) styles.
Note that you dont have to set this option if the PostgreSQL server has been set to use the ISO format, which is the default.

server_tz

This option can be set to a DateTime::TimeZone object or a string that contains a time zone name.

This value must be set to the same value as the PostgreSQL servers time zone in order to parse TIMESTAMP WITH TIMEZONE values in the PostgreSQL, SQL, and German formats correctly.

Note that you dont have to set this option if the PostgreSQL server has been set to use the ISO format, which is the default.

clone()

This method is provided for those who prefer to explicitly clone via a method called clone().

my $clone = $original->clone();

If called as a class method it will die.

DateTime::Format::Epoch::JD is Perl module Convert DateTimes to/from Julian Days.

SYNOPSIS

use DateTime::Format::Epoch::JD;

my $dt = DateTime::Format::Epoch::JD->parse_datetime( 2453244.5 );
# 2004-08-27T00:00:00
DateTime::Format::Epoch::JD->format_datetime($dt);
# 2453244.5

my $formatter = DateTime::Format::Epoch::JD->new();
my $dt2 = $formatter->parse_datetime( 2453244.5 );
# 2004-08-27T00:00:00
$formatter->format_datetime($dt2);
# 2453244.5

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to the Julian Day number. This is the number of days since noon U.T.C. on January 1, 4713 B.C. (Julian calendar).

This time scale was originally proposed by John Herschel, and is often used in astronomical calculations.

Similar modules are:

DateTime::Format::Epoch::MJD
Implements the "modified Julian Day", starting at midnight U.T.C., November 17, 1858. This number is always 2,400,000.5 lower than the JD, and this count only uses five digits to specify a date between 1859 and about 2130.

DateTime::Format::Epoch::RJD
Implements the "reduced Julian Day", starting at noon U.T.C., November 16, 1858. This number is always 2,400,000 lower than the JD.

DateTime::Format::Epoch::TJD
Implements the "truncated Julian Day", starting at midnight U.T.C., May 24, 1968. This number is always 2,440,000,5 lower than the JD. Actually, there is another version of the TJD, defined as JD modulo 10,000. But that one is a bit harder to implement, so youll have to do with this version of TJD. Or dont use TJDs at all.

DateTime::Format::Epoch::RataDie
Implements the Rata Die count, starting at January 1, 1 (Gregorian). This count is used by DateTime::Calendar programmers.

DateTime::Format::Epoch::Lilian
Implements the Lilian count, named after Aloysius Lilian (a 16th century physician) and first used by IBM (a 19th century punched card machine manufacturer). This counts the number of days since the adoption of the Gregorian calendar. Only days are counted, and October 15, 1584 is day 1.

DateTime::Format::Epoch::DotNet is a Perl module that can convert DateTimes to/from .NET epoch seconds.

SYNOPSIS

use DateTime::Format::Epoch::DotNet;

my $dt = DateTime::Format::Epoch::DotNet->parse_datetime( 1051488000 );

DateTime::Format::Epoch::DotNet->format_datetime($dt);
# 1051488000

my $formatter = DateTime::Format::Epoch::DotNet->new();
my $dt2 = $formatter->parse_datetime( 1051488000 );
$formatter->format_datetime($dt2);

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to the number of seconds since the epoch defined in the .NET Framework SDK.
Note that this epoch is defined in the local time zone. This means that these two pieces of code will print the same number of seconds, even though they represent two datetimes 6 hours apart:

$dt = DateTime->new( year => 2003, month => 5, day => 2,
time_zone => Europe/Amsterdam );
print $formatter->format_datetime($dt);

$dt = DateTime->new( year => 2003, month => 5, day => 2,
time_zone => America/Chicago );
print $formatter->format_datetime($dt);

DateTime::Format::Epoch::MJD is a Perl module that can convert DateTimes to/from Modified Julian Days.

SYNOPSIS

use DateTime::Format::Epoch::MJD;

my $dt = DateTime::Format::Epoch::MJD->parse_datetime( 53244 );
# 2004-08-27T00:00:00

DateTime::Format::Epoch::MJD->format_datetime($dt);
# 53244

my $formatter = DateTime::Format::Epoch::MJD->new();
my $dt2 = $formatter->parse_datetime( 53244 );
# 2004-08-27T00:00:00
$formatter->format_datetime($dt2);
# 53244

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to the Modified Julian Day number. See DateTime::Format::Epoch::JD for a description.

DateTime::Format::Epoch::RataDie is a Perl module that can convert DateTimes to/from Rata Die.

SYNOPSIS

use DateTime::Format::Epoch::RataDie;

my $dt = DateTime::Format::Epoch::RataDie->parse_datetime( $count );

DateTime::Format::Epoch::RataDie->format_datetime($dt);
# $count

my $formatter = DateTime::Format::Epoch::RataDie->new();
my $dt2 = $formatter->parse_datetime( $count );
$formatter->format_datetime($dt2);

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to the Rata Die count. See DateTime::Format::Epoch::JD for a description.

DateTime::Format::Epoch::TAI64 is a Perl module that can convert DateTimes to/from TAI64 values.

SYNOPSIS

use DateTime::Format::Epoch::TAI64;

my $dt = DateTime::Format::Epoch::TAI64
->parse_datetime( 4611686019483526367 );
# 2003-06-20T19:49:59

DateTime::Format::Epoch::TAI64->format_datetime($dt);
# 4611686019483526367

my $formatter = DateTime::Format::Epoch::TAI64->new();

$dt = $formatter->parse_datetime( 4611686019483526367 );
# 2003-06-20T19:49:59

$formatter->format_datetime($dt);
# 4611686019483526367

my $str_frmt = DateTime::Format::Epoch::TAI64->new(
format => string );

$dt = $str_frmt->parse_datetime( "x40 x3exf3x69x6a" );
# 2003-06-20T19:49:59

$str_frmt->format_datetime($dt);
# "x40 x3exf3x69x6a"

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to a TAI64 value. The TAI64 timescale covers the entire expected lifespan of the universe (at least, if you expect the universe to be closed).

Time::Format is a Perl module for easy-to-use date/time formatting.

SYNOPSIS

use Time::Format qw(%time %strftime %manip);

$time{$format}
$time{$format, $unixtime}

print "Today is $time{yyyy/mm/dd}n";
print "Yesterday was $time{yyyy/mm/dd, time-24*60*60}n";
print "The time is $time{hh:mm:ss}n";
print "Another time is $time{H:mm am tz, $another_time}n";
print "Timestamp: $time{yyyymmdd.hhmmss.mmm}n";
%time also accepts Date::Manip strings and DateTime objects:
$dm = Date::Manip::ParseDate(last monday);
print "Last monday was $time{Month d, yyyy, $dm}";
$dt = DateTime->new (....);
print "Heres another date: $time{m/d/yy, $dt}";
It also accepts most ISO-8601 date/time strings:
$t = 2005/10/31T17:11:09; # date separator: / or - or .
$t = 2005-10-31 17.11.09; # in-between separator: T or _ or space
$t = 20051031_171109; # time separator: : or .
$t = 20051031171109; # separators may be omitted
$t = 2005/10/31; # date-only is okay
$t = 17:11:09; # time-only is okay
# But not:
$t = 20051031; # date-only without separators
$t = 171109; # time-only without separators
# ...because those look like epoch time numbers.
%strftime works like POSIXs strftime, if you like those %-formats.
$strftime{$format}
$strftime{$format, $unixtime}
$strftime{$format, $sec,$min,$hour, $mday,$mon,$year, $wday,$yday,$isdst}

print "POSIXish: $strftime{%A, %B %d, %Y, 0,0,0,12,11,95,2}n";
print "POSIXish: $strftime{%A, %B %d, %Y, 1054866251}n";
print "POSIXish: $strftime{%A, %B %d, %Y}n"; # current time
%manip works like Date::Manips UnixDate function.
$manip{$format};
$manip{$format, $when};

print "Date::Manip: $manip{%m/%d/%Y}n"; # current time
print "Date::Manip: $manip{%m/%d/%Y,last Tuesday}n";
These can also be used as standalone functions:
use Time::Format qw(time_format time_strftime time_manip);

print "Today is ", time_format(yyyy/mm/dd, $some_time), "n";
print "POSIXish: ", time_strftime(%A %B %d, %Y,$some_time), "n";
print "Date::Manip: ", time_manip(%m/%d/%Y,$some_time), "n";

This module creates global pseudovariables which format dates and times, according to formatting codes you pass to them in strings.

The %time formatting codes are designed to be easy to remember and use, and to take up just as many characters as the output time value whenever possible. For example, the four-digit year code is "yyyy", the three-letter month abbreviation is "Mon".

The nice thing about having a variable-like interface instead of function calls is that the values can be used inside of strings (as well as outside of strings in ordinary expressions). Dates are frequently used within strings (log messages, output, data records, etc.), so having the ability to interpolate them directly is handy.

Perl allows arbitrary expressions within curly braces of a hash, even when that hash is being interpolated into a string. This allows you to do computations on the fly while formatting times and inserting them into strings. See the "yesterday" example above.

The format strings are designed with programmers in mind. What do you need most frequently? 4-digit year, month, day, 24-based hour, minute, second -- usually with leading zeroes. These six are the easiest formats to use and remember in Time::Format: yyyy, mm, dd, hh, mm, ss. Variants on these formats follow a simple and consistent formula. This module is for everyone who is weary of trying to remember strftime(3)s arcane codes, or of endlessly writing $t[4]++; $t[5]+=1900 as you manually format times or dates.

Note that mm (and related codes) are used both for months and minutes. This is a feature. %time resolves the ambiguity by examining other nearby formatting codes. If its in the context of a year or a day, "month" is assumed. If in the context of an hour or a second, "minute" is assumed.

The format strings are not meant to encompass every date/time need ever conceived. But how often do you need the day of the year (strftimes %j) or the week number (strftimes %W)?

For capabilities that %time does not provide, %strftime provides an interface to POSIXs strftime, and %manip provides an interface to the Date::Manip modules UnixDate function.

If the companion module Time::Format_XS is also installed, Time::Format will detect and use it. This will result in a significant speed increase for %time and time_format.