Date-ISO8601-0.005000755001750001750 013136533074 13302 5ustar00zeframzefram000000000000Date-ISO8601-0.005/.gitignore000444001750001750 16513136533065 15411 0ustar00zeframzefram000000000000/Build /Makefile /_build /blib /META.json /META.yml /MYMETA.json /MYMETA.yml /Makefile.PL /SIGNATURE /Date-ISO8601-* Date-ISO8601-0.005/Build.PL000444001750001750 170413136533065 14735 0ustar00zeframzefram000000000000{ use 5.006; } use warnings; use strict; use Module::Build; Module::Build->new( module_name => "Date::ISO8601", license => "perl", configure_requires => { "Module::Build" => 0, "perl" => "5.006", "strict" => 0, "warnings" => 0, }, build_requires => { "Module::Build" => 0, "Test::More" => 0, "perl" => "5.006", "strict" => 0, "warnings" => 0, }, requires => { "Carp" => 0, "Exporter" => 0, "constant" => 0, "integer" => 0, "parent" => 0, "perl" => "5.006", "strict" => 0, "warnings" => 0, }, conflicts => { "Math::BigInt" => "< 1.64", "Math::BigRat" => "< 0.08", }, dynamic_config => 0, meta_add => { distribution_type => "module" }, meta_merge => { "meta-spec" => { version => "2" }, resources => { bugtracker => { mailto => "bug-Date-ISO8601\@rt.cpan.org", web => "https://rt.cpan.org/Public/Dist/". "Display.html?Name=Date-ISO8601", }, }, }, sign => 1, )->create_build_script; 1; Date-ISO8601-0.005/Changes000444001750001750 342013136533065 14731 0ustar00zeframzefram000000000000version 0.005; 2017-07-28 * no longer include a Makefile.PL in the distribution * in documentation, use four-column indentation for all verbatim material * in META.{yml,json}, point to public bug tracker * convert .cvsignore to .gitignore version 0.004; 2011-04-09 * check for required Perl version at runtime * use full stricture in test suite * in Build.PL, explicitly declare configure-time requirements * remove bogus "exit 0" from Build.PL * include META.json in distribution * add MYMETA.json and MYMETA.yml to .cvsignore version 0.003; 2009-04-21 * use "[0-9]" instead of "\d" in regexp in present_y() * test POD syntax and coverage, and rename some internal functions to satisfy the coverage test * use simpler "parent" pragma in place of "base" * really complete dependency list (was missing "integer") * include "distribution_type" entry in META.yml to satisfy CPANTS * in documentation, separate "license" section from "copyright" section * use full stricture in Build.PL * remove from .cvsignore items that don't occur with Module::Build version 0.002; 2007-09-08 * build with Module::Build instead of ExtUtils::MakeMaker * complete dependency list * express relationship with versions of Math::BigInt and Math::BigRat as conflicts rather than dependencies * include signature in distribution version 0.001; 2007-02-13 * in presentation functions, restrict range of all numerical inputs to what will fit into the fixed-length formats * add notes on standard conformance of presentation formats * add reference to Date::JD * test explicitly for correct class of result * small wording fixes in documentation * remove an unused variable version 0.000; 2006-05-18 * initial released version Date-ISO8601-0.005/MANIFEST000444001750001750 26113136533065 14547 0ustar00zeframzefram000000000000.gitignore Build.PL Changes MANIFEST META.json META.yml README lib/Date/ISO8601.pm t/pod_cvg.t t/pod_syn.t t/y.t t/yd.t t/ymd.t t/ywd.t SIGNATURE Added here by Module::Build Date-ISO8601-0.005/META.json000444001750001750 326513136533065 15066 0ustar00zeframzefram000000000000{ "abstract" : "the three ISO 8601 numerical calendars", "author" : [ "Andrew Main (Zefram) " ], "dynamic_config" : 0, "generated_by" : "Module::Build version 0.4224", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : 2 }, "name" : "Date-ISO8601", "prereqs" : { "build" : { "requires" : { "Module::Build" : "0", "Test::More" : "0", "perl" : "5.006", "strict" : "0", "warnings" : "0" } }, "configure" : { "requires" : { "Module::Build" : "0", "perl" : "5.006", "strict" : "0", "warnings" : "0" } }, "runtime" : { "conflicts" : { "Math::BigInt" : "< 1.64", "Math::BigRat" : "< 0.08" }, "requires" : { "Carp" : "0", "Exporter" : "0", "constant" : "0", "integer" : "0", "parent" : "0", "perl" : "5.006", "strict" : "0", "warnings" : "0" } } }, "provides" : { "Date::ISO8601" : { "file" : "lib/Date/ISO8601.pm", "version" : "0.005" } }, "release_status" : "stable", "resources" : { "bugtracker" : { "mailto" : "bug-Date-ISO8601@rt.cpan.org", "web" : "https://rt.cpan.org/Public/Dist/Display.html?Name=Date-ISO8601" }, "license" : [ "http://dev.perl.org/licenses/" ] }, "version" : "0.005", "x_serialization_backend" : "JSON::PP version 2.93" } Date-ISO8601-0.005/META.yml000444001750001750 174313136533065 14715 0ustar00zeframzefram000000000000--- abstract: 'the three ISO 8601 numerical calendars' author: - 'Andrew Main (Zefram) ' build_requires: Module::Build: '0' Test::More: '0' perl: '5.006' strict: '0' warnings: '0' configure_requires: Module::Build: '0' perl: '5.006' strict: '0' warnings: '0' conflicts: Math::BigInt: '< 1.64' Math::BigRat: '< 0.08' dynamic_config: 0 generated_by: 'Module::Build version 0.4224, CPAN::Meta::Converter version 2.150010' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Date-ISO8601 provides: Date::ISO8601: file: lib/Date/ISO8601.pm version: '0.005' requires: Carp: '0' Exporter: '0' constant: '0' integer: '0' parent: '0' perl: '5.006' strict: '0' warnings: '0' resources: bugtracker: https://rt.cpan.org/Public/Dist/Display.html?Name=Date-ISO8601 license: http://dev.perl.org/licenses/ version: '0.005' x_serialization_backend: 'CPAN::Meta::YAML version 0.012' Date-ISO8601-0.005/README000444001750001750 646213136533065 14327 0ustar00zeframzefram000000000000NAME Date::ISO8601 - the three ISO 8601 numerical calendars DESCRIPTION The international standard ISO 8601 "Data elements and interchange formats - Information interchange - Representation of dates and times" defines three distinct calendars by which days can be labelled. It also defines textual formats for the representation of dates in these calendars. This module provides functions to convert dates between these three calendars and Chronological Julian Day Numbers, which is a suitable format to do arithmetic with. It also supplies functions that describe the shape of these calendars, to assist in calendrical calculations. It also supplies functions to represent dates textually in the ISO 8601 formats. ISO 8601 also covers time of day and time periods, but this module does nothing relating to those parts of the standard; this is only about labelling days. The first ISO 8601 calendar divides time up into years, months, and days. It corresponds exactly to the Gregorian calendar, invented by Aloysius Lilius and promulgated by Pope Gregory XIII in the late sixteenth century, with AD (CE) year numbering. This calendar is applied to all time, not just to dates after its invention nor just to years 1 and later. Thus for ancient dates it is the proleptic Gregorian calendar with astronomical year numbering. The second ISO 8601 calendar divides time up into the same years as the first, but divides the year directly into days, with no months. The standard calls this "ordinal dates". Ordinal dates are commonly referred to as "Julian dates", a mistake apparently deriving from true Julian Day Numbers, which divide time up solely into linearly counted days. The third ISO 8601 calendar divides time up into years, weeks, and days. The years approximate the years of the first two calendars, so they stay in step in the long term, but the boundaries differ. This week-based calendar is sometimes called "the ISO calendar", apparently in the belief that ISO 8601 does not define any other. It is also referred to as "business dates", because it is most used by certain businesses to whom the week is the most important temporal cycle. The Chronological Julian Day Number is an integral number labelling each day, where the day extends from midnight to midnight in whatever time zone is of interest. It is a linear count of days, where each day's number is one greater than the previous day's number. It is directly related to the Julian Date system: in the time zone of the prime meridian, the CJDN equals the JD at noon. By way of epoch, the day on which the Convention of the Metre was signed, which ISO 8601 defines to be 1875-05-20 (and 1875-140 and 1875-W20-4), is CJDN 2406029. This module places no limit on the range of dates to which it may be applied. All function arguments are permitted to be "Math::BigInt" or "Math::BigRat" objects in order to achieve arbitrary range. Native Perl integers are also permitted, as a convenience when the range of dates being handled is known to be sufficiently small. INSTALLATION perl Build.PL ./Build ./Build test ./Build install AUTHOR Andrew Main (Zefram) COPYRIGHT Copyright (C) 2006, 2007, 2009, 2011, 2017 Andrew Main (Zefram) LICENSE This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Date-ISO8601-0.005/SIGNATURE000644001750001750 272713136533074 14735 0ustar00zeframzefram000000000000This file contains message digests of all files listed in MANIFEST, signed via the Module::Signature module, version 0.81. To verify the content in this distribution, first make sure you have Module::Signature installed, then type: % cpansign -v It will check each file's integrity, as well as the signature's validity. If "==> Signature verified OK! <==" is not displayed, the distribution may already have been compromised, and you should not run its Makefile.PL or Build.PL. -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 SHA1 64fba6dbdaf265fc2afb33c5a9e5ce07430e99bf .gitignore SHA1 56c058c822bee0aa6f8aaa08d0280ccd86b2e285 Build.PL SHA1 8319cc4e82d5f09b2d47479552e1b5cbf36a66ec Changes SHA1 57be6bb282cfb7f50a26dec852bbb0a0252f7e33 MANIFEST SHA1 c47d4baf6c6de844b59ba9ec98352ac7f3fb1907 META.json SHA1 8bec29d66b1afb7facaeb7180e0365cc8e94c6fc META.yml SHA1 73be621a06860e5697c23ed3c2ce4a4226bf6bf2 README SHA1 90dc0a018c4ad14bc095a3620a131e4f896fabd3 lib/Date/ISO8601.pm SHA1 904d9a4f76525e2303e4b0c168c68230f223c8de t/pod_cvg.t SHA1 65c75abdef6f01a5d1588a307f2ddfe2333dc961 t/pod_syn.t SHA1 033b2459677066c8820a4d764a054cc2cdc82a41 t/y.t SHA1 b9999d6e2ad4491b175d53b37677a79067b8f303 t/yd.t SHA1 646b40a4d49f11a9f79dfeb94fbbe18405766ba4 t/ymd.t SHA1 8938be55b92f217693d02af4d2522e8e65dae76b t/ywd.t -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iEYEARECAAYFAll6tjUACgkQOV9mt2VyAVGJ8QCgikUk3KCe8aG5BqFQVEtDLCb0 m/IAn3lF3I41rg3Mx/s7n3bLmc1QEySJ =s82Z -----END PGP SIGNATURE----- Date-ISO8601-0.005/lib000755001750001750 013136533065 14050 5ustar00zeframzefram000000000000Date-ISO8601-0.005/lib/Date000755001750001750 013136533065 14725 5ustar00zeframzefram000000000000Date-ISO8601-0.005/lib/Date/ISO8601.pm000444001750001750 3653613136533065 16426 0ustar00zeframzefram000000000000=head1 NAME Date::ISO8601 - the three ISO 8601 numerical calendars =head1 SYNOPSIS use Date::ISO8601 qw(present_y); print present_y($y); use Date::ISO8601 qw( month_days cjdn_to_ymd ymd_to_cjdn present_ymd); $md = month_days(2000, 2); ($y, $m, $d) = cjdn_to_ymd(2406029); $cjdn = ymd_to_cjdn(1875, 5, 20); print present_ymd(2406029); print present_ymd(1875, 5, 20); use Date::ISO8601 qw(year_days cjdn_to_yd yd_to_cjdn present_yd); $yd = year_days(2000); ($y, $d) = cjdn_to_yd(2406029); $cjdn = yd_to_cjdn(1875, 140); print present_yd(2406029); print present_yd(1875, 140); use Date::ISO8601 qw( year_weeks cjdn_to_ywd ywd_to_cjdn present_ywd); $yw = year_weeks(2000); ($y, $w, $d) = cjdn_to_ywd(2406029); $cjdn = ywd_to_cjdn(1875, 20, 4); print present_ywd(2406029); print present_ywd(1875, 20, 4); =head1 DESCRIPTION The international standard ISO 8601 "Data elements and interchange formats - Information interchange - Representation of dates and times" defines three distinct calendars by which days can be labelled. It also defines textual formats for the representation of dates in these calendars. This module provides functions to convert dates between these three calendars and Chronological Julian Day Numbers, which is a suitable format to do arithmetic with. It also supplies functions that describe the shape of these calendars, to assist in calendrical calculations. It also supplies functions to represent dates textually in the ISO 8601 formats. ISO 8601 also covers time of day and time periods, but this module does nothing relating to those parts of the standard; this is only about labelling days. The first ISO 8601 calendar divides time up into years, months, and days. It corresponds exactly to the Gregorian calendar, invented by Aloysius Lilius and promulgated by Pope Gregory XIII in the late sixteenth century, with AD (CE) year numbering. This calendar is applied to all time, not just to dates after its invention nor just to years 1 and later. Thus for ancient dates it is the proleptic Gregorian calendar with astronomical year numbering. The second ISO 8601 calendar divides time up into the same years as the first, but divides the year directly into days, with no months. The standard calls this "ordinal dates". Ordinal dates are commonly referred to as "Julian dates", a mistake apparently deriving from true Julian Day Numbers, which divide time up solely into linearly counted days. The third ISO 8601 calendar divides time up into years, weeks, and days. The years approximate the years of the first two calendars, so they stay in step in the long term, but the boundaries differ. This week-based calendar is sometimes called "the ISO calendar", apparently in the belief that ISO 8601 does not define any other. It is also referred to as "business dates", because it is most used by certain businesses to whom the week is the most important temporal cycle. The Chronological Julian Day Number is an integral number labelling each day, where the day extends from midnight to midnight in whatever time zone is of interest. It is a linear count of days, where each day's number is one greater than the previous day's number. It is directly related to the Julian Date system: in the time zone of the prime meridian, the CJDN equals the JD at noon. By way of epoch, the day on which the Convention of the Metre was signed, which ISO 8601 defines to be 1875-05-20 (and 1875-140 and 1875-W20-4), is CJDN 2406029. This module places no limit on the range of dates to which it may be applied. All function arguments are permitted to be C or C objects in order to achieve arbitrary range. Native Perl integers are also permitted, as a convenience when the range of dates being handled is known to be sufficiently small. =cut package Date::ISO8601; { use 5.006; } use warnings; use strict; use Carp qw(croak); our $VERSION = "0.005"; use parent "Exporter"; our @EXPORT_OK = qw( present_y month_days cjdn_to_ymd ymd_to_cjdn present_ymd year_days cjdn_to_yd yd_to_cjdn present_yd year_weeks cjdn_to_ywd ywd_to_cjdn present_ywd ); # _numify(A): turn possibly-object number into native Perl integer sub _numify($) { my($a) = @_; return ref($a) eq "" ? $a : $a->numify; } # _fdiv(A, B): divide A by B, flooring remainder # # B must be a positive Perl integer. A may be a Perl integer, Math::BigInt, # or Math::BigRat. The result has the same type as A. sub _fdiv($$) { my($a, $b) = @_; if(ref($a) eq "Math::BigRat") { return ($a / $b)->bfloor; } else { if($a < 0) { use integer; return -(($b - 1 - $a) / $b); } else { use integer; return $a / $b; } } } # _fmod(A, B): A modulo B, flooring remainder # # B must be a positive Perl integer. A may be a Perl integer, Math::BigInt, # or Math::BigRat. The result has the same type as A. sub _fmod($$) { my($a, $b) = @_; if(ref($a) eq "Math::BigRat") { return $a - $b * ($a / $b)->bfloor; } else { return $a % $b; } } =head1 FUNCTIONS Numbers in this API may be native Perl integers, C objects, or integer-valued C objects. All three types are acceptable for all parameters, in any combination. In all conversion functions, the most-significant part of the result (which is the only part with unlimited range) is of the same type as the most-significant part of the input. Less-significant parts of results (which have a small range) are consistently native Perl integers. All functions C if given invalid parameters. =head2 Years =over =item present_y(YEAR) Puts the given year number into ISO 8601 textual presentation format. For years [0, 9999] this is simply four digits. For years outside that range it is a sign followed by at least four digits. This is the minimum-length presentation format. If it is desired to use a form that is longer than necessary, such as to use at least five digits for all year numbers (as the Long Now Foundation does), then the right tool is C (see L). This format is unconditionally conformant to all versions of ISO 8601 for years [1583, 9999]. For years [0, 1582], preceding the historical introduction of the Gregorian calendar, it is conformant only where it is mutually agreed that such dates (represented in the proleptic Gregorian calendar) are acceptable. For years outside the range [0, 9999], where the expanded format must be used, the result is only conformant to ISO 8601:2004 (earlier versions lacked these formats), and only where it is mutually agreed to use this format. =cut sub present_y($) { my($y) = @_; my($sign, $digits) = ("$y" =~ /\A\+?(-?)0*([0-9]+?)\z/); $digits = ("0" x (4 - length($digits))).$digits unless length($digits) >= 4; $sign = "+" if $sign eq "" && length($digits) > 4; return $sign.$digits; } =back =head2 Gregorian calendar Each year is divided into twelve months, numbered [1, 12]; month number 1 is January. Each month is divided into days, numbered sequentially from 1. The month lengths are irregular. The year numbers have unlimited range. =over =item month_days(YEAR, MONTH) The parameters identify a month, and the function returns the number of days in that month as a native Perl integer. =cut sub _year_leap($) { my($y) = @_; return _fmod($y, 4) == 0 && (_fmod($y, 100) != 0 || _fmod($y, 400) == 0); } { my @month_length = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); sub month_days($$) { my($y, $m) = @_; croak "month number $m is out of the range [1, 12]" unless $m >= 1 && $m <= 12; if($m == 2) { return _year_leap($y) ? 29 : 28; } else { return $month_length[$m - 1]; } } } { my @nonleap_monthstarts = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365); my @leap_monthstarts = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366); sub _year_monthstarts($) { my($y) = @_; return _year_leap($y) ? \@leap_monthstarts : \@nonleap_monthstarts; } } =item cjdn_to_ymd(CJDN) This function takes a Chronological Julian Day Number and returns a list of a year, month, and day. =cut sub cjdn_to_yd($); sub cjdn_to_ymd($) { my($cjdn) = @_; my($y, $d) = cjdn_to_yd($cjdn); my $monthstarts = _year_monthstarts($y); my $m = 1; while($d > $monthstarts->[$m]) { $m++; } return ($y, $m, $d - $monthstarts->[$m - 1]); } =item ymd_to_cjdn(YEAR, MONTH, DAY) This performs the reverse of the translation that C does. It takes year, month, and day numbers, and returns the corresponding CJDN. =cut sub yd_to_cjdn($$); sub ymd_to_cjdn($$$) { my($y, $m, $d) = @_; croak "month number $m is out of the range [1, 12]" unless $m >= 1 && $m <= 12; $m = _numify($m); my $monthstarts = _year_monthstarts($y); my $md = $monthstarts->[$m] - $monthstarts->[$m - 1]; croak "day number $d is out of the range [1, $md]" unless $d >= 1 && $d <= $md; $d = _numify($d); return yd_to_cjdn($y, $monthstarts->[$m - 1] + $d); } =item present_ymd(CJDN) =item present_ymd(YEAR, MONTH, DAY) Puts the given date into ISO 8601 Gregorian textual presentation format. The `extended' format (with "-" separators) is used. The conformance notes for C apply to this function also. If the date is given as a (YEAR, MONTH, DAY) triplet then these are not checked for consistency. The MONTH and DAY values are only checked to ensure that they fit into the fixed number of digits. This allows the use of this function on data other than actual Gregorian dates. =cut sub present_ymd($;$$) { my($y, $m, $d); if(@_ == 1) { ($y, $m, $d) = cjdn_to_ymd($_[0]); } else { ($y, $m, $d) = @_; croak "month number $m is out of the displayable range" unless $m >= 0 && $m < 100; croak "day number $d is out of the displayable range" unless $d >= 0 && $d < 100; } return sprintf("%s-%02d-%02d", present_y($y), _numify($m), _numify($d)); } =back =head2 Ordinal dates Each year is divided into days, numbered sequentially from 1. The year lengths are irregular. The years correspond exactly to those of the Gregorian calendar. =over =item year_days(YEAR) The parameter identifies a year, and the function returns the number of days in that year as a native Perl integer. =cut sub year_days($) { my($y) = @_; return _year_leap($y) ? 366 : 365; } use constant GREGORIAN_ZERO_CJDN => 1721060; # 0000-001 =item cjdn_to_yd(CJDN) This function takes a Chronological Julian Day Number and returns a list of a year and ordinal day. =cut sub cjdn_to_yd($) { my($cjdn) = @_; use integer; my $d = $cjdn - GREGORIAN_ZERO_CJDN; my $qcents = _fdiv($d, 365*400 + 97); $d = _numify($d - $qcents * (365*400 + 97)); my $y = $d / 366; my $leaps = ($y + 3) / 4; $leaps -= ($leaps - 1) / 25 unless $leaps == 0; $d -= 365 * $y + $leaps; my $yd = year_days($y); if($d >= $yd) { $d -= $yd; $y++; } return ($qcents*400 + $y, 1 + $d); } =item yd_to_cjdn(YEAR, DAY) This performs the reverse of the translation that C does. It takes year and ordinal day numbers, and returns the corresponding CJDN. =cut sub yd_to_cjdn($$) { my($y, $d) = @_; use integer; my $qcents = _fdiv($y, 400); $y = _numify($y - $qcents * 400); my $yd = year_days($y); croak "day number $d is out of the range [1, $yd]" unless $d >= 1 && $d <= $yd; $d = _numify($d); my $leaps = ($y + 3) / 4; $leaps -= ($leaps - 1) / 25 unless $leaps == 0; return (GREGORIAN_ZERO_CJDN + 365*$y + $leaps + ($d - 1)) + $qcents * (365*400 + 97); } =item present_yd(CJDN) =item present_yd(YEAR, DAY) Puts the given date into ISO 8601 ordinal textual presentation format. The `extended' format (with "-" separators) is used. The conformance notes for C apply to this function also. If the date is given as a (YEAR, DAY) pair then these are not checked for consistency. The DAY value is only checked to ensure that it fits into the fixed number of digits. This allows the use of this function on data other than actual ordinal dates. =cut sub present_yd($;$) { my($y, $d); if(@_ == 1) { ($y, $d) = cjdn_to_yd($_[0]); } else { ($y, $d) = @_; croak "day number $d is out of the displayable range" unless $d >= 0 && $d < 1000; } return sprintf("%s-%03d", present_y($y), _numify($d)); } =back =head2 Week-based calendar Each year is divided into weeks, numbered sequentially from 1. Each week is divided into seven days, numbered [1, 7]; day number 1 is Monday. The year lengths are irregular. The year numbers have unlimited range. The years correspond to those of the Gregorian calendar. Each week is associated with the Gregorian year that contains its Thursday and hence contains the majority of its days. =over =item year_weeks(YEAR) The parameter identifies a year, and the function returns the number of weeks in that year as a native Perl integer. =cut # _year_phase(YEAR): find day of week of first day of year # # The argument must be a native Perl integer. The return value is # zero-based, in the range 0 = Monday to 6 = Sunday. sub _year_phase($) { my($y) = @_; return yd_to_cjdn($y, 1) % 7; } sub year_weeks($) { my($y) = @_; $y = _numify(_fmod($y, 400)); my $phase = _year_phase($y); return $phase == 3 || ($phase == 2 && _year_leap($y)) ? 53 : 52; } =item cjdn_to_ywd(CJDN) This function takes a Chronological Julian Day Number and returns a list of a year, week, and day. =cut sub cjdn_to_ywd($) { my($cjdn) = @_; my($y, $d) = cjdn_to_yd($cjdn); my $py = _numify(_fmod($y, 400)); my $phase = _year_phase($py); my $start_wk1 = ($phase <= 3 ? 1 : 8) - $phase; my $w = _fdiv($d - $start_wk1, 7); if($w == -1) { $y--; $w = year_weeks($py - 1); } elsif($w >= year_weeks($py)) { $y++; $w = 1; } else { $w++; } return ($y, $w, ($d - $start_wk1) % 7 + 1); } =item ywd_to_cjdn(YEAR, WEEK, DAY) This performs the reverse of the translation that C does. It takes year, week, and day numbers, and returns the corresponding CJDN. =cut sub ywd_to_cjdn($$$) { my($y, $w, $d) = @_; my $yw = year_weeks($y); croak "week number $w is out of the range [1, $yw]" unless $w >= 1 && $w <= $yw; croak "day number $d is out of the range [1, 7]" unless $d >= 1 && $d <= 7; my $start_cjdn = yd_to_cjdn($y, 1); my $phase = _fmod($start_cjdn, 7); return $start_cjdn + (($phase <= 3 ? -8 : -1) - $phase + _numify($w)*7 + _numify($d)); } =item present_ywd(CJDN) =item present_ywd(YEAR, WEEK, DAY) Puts the given date into ISO 8601 week-based textual presentation format. The `extended' format (with "-" separators) is used. The conformance notes for C apply to this function also. If the date is given as a (YEAR, WEEK, DAY) triplet then these are not checked for consistency. The WEEK and DAY values are only checked to ensure that they fit into the fixed number of digits. This allows the use of this function on data other than actual week-based dates. =cut sub present_ywd($;$$) { my($y, $w, $d); if(@_ == 1) { ($y, $w, $d) = cjdn_to_ywd($_[0]); } else { ($y, $w, $d) = @_; croak "week number $w is out of the displayable range" unless $w >= 0 && $w < 100; croak "day number $d is out of the displayable range" unless $d >= 0 && $d < 10; } return sprintf("%s-W%02d-%d", present_y($y), _numify($w), _numify($d)); } =back =head1 SEE ALSO L, L =head1 AUTHOR Andrew Main (Zefram) =head1 COPYRIGHT Copyright (C) 2006, 2007, 2009, 2011, 2017 Andrew Main (Zefram) =head1 LICENSE This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut 1; Date-ISO8601-0.005/t000755001750001750 013136533065 13545 5ustar00zeframzefram000000000000Date-ISO8601-0.005/t/pod_cvg.t000444001750001750 27313136533065 15472 0ustar00zeframzefram000000000000use warnings; use strict; use Test::More; plan skip_all => "Test::Pod::Coverage not available" unless eval "use Test::Pod::Coverage; 1"; Test::Pod::Coverage::all_pod_coverage_ok(); 1; Date-ISO8601-0.005/t/pod_syn.t000444001750001750 23613136533065 15523 0ustar00zeframzefram000000000000use warnings; use strict; use Test::More; plan skip_all => "Test::Pod not available" unless eval "use Test::Pod 1.00; 1"; Test::Pod::all_pod_files_ok(); 1; Date-ISO8601-0.005/t/y.t000444001750001750 154313136533065 14342 0ustar00zeframzefram000000000000use warnings; use strict; use Test::More tests => 1 + 3*14; BEGIN { use_ok "Date::ISO8601", qw(present_y); } my $have_bigint = eval("use Math::BigInt; 1"); my $have_bigrat = eval("use Math::BigRat 0.02; 1"); my @prep = ( sub { $_[0] }, sub { $have_bigint ? Math::BigInt->new($_[0]) : undef }, sub { $have_bigrat ? Math::BigRat->new($_[0]) : undef }, ); sub check($$) { my($y, $pres) = @_; foreach my $prep (@prep) { SKIP: { my $py = $prep->($y); skip "numeric type unavailable", 1 unless defined $py; is present_y($py), $pres; } } } check(-123456, "-123456"); check(-12345, "-12345"); check(-1234, "-1234"); check(-123, "-0123"); check(-12, "-0012"); check(-1, "-0001"); check(0, "0000"); check(1, "0001"); check(12, "0012"); check(123, "0123"); check(1234, "1234"); check(12345, "+12345"); check(123456, "+123456"); check("+00000123", "0123"); 1; Date-ISO8601-0.005/t/yd.t000444001750001750 426213136533065 14507 0ustar00zeframzefram000000000000use warnings; use strict; use Test::More tests => 1 + 3*8 + 3 + 6*9 + 9; BEGIN { use_ok "Date::ISO8601", qw(year_days cjdn_to_yd yd_to_cjdn present_yd); } my $have_bigint = eval("use Math::BigInt 1.16; 1"); my $have_bigrat = eval("use Math::BigRat 0.04; 1"); sub match_val($$) { my($a, $b) = @_; ok ref($a) eq ref($b) && $a == $b; } sub match_vec($$) { my($a, $b) = @_; unless(@$a == @$b) { ok 0; return; } for(my $i = 0; $i != @$a; $i++) { my $aval = $a->[$i]; my $bval = $b->[$i]; unless(ref($aval) eq ref($bval) && $aval == $bval) { ok 0; return; } } ok 1; } my @prep = ( sub { $_[0] }, sub { $have_bigint ? Math::BigInt->new($_[0]) : undef }, sub { $have_bigrat ? Math::BigRat->new($_[0]) : undef }, ); sub check_days($$) { my($y, $yd) = @_; foreach my $prep (@prep) { SKIP: { my $py = $prep->($y); skip "numeric type unavailable", 1 unless defined $py; match_val year_days($py), $yd; } } } check_days(-2000, 366); check_days(-1999, 365); check_days(-1996, 366); check_days(-1900, 365); check_days(2000, 366); check_days(2001, 365); check_days(2004, 366); check_days(2100, 365); eval { yd_to_cjdn(2000, 0); }; like $@, qr/\Aday number /; eval { yd_to_cjdn(2000, 367); }; like $@, qr/\Aday number /; eval { yd_to_cjdn(2001, 366); }; like $@, qr/\Aday number /; sub check_conv($$$) { my($cjdn, $y, $d) = @_; foreach my $prep (@prep) { SKIP: { skip "numeric type unavailable", 2 unless defined $prep->(0); match_vec [ cjdn_to_yd($prep->($cjdn)) ], [ $prep->($y), $d ]; match_vec [ $prep->($cjdn) ], [ yd_to_cjdn($prep->($y), $d) ]; } } } check_conv(0, -4713, 328); check_conv(1721060, 0, 1); check_conv(2406029, 1875, 140); check_conv(2441317, 1971, 365); check_conv(2441318, 1972, 1); check_conv(2443144, 1976, 366); check_conv(2443145, 1977, 1); check_conv(2451544, 1999, 365); check_conv(2451545, 2000, 1); is present_yd(2406029), "1875-140"; is present_yd(1875, 140), "1875-140"; is present_yd(2451545), "2000-001"; is present_yd(2000, 1), "2000-001"; is present_yd(1233, 0), "1233-000"; is present_yd(1233, 366), "1233-366"; is present_yd(1233, 999), "1233-999"; eval { present_yd(1233, -1) }; isnt $@, ""; eval { present_yd(1233, 1000) }; isnt $@, ""; 1; Date-ISO8601-0.005/t/ymd.t000444001750001750 566213136533065 14671 0ustar00zeframzefram000000000000use warnings; use strict; use Test::More tests => 1 + 3*19 + 6 + 6*11 + 11; BEGIN { use_ok "Date::ISO8601", qw(month_days cjdn_to_ymd ymd_to_cjdn present_ymd); } my $have_bigint = eval("use Math::BigInt 1.16; 1"); my $have_bigrat = eval("use Math::BigRat 0.04; 1"); sub match_val($$) { my($a, $b) = @_; ok ref($a) eq ref($b) && $a == $b; } sub match_vec($$) { my($a, $b) = @_; unless(@$a == @$b) { ok 0; return; } for(my $i = 0; $i != @$a; $i++) { my $aval = $a->[$i]; my $bval = $b->[$i]; unless(ref($aval) eq ref($bval) && $aval == $bval) { ok 0; return; } } ok 1; } my @prep = ( sub { $_[0] }, sub { $have_bigint ? Math::BigInt->new($_[0]) : undef }, sub { $have_bigrat ? Math::BigRat->new($_[0]) : undef }, ); sub check_days($$$) { my($y, $m, $md) = @_; foreach my $prep (@prep) { SKIP: { my $py = $prep->($y); skip "numeric type unavailable", 1 unless defined $py; match_val month_days($py, $m), $md; } } } check_days(-2000, 2, 29); check_days(-1999, 2, 28); check_days(-1996, 2, 29); check_days(-1900, 2, 28); check_days(2000, 2, 29); check_days(2001, 2, 28); check_days(2004, 2, 29); check_days(2100, 2, 28); check_days(2100, 1, 31); check_days(2100, 3, 31); check_days(2100, 4, 30); check_days(2100, 5, 31); check_days(2100, 6, 30); check_days(2100, 7, 31); check_days(2100, 8, 31); check_days(2100, 9, 30); check_days(2100, 10, 31); check_days(2100, 11, 30); check_days(2100, 12, 31); eval { ymd_to_cjdn(2000, 0, 1); }; like $@, qr/\Amonth number /; eval { ymd_to_cjdn(2000, 13, 1); }; like $@, qr/\Amonth number /; eval { ymd_to_cjdn(2000, 1, 0); }; like $@, qr/\Aday number /; eval { ymd_to_cjdn(2000, 1, 32); }; like $@, qr/\Aday number /; eval { ymd_to_cjdn(2000, 2, 30); }; like $@, qr/\Aday number /; eval { ymd_to_cjdn(2001, 2, 29); }; like $@, qr/\Aday number /; sub check_conv($$$$) { my($cjdn, $y, $m, $d) = @_; foreach my $prep (@prep) { SKIP: { skip "numeric type unavailable", 2 unless defined $prep->(0); match_vec [ cjdn_to_ymd($prep->($cjdn)) ], [ $prep->($y), $m, $d ]; match_vec [ $prep->($cjdn) ], [ ymd_to_cjdn($prep->($y), $m, $d) ]; } } } check_conv(0, -4713, 11, 24); check_conv(1721060, 0, 1, 1); check_conv(2406029, 1875, 5, 20); check_conv(2441317, 1971, 12, 31); check_conv(2441318, 1972, 1, 1); check_conv(2443144, 1976, 12, 31); check_conv(2443145, 1977, 1, 1); check_conv(2451544, 1999, 12, 31); check_conv(2451545, 2000, 1, 1); check_conv(2451604, 2000, 2, 29); check_conv(2451605, 2000, 3, 1); is present_ymd(2406029), "1875-05-20"; is present_ymd(1875, 5, 20), "1875-05-20"; is present_ymd(2451545), "2000-01-01"; is present_ymd(2000, 1, 1), "2000-01-01"; is present_ymd(1233, 0, 0), "1233-00-00"; is present_ymd(1233, 2, 29), "1233-02-29"; is present_ymd(1233, 99, 99), "1233-99-99"; eval { present_ymd(1233, -1, 1) }; isnt $@, ""; eval { present_ymd(1233, 100, 1) }; isnt $@, ""; eval { present_ymd(1233, 1, -1) }; isnt $@, ""; eval { present_ymd(1233, 1, 100) }; isnt $@, ""; 1; Date-ISO8601-0.005/t/ywd.t000444001750001750 575713136533065 14710 0ustar00zeframzefram000000000000use warnings; use strict; use Test::More tests => 1 + 3*12 + 5 + 6*21 + 11; BEGIN { use_ok "Date::ISO8601", qw(year_weeks cjdn_to_ywd ywd_to_cjdn present_ywd); } my $have_bigint = eval("use Math::BigInt 1.16; 1"); my $have_bigrat = eval("use Math::BigRat 0.04; 1"); sub match_val($$) { my($a, $b) = @_; ok ref($a) eq ref($b) && $a == $b; } sub match_vec($$) { my($a, $b) = @_; unless(@$a == @$b) { ok 0; return; } for(my $i = 0; $i != @$a; $i++) { my $aval = $a->[$i]; my $bval = $b->[$i]; unless(ref($aval) eq ref($bval) && $aval == $bval) { ok 0; return; } } ok 1; } my @prep = ( sub { $_[0] }, sub { $have_bigint ? Math::BigInt->new($_[0]) : undef }, sub { $have_bigrat ? Math::BigRat->new($_[0]) : undef }, ); sub check_weeks($$) { my($y, $yw) = @_; foreach my $prep (@prep) { SKIP: { my $py = $prep->($y); skip "numeric type unavailable", 1 unless defined $py; match_val year_weeks($py), $yw; } } } check_weeks(-1994, 52); check_weeks(-1993, 52); check_weeks(-1991, 53); check_weeks(-1985, 53); check_weeks(-1980, 53); check_weeks(-1975, 52); check_weeks(2006, 52); check_weeks(2007, 52); check_weeks(2009, 53); check_weeks(2015, 53); check_weeks(2020, 53); check_weeks(2025, 52); eval { ywd_to_cjdn(2006, 0, 1); }; like $@, qr/\Aweek number /; eval { ywd_to_cjdn(2006, 53, 1); }; like $@, qr/\Aweek number /; eval { ywd_to_cjdn(2009, 54, 1); }; like $@, qr/\Aweek number /; eval { ywd_to_cjdn(2000, 1, 0); }; like $@, qr/\Aday number /; eval { ywd_to_cjdn(2000, 1, 8); }; like $@, qr/\Aday number /; sub check_conv($$$$) { my($cjdn, $y, $w, $d) = @_; foreach my $prep (@prep) { SKIP: { skip "numeric type unavailable", 2 unless defined $prep->(0); match_vec [ cjdn_to_ywd($prep->($cjdn)) ], [ $prep->($y), $w, $d ]; match_vec [ $prep->($cjdn) ], [ ywd_to_cjdn($prep->($y), $w, $d) ]; } } } check_conv(0, -4713, 48, 1); check_conv(1721060, -1, 52, 6); check_conv(2406029, 1875, 20, 4); check_conv(2441317, 1971, 52, 5); check_conv(2441318, 1971, 52, 6); check_conv(2441319, 1971, 52, 7); check_conv(2441320, 1972, 1, 1); check_conv(2441683, 1972, 52, 7); check_conv(2441684, 1973, 1, 1); check_conv(2442047, 1973, 52, 7); check_conv(2442048, 1974, 1, 1); check_conv(2442049, 1974, 1, 2); check_conv(2443139, 1976, 52, 7); check_conv(2443140, 1976, 53, 1); check_conv(2443141, 1976, 53, 2); check_conv(2443142, 1976, 53, 3); check_conv(2443143, 1976, 53, 4); check_conv(2443144, 1976, 53, 5); check_conv(2443145, 1976, 53, 6); check_conv(2443146, 1976, 53, 7); check_conv(2443147, 1977, 1, 1); is present_ywd(2406029), "1875-W20-4"; is present_ywd(1875, 20, 4), "1875-W20-4"; is present_ywd(2441320), "1972-W01-1"; is present_ywd(1972, 1, 1), "1972-W01-1"; is present_ywd(1233, 0, 0), "1233-W00-0"; is present_ywd(1233, 53, 1), "1233-W53-1"; is present_ywd(1233, 99, 9), "1233-W99-9"; eval { present_ywd(1233, -1, 1) }; isnt $@, ""; eval { present_ywd(1233, 100, 1) }; isnt $@, ""; eval { present_ywd(1233, 1, -1) }; isnt $@, ""; eval { present_ywd(1233, 1, 10) }; isnt $@, ""; 1;