ruby-sdn 2.0.0

data/ext/sdn/julian.c

@@ -0,0 +1,245 @@
+/* $selId: julian.c,v 2.0 1995/10/24 01:13:06 lees Exp $
+ * Copyright 1993-1995, Scott E. Lee, all rights reserved.
+ * Permission granted to use, copy, modify, distribute and sell so long as
+ * the above copyright and this permission statement are retained in all
+ * copies.  THERE IS NO WARRANTY - USE AT YOUR OWN RISK.
+ */
+
+/**************************************************************************
+ *
+ * These are the externally visible components of this file:
+ *
+ *     void
+ *     SdnToJulian(
+ *         long int  sdn,
+ *         int      *pYear,
+ *         int      *pMonth,
+ *         int      *pDay);
+ *
+ * Convert a SDN to a Julian calendar date.  If the input SDN is less than
+ * 1, the three output values will all be set to zero, otherwise *pYear
+ * will be >= -4713 and != 0; *pMonth will be in the range 1 to 12
+ * inclusive; *pDay will be in the range 1 to 31 inclusive.
+ *
+ *     long int
+ *     JulianToSdn(
+ *         int inputYear,
+ *         int inputMonth,
+ *         int inputDay);
+ *
+ * Convert a Julian calendar date to a SDN.  Zero is returned when the
+ * input date is detected as invalid or out of the supported range.  The
+ * return value will be > 0 for all valid, supported dates, but there are
+ * some invalid dates that will return a positive value.  To verify that a
+ * date is valid, convert it to SDN and then back and compare with the
+ * original.
+ *
+ * VALID RANGE
+ *
+ *     4713 B.C. to at least 10000 A.D.
+ *
+ *     Although this software can handle dates all the way back to 4713
+ *     B.C., such use may not be meaningful.  The calendar was created in
+ *     46 B.C., but the details did not stabilize until at least 8 A.D.,
+ *     and perhaps as late at the 4th century.  Also, the beginning of a
+ *     year varied from one culture to another - not all accepted January
+ *     as the first month.
+ *
+ * CALENDAR OVERVIEW
+ *
+ *     Julias Ceasar created the calendar in 46 B.C. as a modified form of
+ *     the old Roman republican calendar which was based on lunar cycles.
+ *     The new Julian calendar set fixed lengths for the months, abandoning
+ *     the lunar cycle.  It also specified that there would be exactly 12
+ *     months per year and 365.25 days per year with every 4th year being a
+ *     leap year.
+ *
+ *     Note that the current accepted value for the tropical year is
+ *     365.242199 days, not 365.25.  This lead to an 11 day shift in the
+ *     calendar with respect to the seasons by the 16th century when the
+ *     Gregorian calendar was created to replace the Julian calendar.
+ *
+ *     The difference between the Julian and today's Gregorian calendar is
+ *     that the Gregorian does not make centennial years leap years unless
+ *     they are a multiple of 400, which leads to a year of 365.2425 days.
+ *     In other words, in the Gregorian calendar, 1700, 1800 and 1900 are
+ *     not leap years, but 2000 is.  All centennial years are leap years in
+ *     the Julian calendar.
+ *
+ *     The details are unknown, but the lengths of the months were adjusted
+ *     until they finally stablized in 8 A.D. with their current lengths:
+ *
+ *         January          31
+ *         February         28/29
+ *         March            31
+ *         April            30
+ *         May              31
+ *         June             30
+ *         Quintilis/July   31
+ *         Sextilis/August  31
+ *         September        30
+ *         October          31
+ *         November         30
+ *         December         31
+ *
+ *     In the early days of the calendar, the days of the month were not
+ *     numbered as we do today.  The numbers ran backwards (decreasing) and
+ *     were counted from the Ides (15th of the month - which in the old
+ *     Roman republican lunar calendar would have been the full moon) or
+ *     from the Nonae (9th day before the Ides) or from the beginning of
+ *     the next month.
+ *
+ *     In the early years, the beginning of the year varied, sometimes
+ *     based on the ascension of rulers.  It was not always the first of
+ *     January.
+ *
+ *     Also, today's epoch, 1 A.D. or the birth of Jesus Christ, did not
+ *     come into use until several centuries later when Christianity became
+ *     a dominant religion.
+ *
+ * ALGORITHMS
+ *
+ *     The calculations are based on two different cycles: a 4 year cycle
+ *     of leap years and a 5 month cycle of month lengths.
+ *
+ *     The 5 month cycle is used to account for the varying lengths of
+ *     months.  You will notice that the lengths alternate between 30 and
+ *     31 days, except for three anomalies: both July and August have 31
+ *     days, both December and January have 31, and February is less than
+ *     30.  Starting with March, the lengths are in a cycle of 5 months
+ *     (31, 30, 31, 30, 31):
+ *
+ *         Mar   31 days  \
+ *         Apr   30 days   |
+ *         May   31 days    > First cycle
+ *         Jun   30 days   |
+ *         Jul   31 days  /
+ *
+ *         Aug   31 days  \
+ *         Sep   30 days   |
+ *         Oct   31 days    > Second cycle
+ *         Nov   30 days   |
+ *         Dec   31 days  /
+ *
+ *         Jan   31 days  \
+ *         Feb 28/9 days   |
+ *                          > Third cycle (incomplete)
+ *
+ *     For this reason the calculations (internally) assume that the year
+ *     starts with March 1.
+ *
+ * TESTING
+ *
+ *     This algorithm has been tested from the year 4713 B.C. to 10000 A.D.
+ *     The source code of the verification program is included in this
+ *     package.
+ *
+ * REFERENCES
+ *
+ *     Conversions Between Calendar Date and Julian Day Number by Robert J.
+ *     Tantzen, Communications of the Association for Computing Machinery
+ *     August 1963.  (Also published in Collected Algorithms from CACM,
+ *     algorithm number 199).  [Note: the published algorithm is for the
+ *     Gregorian calendar, but was adjusted to use the Julian calendar's
+ *     simpler leap year rule.]
+ *
+ **************************************************************************/
+
+#include "sdncal.h"
+
+#define SDN_OFFSET         32083
+#define DAYS_PER_5_MONTHS  153
+#define DAYS_PER_4_YEARS   1461
+
+void
+SdnToJulian(
+    long int  sdn,
+    int      *pYear,
+    int      *pMonth,
+    int      *pDay)
+{
+    int       year;
+    int       month;
+    int       day;
+    long int  temp;
+    int       dayOfYear;
+
+    if (sdn <= 0) {
+	*pYear = 0;
+	*pMonth = 0;
+	*pDay = 0;
+	return;
+    }
+
+    temp = (sdn + SDN_OFFSET) * 4 - 1;
+
+    /* Calculate the year and day of year (1 <= dayOfYear <= 366). */
+    year = temp / DAYS_PER_4_YEARS;
+    dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
+
+    /* Calculate the month and day of month. */
+    temp = dayOfYear * 5 - 3;
+    month = temp / DAYS_PER_5_MONTHS;
+    day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
+
+    /* Convert to the normal beginning of the year. */
+    if (month < 10) {
+	month += 3;
+    } else {
+	year += 1;
+	month -= 9;
+    }
+
+    /* Adjust to the B.C./A.D. type numbering. */
+    year -= 4800;
+    if (year <= 0) year--;
+
+    *pYear = year;
+    *pMonth = month;
+    *pDay = day;
+}
+
+long int
+JulianToSdn(
+    int inputYear,
+    int inputMonth,
+    int inputDay)
+{
+    int year;
+    int month;
+
+    /* check for invalid dates */
+    if (inputYear == 0 || inputYear < -4713 ||
+	inputMonth <= 0 || inputMonth > 12 ||
+	inputDay <= 0 || inputDay > 31)
+    {
+	return(0);
+    }
+
+    /* check for dates before SDN 1 (Jan 2, 4713 B.C.) */
+    if (inputYear == -4713) {
+	if (inputMonth == 1 && inputDay == 1) {
+	    return(0);
+	}
+    }
+
+    /* Make year always a positive number. */
+    if (inputYear < 0) {
+	year = inputYear + 4801;
+    } else {
+	year = inputYear + 4800;
+    }
+
+    /* Adjust the start of the year. */
+    if (inputMonth > 2) {
+	month = inputMonth - 3;
+    } else {
+	month = inputMonth + 9;
+	year--;
+    }
+
+    return( (year * DAYS_PER_4_YEARS) / 4
+	    + (month * DAYS_PER_5_MONTHS + 2) / 5
+	    + inputDay
+	    - SDN_OFFSET );
+}

data/ext/sdn/sdncal.h

@@ -0,0 +1,90 @@
+#ifndef _INCLUDED_SDNCAL_H
+#define _INCLUDED_SDNCAL_H
+
+/* $selId: sdncal.h,v 2.0 1995/10/24 01:13:06 lees Exp $
+ * Copyright 1993-1995, Scott E. Lee, all rights reserved.
+ * Permission granted to use, copy, modify, distribute and sell so long as
+ * the above copyright and this permission statement are retained in all
+ * copies.  THERE IS NO WARRANTY - USE AT YOUR OWN RISK.
+ */
+
+/**************************************************************************
+ *
+ * This package defines a set of routines that convert calendar dates to
+ * and from a serial day number (SDN).  The SDN is a serial numbering of
+ * days where SDN 1 is November 25, 4714 BC in the Gregorian calendar and
+ * SDN 2447893 is January 1, 1990.  This system of day numbering is
+ * sometimes referred to as Julian days, but to avoid confusion with the
+ * Julian calendar, it is referred to as serial day numbers here.  The term
+ * Julian days is also used to mean the number of days since the beginning
+ * of the current year.
+ *
+ * The SDN can be used as an intermediate step in converting from one
+ * calendar system to another (such as Gregorian to Jewish).  It can also
+ * be used for date computations such as easily comparing two dates,
+ * determining the day of the week, finding the date of yesterday or
+ * calculating the number of days between two dates.
+ *
+ * When using this software on 16 bit systems, be careful to store SDNs in
+ * a long int, because it will not fit in the 16 bits that some systems
+ * allocate to an int.
+ *
+ * For each calendar, there are two routines provided.  One converts dates
+ * in that calendar to SDN and the other converts SDN to calendar dates.
+ * The routines are named SdnTo<CALENDAR>() and <CALENDAR>ToSdn(), where
+ * <CALENDAR> is the name of the calendar system.
+ *
+ * SDN values less than one are not supported.  If a conversion routine
+ * returns an SDN of zero, this means that the date given is either invalid
+ * or is outside the supported range for that calendar.
+ *
+ * At least some validity checks are performed on input dates.  For
+ * example, a negative month number will result in the return of zero for
+ * the SDN.  A returned SDN greater than one does not necessarily mean that
+ * the input date was valid.  To determine if the date is valid, convert it
+ * to SDN, and if the SDN is greater than zero, convert it back to a date
+ * and compare to the original.  For example:
+ *
+ *    int y1, m1, d1;
+ *    int y2, m2, d2;
+ *    long int sdn;
+ *    ...
+ *    sdn = GregorianToSdn(y1, m1, d1);
+ *    if (sdn > 0) {
+ *        SdnToGregorian(sdn, &y2, &m2, &d2);
+ *        if (y1 == y2 && m1 == m2 && d1 == d2) {
+ *            ... date is valid ...
+ *        }
+ *    }
+ *
+ **************************************************************************/
+
+/* Gregorian calendar conversions. */
+void SdnToGregorian(long int sdn, int *pYear, int *pMonth, int *pDay);
+long int GregorianToSdn(int year, int month, int day);
+extern const char *MonthNameShort[13];
+extern const char *MonthNameLong[13];
+
+/* Julian calendar conversions. */
+void SdnToJulian(long int sdn, int *pYear, int *pMonth, int *pDay);
+long int JulianToSdn(int year, int month, int day);
+
+/* Jewish calendar conversions. */
+void SdnToJewish(long int sdn, int *pYear, int *pMonth, int *pDay);
+long int JewishToSdn(int year, int month, int day);
+extern const char *JewishMonthName[14];
+
+/* French republic calendar conversions. */
+void SdnToFrench(long int sdn, int *pYear, int *pMonth, int *pDay);
+long int FrenchToSdn(int inputYear, int inputMonth, int inputDay);
+extern const char *FrenchMonthName[14];
+
+/* Islamic calendar conversions. */
+/* Not implemented yet. */
+
+/* Day of week conversion.  0=Sunday, 6=Saturday */
+int DayOfWeek(long int sdn);
+extern const char *DayNameShort[7];
+extern const char *DayNameLong[7];
+
+#endif /* _INCLUDED_SDNCAL_H */

data/ext/sdn/sdnmodule.c

@@ -0,0 +1,212 @@
+/*
+  sdnmodule.c: Copyright (C) 1997,1999,2014 Tadayoshi Funaba All rights reserved
+  $Id: sdnmodule.c,v 1.7 2014-04-05 16:47:22+09 tadf Exp $
+*/
+
+#include "ruby.h"
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#endif
+#include "sdncal.h"
+
+#define CHECK_RANGE(v, m)			\
+{						\
+    if ((v) < (m))				\
+	rb_raise(rb_eArgError, "out of range");	\
+}
+
+#define CHECK_DOMAIN(v, m)			\
+{						\
+    if ((v) < (m))				\
+	rb_raise(rb_eArgError, "out of domain");\
+}
+
+#define CHECK_DOMAIN2(v, m, n)			\
+{						\
+    if ((v) < (m) || (v) > (n))			\
+	rb_raise(rb_eArgError, "out of domain");\
+}
+
+static VALUE
+sdn_SdnToGregorian(VALUE obj, VALUE sdn)
+{
+    int y, m, md;
+    long isdn;
+
+    isdn = NUM2LONG(sdn); CHECK_DOMAIN(isdn, 1);
+    SdnToGregorian(isdn, &y, &m, &md);
+    return rb_ary_new3(3, INT2NUM(y), INT2NUM(m), INT2NUM(md));
+}
+
+static VALUE
+sdn_GregorianToSdn(VALUE obj, VALUE y, VALUE m, VALUE md)
+{
+    int iy, im, imd, iy2, im2, imd2;
+    long sdn;
+
+    iy = NUM2INT(y); CHECK_DOMAIN(iy, -4714);
+    im = NUM2INT(m); CHECK_DOMAIN2(im, 1, 12);
+    imd = NUM2INT(md); CHECK_DOMAIN2(imd, 1, 31);
+    sdn = GregorianToSdn(iy, im, imd);
+    CHECK_RANGE(sdn, 1);
+    SdnToGregorian(sdn, &iy2, &im2, &imd2);
+    if (iy != iy2 || im != im2 || imd != imd2)
+	rb_raise(rb_eArgError, "invalid date");
+    return INT2NUM(sdn);
+}
+
+static VALUE
+sdn_SdnToJulian(VALUE obj, VALUE sdn)
+{
+    int y, m, md;
+    long isdn;
+
+    isdn = NUM2LONG(sdn); CHECK_DOMAIN(isdn, 1);
+    SdnToJulian(isdn, &y, &m, &md);
+    return rb_ary_new3(3, INT2NUM(y), INT2NUM(m), INT2NUM(md));
+}
+
+static VALUE
+sdn_JulianToSdn(VALUE obj, VALUE y, VALUE m, VALUE md)
+{
+    int iy, im, imd, iy2, im2, imd2;
+    long sdn;
+
+    iy = NUM2INT(y); CHECK_DOMAIN(iy, -4713);
+    im = NUM2INT(m); CHECK_DOMAIN2(im, 1, 12);
+    imd = NUM2INT(md); CHECK_DOMAIN2(imd, 1, 31);
+    sdn = JulianToSdn(iy, im, imd);
+    CHECK_RANGE(sdn, 1);
+    SdnToJulian(sdn, &iy2, &im2, &imd2);
+    if (iy != iy2 || im != im2 || imd != imd2)
+	rb_raise(rb_eArgError, "invalid date");
+    return INT2NUM(sdn);
+}
+
+static VALUE
+sdn_SdnToJewish(VALUE obj, VALUE sdn)
+{
+    int y, m, md;
+    long isdn;
+
+    isdn = NUM2LONG(sdn); CHECK_DOMAIN(isdn, 347998);
+    SdnToJewish(NUM2INT(sdn), &y, &m, &md);
+    return rb_ary_new3(3, INT2NUM(y), INT2NUM(m), INT2NUM(md));
+}
+
+static VALUE
+sdn_JewishToSdn(VALUE obj, VALUE y, VALUE m, VALUE md)
+{
+    int iy, im, imd, iy2, im2, imd2;
+    long sdn;
+
+    iy = NUM2INT(y); CHECK_DOMAIN(iy, 1);
+    im = NUM2INT(m); CHECK_DOMAIN2(im, 1, 13);
+    imd = NUM2INT(md); CHECK_DOMAIN2(imd, 1, 30);
+    sdn = JewishToSdn(iy, im, imd);
+    CHECK_RANGE(sdn, 1); /* 347998 */
+    SdnToJewish(sdn, &iy2, &im2, &imd2);
+    if (iy != iy2 || im != im2 || imd != imd2)
+	rb_raise(rb_eArgError, "invalid date");
+    return INT2NUM(sdn);
+}
+
+static VALUE
+sdn_SdnToFrench(VALUE obj, VALUE sdn)
+{
+    int y, m, md;
+    long isdn;
+
+    isdn = NUM2LONG(sdn); CHECK_DOMAIN2(isdn, 2375840, 2380952);
+    SdnToFrench(isdn, &y, &m, &md);
+    return rb_ary_new3(3, INT2NUM(y), INT2NUM(m), INT2NUM(md));
+}
+
+static VALUE
+sdn_FrenchToSdn(VALUE obj, VALUE y, VALUE m, VALUE md)
+{
+    int iy, im, imd, iy2, im2, imd2;
+    long sdn;
+
+    iy = NUM2INT(y); CHECK_DOMAIN(iy, 1);
+    im = NUM2INT(m); CHECK_DOMAIN2(im, 1, 13);
+    imd = NUM2INT(md); CHECK_DOMAIN2(imd, 1, 30);
+    sdn = FrenchToSdn(iy, im, imd);
+    CHECK_RANGE(sdn, 1);
+    SdnToFrench(sdn, &iy2, &im2, &imd2);
+    if (iy != iy2 || im != im2 || imd != imd2)
+	rb_raise(rb_eArgError, "invalid date");
+    return INT2NUM(sdn);
+}
+
+static VALUE
+sdn_DayOfWeek(VALUE obj, VALUE sdn)
+{
+    long isdn;
+    int wd;
+
+    isdn = NUM2LONG(sdn);
+    wd = DayOfWeek(isdn);
+    return INT2NUM(wd);
+}
+
+static VALUE
+mk_ary_of_str(long len, const char *a[])
+{
+    VALUE o;
+    long i;
+
+    o = rb_ary_new2(len);
+    for (i = 0; i < len; i++) {
+	VALUE e;
+
+	if (!a[i])
+	    e = Qnil;
+	else {
+	    e = rb_str_new2(a[i]);
+#ifdef HAVE_RUBY_ENCODING_H
+	    rb_enc_associate(e, rb_utf8_encoding());
+	    ENC_CODERANGE_CLEAR(e);
+#endif
+	    rb_obj_freeze(e);
+	}
+	rb_ary_push(o, e);
+    }
+    rb_obj_freeze(o);
+    return o;
+}
+
+void
+Init_sdn(void)
+{
+    VALUE mod;
+
+    mod = rb_define_module("Sdn");
+
+    rb_define_module_function(mod, "DayOfWeek", sdn_DayOfWeek, 1);
+    rb_define_module_function(mod, "SdnToGregorian", sdn_SdnToGregorian, 1);
+    rb_define_module_function(mod, "GregorianToSdn", sdn_GregorianToSdn, 3);
+    rb_define_module_function(mod, "SdnToJulian", sdn_SdnToJulian, 1);
+    rb_define_module_function(mod, "JulianToSdn", sdn_JulianToSdn, 3);
+    rb_define_module_function(mod, "SdnToJewish", sdn_SdnToJewish, 1);
+    rb_define_module_function(mod, "JewishToSdn", sdn_JewishToSdn, 3);
+    rb_define_module_function(mod, "SdnToFrench", sdn_SdnToFrench, 1);
+    rb_define_module_function(mod, "FrenchToSdn", sdn_FrenchToSdn, 3);
+
+    rb_define_const
+	(mod, "VERSION",
+	 rb_obj_freeze(rb_str_new2("$Revision: 1.7 $")));
+
+#define const_array(a) mk_ary_of_str(sizeof a / sizeof a[0], a)
+#define def_const(n, o) rb_define_const(mod, n, o)
+#define def_const_array(n, a) def_const(n, const_array(a))
+
+    def_const_array("DayNameShort", DayNameShort);
+    def_const_array("DayNameLong", DayNameLong);
+
+    def_const_array("MonthNameShort", MonthNameShort);
+    def_const_array("MonthNameLong", MonthNameLong);
+
+    def_const_array("JewishMonthName", JewishMonthName);
+    def_const_array("FrenchMonthName", FrenchMonthName);
+}