Initial revision
diff --git a/Demo/classes/Dates.py b/Demo/classes/Dates.py
new file mode 100755
index 0000000..4e8bbf7
--- /dev/null
+++ b/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
diff --git a/Demo/classes/Rev.py b/Demo/classes/Rev.py
new file mode 100755
index 0000000..5cf4602
--- /dev/null
+++ b/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:]