Initial revision

Demo/classes/Dates.py

@@ -0,0 +1,233 @@
+# Class Date supplies date objects that support date arithmetic.
+#
+# Date(month,day,year) returns a Date object.  An instance prints as,
+# e.g., 'Mon 16 Aug 1993'.
+#
+# Addition, subtraction, comparison operators, min, max, and sorting
+# all work as expected for date objects:  int+date or date+int returns
+# the date `int' days from `date'; date+date raises an exception;
+# date-int returns the date `int' days before `date'; date2-date1 returns
+# an integer, the number of days from date1 to date2; int-date raises an
+# exception; date1 < date2 is true iff date1 occurs before date2 (&
+# similarly for other comparisons); min(date1,date2) is the earlier of
+# the two dates and max(date1,date2) the later; and date objects can be
+# used as dictionary keys.
+#
+# Date objects support one visible method, date.weekday().  This returns
+# the day of the week the date falls on, as a string.
+#
+# Date objects also have 4 (conceptually) read-only data attributes:
+#   .month  in 1..12
+#   .day    in 1..31
+#   .year   int or long int
+#   .ord    the ordinal of the date relative to an arbitrary staring point
+#
+# The Dates module also supplies function today(), which returns the
+# current date as a date object.
+#
+# Those entranced by calendar trivia will be disappointed, as no attempt
+# has been made to accommodate the Julian (etc) system.  On the other
+# hand, at least this package knows that 2000 is a leap year but 2100
+# isn't, and works fine for years with a hundred decimal digits <wink>.
+
+# Tim Peters   tim@ksr.com
+# not speaking for Kendall Square Research Corp
+
+_MONTH_NAMES = [ 'January', 'February', 'March', 'April', 'May',
+		 'June', 'July', 'August', 'September', 'October',
+		 'November', 'December' ]
+
+_DAY_NAMES = [ 'Friday', 'Saturday', 'Sunday', 'Monday',
+	       'Tuesday', 'Wednesday', 'Thursday' ]
+
+_DAYS_IN_MONTH = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
+
+_DAYS_BEFORE_MONTH = []
+dbm = 0
+for dim in _DAYS_IN_MONTH:
+    _DAYS_BEFORE_MONTH.append(dbm)
+    dbm = dbm + dim
+del dbm, dim
+
+_INT_TYPES = type(1), type(1L)
+
+def _is_leap( year ):		# 1 if leap year, else 0
+    if year % 4 != 0: return 0
+    if year % 400 == 0: return 1
+    return year % 100 != 0
+
+def _days_in_year( year ):	# number of days in year
+    return 365 + _is_leap(year)
+
+def _days_before_year( year ):	# number of days before year
+    return year*365L + (year+3)/4 - (year+99)/100 + (year+399)/400
+
+def _days_in_month( month, year ):	# number of days in month of year
+    if month == 2 and _is_leap(year): return 29
+    return _DAYS_IN_MONTH[month-1]
+
+def _days_before_month( month, year ):	# number of days in year before month
+    return _DAYS_BEFORE_MONTH[month-1] + (month > 2 and _is_leap(year))
+
+def _date2num( date ):		# compute ordinal of date.month,day,year
+    return _days_before_year( date.year ) + \
+	   _days_before_month( date.month, date.year ) + \
+	   date.day
+
+_DI400Y = _days_before_year( 400 )	# number of days in 400 years
+
+def _num2date( n ):		# return date with ordinal n
+    if type(n) not in _INT_TYPES:
+	raise TypeError, 'argument must be integer: ' + `type(n)`
+
+    ans = Date(1,1,1)	# arguments irrelevant; just getting a Date obj
+    ans.ord = n
+
+    n400 = (n-1)/_DI400Y		# # of 400-year blocks preceding
+    year, n = 400 * n400, n - _DI400Y * n400
+    more = n / 365
+    dby = _days_before_year( more )
+    if dby >= n:
+	more = more - 1
+	dby = dby - _days_in_year( more )
+    year, n = year + more, int(n - dby)
+
+    try: year = int(year)		# chop to int, if it fits
+    except ValueError: pass
+
+    month = min( n/29 + 1, 12 )
+    dbm = _days_before_month( month, year )
+    if dbm >= n:
+	month = month - 1
+	dbm = dbm - _days_in_month( month, year )
+
+    ans.month, ans.day, ans.year = month, n-dbm, year
+    return ans
+
+def _num2day( n ):	# return weekday name of day with ordinal n
+    return _DAY_NAMES[ int(n % 7) ]
+
+
+class Date:
+    def __init__( self, month, day, year ):
+	if not 1 <= month <= 12:
+	    raise ValueError, 'month must be in 1..12: ' + `month`
+	dim = _days_in_month( month, year )
+	if not 1 <= day <= dim:
+	    raise ValueError, 'day must be in 1..' + `dim` + ': ' + `day`
+	self.month, self.day, self.year = month, day, year
+	self.ord = _date2num( self )
+
+    def __cmp__( self, other ):
+	return cmp( self.ord, other.ord )
+
+    # define a hash function so dates can be used as dictionary keys
+    def __hash__( self ):
+	return hash( self.ord )
+
+    # print as, e.g., Mon 16 Aug 1993
+    def __repr__( self ):
+	return '%.3s %2d %.3s ' % (
+	      self.weekday(),
+	      self.day,
+	      _MONTH_NAMES[self.month-1] ) + `self.year`
+
+    # automatic coercion is a pain for date arithmetic, since e.g.
+    # date-date and date-int mean different things.  So, in order to
+    # sneak integers past Python's coercion rules without losing the info
+    # that they're really integers (& not dates!), integers are disguised
+    # as instances of the derived class _DisguisedInt.  That this works
+    # relies on undocumented behavior of Python's coercion rules.
+    def __coerce__( self, other ):
+	if type(other) in _INT_TYPES:
+	    return self, _DisguisedInt(other)
+	# if another Date, fine
+	if type(other) is type(self) and other.__class__ is Date:
+	    return self, other
+
+    # Python coerces int+date, but not date+int; in the former case,
+    # _DisguisedInt.__add__ handles it, so we only need to do
+    # date+int here
+    def __add__( self, n ):
+	if type(n) not in _INT_TYPES:
+	    raise TypeError, 'can\'t add ' + `type(n)` + ' to date'
+	return _num2date( self.ord + n )
+
+    # Python coerces all of int-date, date-int and date-date; the first
+    # case winds up in _DisguisedInt.__sub__, leaving the latter two
+    # for us
+    def __sub__( self, other ):
+	if other.__class__ is _DisguisedInt:	# date-int
+	    return _num2date( self.ord - other.ord )
+	else:
+	    return self.ord - other.ord		# date-date
+
+    def weekday( self ):
+	return _num2day( self.ord )
+
+# see comments before Date.__add__
+class _DisguisedInt( Date ):
+    def __init__( self, n ):
+	self.ord = n
+
+    # handle int+date
+    def __add__( self, other ):
+	return other.__add__( self.ord )
+
+    # complain about int-date
+    def __sub__( self, other ):
+	raise TypeError, 'Can\'t subtract date from integer'
+
+def today():
+    import time
+    local = time.localtime(time.time())
+    return Date( local[1], local[2], local[0] )
+
+DateTestError = 'DateTestError'
+def test( firstyear, lastyear ):
+    a = Date(9,30,1913)
+    b = Date(9,30,1914)
+    if `a` != 'Tue 30 Sep 1913':
+	raise DateTestError, '__repr__ failure'
+    if (not a < b) or a == b or a > b or b != b or \
+	  a != 698982 or 698982 != a or \
+	  (not a > 5) or (not 5 < a):
+	raise DateTestError, '__cmp__ failure'
+    if a+365 != b or 365+a != b:
+	raise DateTestError, '__add__ failure'
+    if b-a != 365 or b-365 != a:
+	raise DateTestError, '__sub__ failure'
+    try:
+	x = 1 - a
+	raise DateTestError, 'int-date should have failed'
+    except TypeError:
+	pass
+    try:
+	x = a + b
+	raise DateTestError, 'date+date should have failed'
+    except TypeError:
+	pass
+    if a.weekday() != 'Tuesday':
+	raise DateTestError, 'weekday() failure'
+    if max(a,b) is not b or min(a,b) is not a:
+	raise DateTestError, 'min/max failure'
+    d = {a-1:b, b:a+1}
+    if d[b-366] != b or d[a+(b-a)] != Date(10,1,1913):
+	raise DateTestError, 'dictionary failure'
+
+    # verify date<->number conversions for first and last days for
+    # all years in firstyear .. lastyear
+
+    lord = _days_before_year( firstyear )
+    y = firstyear
+    while y <= lastyear:
+	ford = lord + 1
+	lord = ford + _days_in_year(y) - 1
+	fd, ld = Date(1,1,y), Date(12,31,y)
+	if (fd.ord,ld.ord) != (ford,lord):
+	    raise DateTestError, ('date->num failed', y)
+	fd, ld = _num2date(ford), _num2date(lord)
+	if (1,1,y,12,31,y) != \
+	   (fd.month,fd.day,fd.year,ld.month,ld.day,ld.year):
+	    raise DateTestError, ('num->date failed', y)
+	y = y + 1

Demo/classes/Rev.py

@@ -0,0 +1,89 @@
+# A class which presents the reverse of a sequence without duplicating it.
+# From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu>
+
+# It works on mutable or inmutable sequences.
+#
+# >>> for c in Rev( 'Hello World!' ) : sys.stdout.write( c )
+# ... else: sys.stdout.write( '\n' )
+# ... 
+# !dlroW olleH
+#
+# The .forw is so you can use anonymous sequences in init, and still
+# keep a reference the forward sequence. ) 
+# If you give it a non-anonymous mutable sequence, the reverse sequence
+# will track the updated values. ( but not reassignment! - another 
+# good reason to use anonymous values in creating the sequence to avoid
+# confusion. Maybe it should be change to copy input sequence to break
+# the connection completely ? )
+#
+# >>> nnn = range( 0, 3 )
+# >>> rnn = Rev( nnn )
+# >>> for n in rnn: print n
+# ... 
+# 2
+# 1
+# 0
+# >>> for n in range( 4, 6 ): nnn.append( n )	# update nnn
+# ... 
+# >>> for n in rnn: print n	# prints reversed updated values
+# ... 
+# 5
+# 4
+# 2
+# 1
+# 0
+# >>> nnn = nnn[1:-1]
+# >>> nnn
+# [1, 2, 4]
+# >>> for n in rnn: print n	# prints reversed values of old nnn
+# ... 
+# 5
+# 4
+# 2
+# 1
+# 0
+# >>> 
+#
+# WH = Rev( 'Hello World!' )
+# print WH.forw, WH.back
+# nnn = Rev( range( 1, 10 ) )
+# print nnn.forw
+# print nnn
+# 
+# produces output:
+# 
+# Hello World! !dlroW olleH
+# [1, 2, 3, 4, 5, 6, 7, 8, 9]
+# [9, 8, 7, 6, 5, 4, 3, 2, 1]
+# 
+# >>>rrr = Rev( nnn ) 
+# >>>rrr
+# <1, 2, 3, 4, 5, 6, 7, 8, 9>	
+
+from string import joinfields
+class Rev:
+	def __init__( self, seq ):
+		self.forw = seq
+		self.back = self
+	def __len__( self ):
+		return len( self.forw )
+	def __getitem__( self, j ):
+		return self.forw[ -( j + 1 ) ]
+	def __repr__( self ):
+		seq = self.forw
+		if type(seq) == type( [] ) : 
+			wrap = '[]'
+			sep = ', '
+		elif type(seq) == type( () ) : 
+			wrap = '()'
+			sep = ', '
+		elif type(seq) == type( '' ) : 
+			wrap = ''
+			sep = ''
+		else: 
+			wrap = '<>'
+			sep = ', ' 
+		outstrs = []
+		for item in self.back :
+			outstrs.append( str( item ) )
+		return wrap[:1] + joinfields( outstrs, sep ) + wrap[-1:]