| Current File : /home/mmdealscpanel/yummmdeals.com/classes.tar |
Rev.pyc 0000644 00000005461 15040042263 0006017 0 ustar 00 �
��^c @ s< d Z d d d � � YZ d � Z e d k r8 e � n d S( s�
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.
>>> chars = list(Rev('Hello World!'))
>>> print ''.join(chars)
!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(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
Hello World! !dlroW olleH
>>> nnn = Rev(range(1, 10))
>>> print nnn.forw
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print nnn.back
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> rrr = Rev(nnn)
>>> rrr
<1, 2, 3, 4, 5, 6, 7, 8, 9>
t Revc B s, e Z d � Z d � Z d � Z d � Z RS( c C s | | _ | | _ d S( N( t forwt back( t selft seq( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __init__? s c C s
t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __len__C s c C s | j | d S( Ni ( R ( R t j( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __getitem__F s c C s� | j } t | t � r' d } d } nH t | t � rE d } d } n* t | t � rc d } d } n d } d } g | j D] } t | � ^ qy } | d | j | � | d S( Ns []s , s ()t s <>i i����( R t
isinstancet listt tuplet strR t join( R R t wrapt sept itemt outstrs( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __repr__I s "( t __name__t
__module__R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyR > s c C s% d d l } d d l } | j | � S( Ni����( t doctestR t testmod( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt _testZ s t __main__N( ( t __doc__R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt <module>< s Vec.pyc 0000644 00000005404 15040042263 0005775 0 ustar 00 �
��^c @ s' d d d � � YZ d � Z e � d S( t Vecc B sb e Z d Z d � Z e d � � Z d � Z d � Z d � Z d � Z d � Z
d � Z e Z RS( sx A simple vector class
Instances of the Vec class can be constructed from numbers
>>> a = Vec(1, 2, 3)
>>> b = Vec(3, 2, 1)
added
>>> a + b
Vec(4, 4, 4)
subtracted
>>> a - b
Vec(-2, 0, 2)
and multiplied by a scalar on the left
>>> 3.0 * a
Vec(3.0, 6.0, 9.0)
or on the right
>>> a * 3.0
Vec(3.0, 6.0, 9.0)
c G s t | � | _ d S( N( t listt v( t selfR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __init__ s c C s. t | t � s t � n | � } | | _ | S( N( t
isinstanceR t TypeErrorR ( t clsR t inst( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt fromlist s
c C s) d j d � | j D� � } d j | � S( Ns , c s s | ] } t | � Vq d S( N( t repr( t .0t x( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pys <genexpr>% s s Vec({0})( t joinR t format( R t args( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __repr__$ s c C s
t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __len__( s c C s | j | S( N( R ( R t i( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __getitem__+ s c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( t zipR R R ( R t otherR t yR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __add__. s 2c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( R R R R ( R R R R R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __sub__3 s 2c C s- g | j D] } | | ^ q
} t j | � S( N( R R R ( R t scalarR R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __mul__8 s (
t __name__t
__module__t __doc__R t classmethodR R R R R R R t __rmul__( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyR s c C s d d l } | j � d S( Ni����( t doctestt testmod( R! ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt test@ s N( ( R R# ( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt <module> s ? Range.pyo 0000644 00000007773 15040042263 0006343 0 ustar 00 �
��^c @ sN d Z d � Z d � Z d d d � � YZ d � Z e d k rJ e � n d S( s Example of a generator: re-implement the built-in range function
without actually constructing the list of values.
OldStyleRange is coded in the way required to work in a 'for' loop before
iterators were introduced into the language; using __getitem__ and __len__ .
c C s� y� t | � d k r, d t | d � d f St | � d k r_ t | d � t | d � d f St | � d k r� | d d k r� t d � � n t d � | D� � St d t | � � � Wn t k
r� t d � � n Xd S(
sg Take list of arguments and extract/create proper start, stop, and step
values and return in a tuplei i i i s step argument must not be zeroc s s | ] } t | � Vq d S( N( t int( t .0t x( ( s* /usr/lib64/python2.7/Demo/classes/Range.pys <genexpr> s s$ range() accepts 1-3 arguments, givensA range() arguments must be numbers or strings representing numbersN( t lenR t
ValueErrort tuplet TypeError( t arglist( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt
handleargs s !
c g sA t | � \ } } } | } x | | k r< | V| | 7} q Wd S( s, Function to implement 'range' as a generatorN( R ( t at startt stopt stept value( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt genrange s
t oldrangec B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s Class implementing a range object.
To the user the instances feel like immutable sequences
(and you can't concatenate or slice them)
Done using the old way (pre-iterators; __len__ and __getitem__) to have an
object be used by a 'for' loop.
c G sE t | � \ | _ | _ | _ t d | j | j | j � | _ d S( s� Initialize start, stop, and step values along with calculating the
nubmer of values (what __len__ will return) in the rangei N( R R
R R t maxR ( t selfR ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __init__, s c C s d | j | j | j f S( s- implement repr(x) which is also used by prints range(%r, %r, %r)( R
R R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __repr__2 s c C s | j S( s implement len(x)( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __len__6 s c C s> d | k o | j k n r1 | j | j | St d � d S( s implement x[i]i s range[i] index out of rangeN( R R
R t
IndexError( R t i( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __getitem__: s ( t __name__t
__module__t __doc__R R R R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyR " s
c
C s9 d d l } d d l } | j d d d � } t t d d d � � } t t d d d � � } | | k su | | k r� t d | | | f � � n d GH| j � } x t d � D] } q� W| j � } x t d � D] } q� W| j � } x | j d � D] } q� W| j � } | | Gd GH| | Gd GH| | Gd
GHd S( Ni����i id i sE error in implementation:
correct = %s
old-style = %s
generator = %ss Timings for range(1000):i� s sec (old-style class)s sec (generator)s sec (built-in)( t timet __builtin__t ranget listR R t Exception(
R R t correct_resultt oldrange_resultt genrange_resultt t1R t t2t t3t t4( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt testB s*
t __main__N( ( R R R R R' R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt <module> s Dbm.py 0000644 00000003046 15040042263 0005617 0 ustar 00 # A wrapper around the (optional) built-in class dbm, supporting keys
# and values of almost any type instead of just string.
# (Actually, this works only for keys and values that can be read back
# correctly after being converted to a string.)
class Dbm:
def __init__(self, filename, mode, perm):
import dbm
self.db = dbm.open(filename, mode, perm)
def __repr__(self):
s = ''
for key in self.keys():
t = repr(key) + ': ' + repr(self[key])
if s: t = ', ' + t
s = s + t
return '{' + s + '}'
def __len__(self):
return len(self.db)
def __getitem__(self, key):
return eval(self.db[repr(key)])
def __setitem__(self, key, value):
self.db[repr(key)] = repr(value)
def __delitem__(self, key):
del self.db[repr(key)]
def keys(self):
res = []
for key in self.db.keys():
res.append(eval(key))
return res
def has_key(self, key):
return self.db.has_key(repr(key))
def test():
d = Dbm('@dbm', 'rw', 0600)
print d
while 1:
try:
key = input('key: ')
if d.has_key(key):
value = d[key]
print 'currently:', value
value = input('value: ')
if value is None:
del d[key]
else:
d[key] = value
except KeyboardInterrupt:
print ''
print d
except EOFError:
print '[eof]'
break
print d
test()
Dbm.pyc 0000644 00000004730 15040042263 0005763 0 ustar 00 �
��^c @ s' d d d � � YZ d � Z e � d S( t Dbmc B sP e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s( d d l } | j | | | � | _ d S( Ni����( t dbmt opent db( t selft filenamet modet permR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __init__ s c C sd d } xO | j � D]A } t | � d t | | � } | rJ d | } n | | } q Wd | d S( Nt s : s , t {t }( t keyst repr( R t st keyt t( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __repr__
s
c C s
t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __len__ s c C s t | j t | � � S( N( t evalR R
( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __getitem__ s c C s t | � | j t | � <d S( N( R
R ( R R t value( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __setitem__ s c C s | j t | � =d S( N( R R
( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __delitem__ s c C s7 g } x* | j j � D] } | j t | � � q W| S( N( R R t appendR ( R t resR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ! s c C s | j j t | � � S( N( R t has_keyR
( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ' s (
t __name__t
__module__R R R R R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR s c C s� t d d d � } | GHx� ya t d � } | j | � rN | | } d G| GHn t d � } | d k rp | | =n
| | | <Wq t k
r� d GH| GHq t k
r� d GHPq Xq W| GHd S( Ns @dbmt rwi� s key: s
currently:s value: R s [eof]( R t inputR t Nonet KeyboardInterruptt EOFError( t dR R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt test+ s&
N( ( R R$ ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt <module> s $ Range.py 0000644 00000006066 15040042263 0006156 0 ustar 00 """Example of a generator: re-implement the built-in range function
without actually constructing the list of values.
OldStyleRange is coded in the way required to work in a 'for' loop before
iterators were introduced into the language; using __getitem__ and __len__ .
"""
def handleargs(arglist):
"""Take list of arguments and extract/create proper start, stop, and step
values and return in a tuple"""
try:
if len(arglist) == 1:
return 0, int(arglist[0]), 1
elif len(arglist) == 2:
return int(arglist[0]), int(arglist[1]), 1
elif len(arglist) == 3:
if arglist[2] == 0:
raise ValueError("step argument must not be zero")
return tuple(int(x) for x in arglist)
else:
raise TypeError("range() accepts 1-3 arguments, given", len(arglist))
except TypeError:
raise TypeError("range() arguments must be numbers or strings "
"representing numbers")
def genrange(*a):
"""Function to implement 'range' as a generator"""
start, stop, step = handleargs(a)
value = start
while value < stop:
yield value
value += step
class oldrange:
"""Class implementing a range object.
To the user the instances feel like immutable sequences
(and you can't concatenate or slice them)
Done using the old way (pre-iterators; __len__ and __getitem__) to have an
object be used by a 'for' loop.
"""
def __init__(self, *a):
""" Initialize start, stop, and step values along with calculating the
nubmer of values (what __len__ will return) in the range"""
self.start, self.stop, self.step = handleargs(a)
self.len = max(0, (self.stop - self.start) // self.step)
def __repr__(self):
"""implement repr(x) which is also used by print"""
return 'range(%r, %r, %r)' % (self.start, self.stop, self.step)
def __len__(self):
"""implement len(x)"""
return self.len
def __getitem__(self, i):
"""implement x[i]"""
if 0 <= i <= self.len:
return self.start + self.step * i
else:
raise IndexError, 'range[i] index out of range'
def test():
import time, __builtin__
#Just a quick sanity check
correct_result = __builtin__.range(5, 100, 3)
oldrange_result = list(oldrange(5, 100, 3))
genrange_result = list(genrange(5, 100, 3))
if genrange_result != correct_result or oldrange_result != correct_result:
raise Exception("error in implementation:\ncorrect = %s"
"\nold-style = %s\ngenerator = %s" %
(correct_result, oldrange_result, genrange_result))
print "Timings for range(1000):"
t1 = time.time()
for i in oldrange(1000):
pass
t2 = time.time()
for i in genrange(1000):
pass
t3 = time.time()
for i in __builtin__.range(1000):
pass
t4 = time.time()
print t2-t1, 'sec (old-style class)'
print t3-t2, 'sec (generator)'
print t4-t3, 'sec (built-in)'
if __name__ == '__main__':
test()
Dates.pyo 0000644 00000016246 15040042263 0006342 0 ustar 00 �
��^c @ sp d d d d d d d d d d d
d g Z d d
d d d d d g Z d d d d d d d d d d d d g Z g Z d Z x% e D] Z e j e � e e Z q� W[ [ e d � e d � f Z d � Z d � Z
d � Z d � Z d � Z
d � Z e d � Z d � Z d! � Z d" d, d# � � YZ d$ � Z d% e f d& � � YZ d' � Z e d( k rle d) d* � n d+ S(- t Januaryt Februaryt Marcht Aprilt Mayt Junet Julyt Augustt Septembert Octobert Novembert Decembert Fridayt Saturdayt Sundayt Mondayt Tuesdayt Wednesdayt Thursdayi i i i i l c C s6 | d d k r d S| d d k r( d S| d d k S( Ni i i� i id ( ( t year( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _is_leap> s
c C s d t | � S( Nim ( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt
_days_in_yearC s c C s, | d | d d | d d | d d S( Nl mi i ic id i� i� ( ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_yearF s c C s( | d k r t | � r d St | d S( Ni i i ( R t _DAYS_IN_MONTH( t monthR ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_in_monthI s c C s" t | d | d k o t | � S( Ni i ( t _DAYS_BEFORE_MONTHR ( R R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_monthM s c C s' t | j � t | j | j � | j S( N( R R R R t day( t date( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _date2numP s i� c C s} t | � t k r( t d t | � � n t d d d � } | ` | ` | ` | ` | | _ | d t } d | | t | } } | d } t | � } | | k r� | d } | t
| � } n | | t | | � } } y t | � } Wn t t
f k
rn Xt | d d d � } t | | � } | | k rX| d } | t | | � } n | | | | | _ | _ | _ | S( Ns argument must be integer: %ri i� im i i ( t typet
_INT_TYPESt TypeErrort Datet ordR R R t _DI400YR R t intt
ValueErrort
OverflowErrort minR R ( t nt anst n400R t moret dbyR t dbm( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dateW s0
!c C s t t | d � S( Ni ( t
_DAY_NAMESR% ( R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dayt s R" c B s_ e Z d � Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z
d � Z RS( c C s� d | k o d k n s/ t d | f � n t | | � } d | k oU | k n sp t d | | f � n | | | | _ | _ | _ t | � | _ d S( Ni i s month must be in 1..12: %rs day must be in 1..%r: %r( R& R R R R R R# ( t selfR R R t dim( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __init__y s c C s3 | j j | � r" t d | � n | | j | <d S( Ns read-only attribute ( t __dict__t has_keyt AttributeError( R2 t namet value( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __setattr__� s c C s t | j | j � S( N( t cmpR# ( R2 t other( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __cmp__� s c C s
t | j � S( N( t hashR# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __hash__� s c C s+ d | j � | j t | j d | j f S( Ns %.3s %2d %.3s %ri ( t weekdayR t _MONTH_NAMESR R ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __repr__� s
c C s9 t | � t k r( t d t | � � n t | j | � S( Ns can't add %r to date( R R R! R/ R# ( R2 R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __add__� s c C s5 t | � t k r# t | j | � S| j | j Sd S( N( R R R/ R# ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __sub__� s c C s
t d � d S( Ns Can't subtract date from integer( R! ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __rsub__� s c C s
t | j � S( N( R1 R# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR@ � s ( t __name__t
__module__R4 R: R= R? RB RC t __radd__RD RE R@ ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR" x s
c C s= d d l } | j | j � � } t | d | d | d � S( Ni����i i i ( t timet localtimeR" ( RI t local( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt today� s t
DateTestErrorc B s e Z RS( ( RF RG ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyRM � s c C s� t d d d � } t d d d � } t | � d k rB t d � n | | k ss | | k ss | | k ss | | k r t d � n | d | k s� d | | k r� t d � n | | d k s� | d | k r� t d
� n y d | } t d � Wn t k
rn Xy | | } t d
� Wn t k
r,n X| j � d k rKt d � n t | | � | k sut | | � | k r�t d � n i | | d 6| d | 6} | | d | k s�| | | | t d d d � k r�t d � n t | � } | } x� | | k r�| d } | t | � d } t d d | � t d d | � } }
| j |
j f | | f k rut d | f � n t
| � t
| � } }
d d | d d | f | j | j | j
|
j |
j |
j
f k r�t d | f � n | d } q�Wd S( Ni i iy iz s Tue 30 Sep 1913s __repr__ failures __cmp__ failureim s __add__ failures __sub__ failurei s int-date should have faileds date+date should have failedR s weekday() failures min/max failurein i
s dictionary failurei i s date->num faileds num->date failed( R" t reprRM R! R@ t maxR( R R R# R/ R R R ( t firstyeart lastyeart at bt xt dt lordt yt fordt fdt ld( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt test� sP 1
* 8
% -t __main__i: if N( ( RA R0 R R R. R3 t appendR R R R R R R R R$ R/ R1 R" RL t ExceptionRM R[ RF ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt <module>, s6 *
4 . Complex.pyc 0000644 00000023446 15040042263 0006675 0 ustar 00 �
��^c @ s� d d l Z d d l Z e j d Z e j d Z d � Z d � Z d d e d � Z d � Z d � Z d d d
� � YZ
d � Z d d
� Z d � Z
e d k r� e
� n d S( i����Ng @c C s t | d � o t | d � S( Nt ret im( t hasattr( t obj( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt IsComplexG s c C s7 t | � r | St | t � r) t | � St | � Sd S( N( R t
isinstancet tuplet Complex( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ToComplexJ s
i c C s5 | t | } t t j | � | t j | � | � S( N( t twopiR t matht cost sin( t rt phit
fullcircle( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt PolarToComplexR s c C s t | � r | j S| S( N( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ReV s c C s t | � r | j Sd S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt Im[ s R c B s� e Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d
� Z d � Z d � Z
d
� Z d � Z e Z Z e d � Z e Z d � Z e Z d � Z d � Z d � Z e Z d � Z d � Z d d � Z d � Z RS( i c C s� d } d } t | � r- | j } | j } n | } t | � r\ | | j } | | j } n
| | } | | j d <| | j d <d S( Ni R R ( R R R t __dict__( t selfR R t _ret _im( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __init__b s
c C s
t d � d S( Ns Complex numbers are immutable( t TypeError( R t namet value( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __setattr__t s c C s, | j s t | j � St | j | j f � S( N( R t hashR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __hash__w s
c C s/ | j s d | j f Sd | j | j f Sd S( Ns Complex(%r)s Complex(%r, %r)( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __repr__| s c C s. | j s t | j � Sd | j | j f Sd S( Ns Complex(%r, %r)( R t reprR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __str__� s
c C s t | j | j � S( N( R R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __neg__� s c C s | S( N( ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pos__� s c C s t j | j | j � S( N( R
t hypotR R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __abs__� s c C s" | j r t d � n t | j � S( Ns, can't convert Complex with nonzero im to int( R t
ValueErrort intR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __int__� s c C s" | j r t d � n t | j � S( Ns- can't convert Complex with nonzero im to long( R R% t longR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __long__� s c C s" | j r t d � n t | j � S( Ns. can't convert Complex with nonzero im to float( R R% t floatR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __float__� s c C s1 t | � } t | j | j f | j | j f � S( N( R t cmpR R ( R t other( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __cmp__� s c C s t | � } t | | � S( N( R R, ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rcmp__� s c C s! | j | j k o d k n S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __nonzero__� s c C s& | t t t j | j | j � t S( N( R t halfpiR
t atan2R R ( R R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt angle� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __add__� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __sub__� s c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rsub__� s c C sI t | � } t | j | j | j | j | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __mul__� s c C s� t | � } t | j | j | j | j � } | sB t d � n t | j | j | j | j | | j | j | j | j | � S( Ns Complex division( R R* R R t ZeroDivisionErrorR ( R R- t d( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __div__� s $ "c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rdiv__� s c C s� | d k r t d � n t | � rk | j r_ | j rB t d � q_ t t j | j � | � Sn | j } n t | j � | � } | | j
� } t t j | � | t j
| � | � S( Ns& Complex does not support ternary pow()s Complex to the Complex power( t NoneR R R t expR
t logR t powt absR3 R R R ( R t nt zR
R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pow__� s c C s t | � } t | | � S( N( R R? ( R t base( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rpow__� s N( t __name__t
__module__R R R R R R! R" R$ R' R) R+ R. R/ R0 R@ t radiusR R3 R R4 t __radd__R5 R6 R7 t __rmul__R: R; R< RC RE ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR ` s6
c C s? t j | j � } t t j | j � | t j | j � | � S( N( R
R= R R R R R ( RB R
( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR= � s g���ư>c C s� d G| Gd G| Gy t | � } Wn t j } n Xd G| GHt | t � sZ t | t � ri | | k } n t | | � | k } | s� d G| Gd Gt | | � GHn d S( Ns t ands ->s !! !! !! should bet diff( t evalt syst exc_typeR t strR@ ( t exprt at bR t fuzzt resultt ok( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt checkop� s
c C s d GHd t � f d t � f d! t d � f d" t d d � f d# t t d d � � f d$ t t d d � d � f d% t d t d d � � f d& t d t d � � f d' t d t d d � � f d( t t d d � t d d
� � f f
} d d g } x� | D]x } | d c d 7<| d d | d j k sH| d d | d j k r� d G| d Gd G| d GH| d c d 7<q� q� Wd
G| d Gd G| d Gd GHi d) d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d* d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d+ d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d, d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d- d t d d � d f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � d f d t d d � d f g d 6d. d t d d � d f t d d � d d f t d d � t d � d f t d � t d d � d f g d 6} xI t | � D]; } | d GH| f } x | | D] } t | | � q�Wq�Wd S(/ Ns test constructorsi i i i i i����i����i i s expectedt gots t ofs tests failedi
i s a+bi����i����s a-bs a*bg �?g�������?g��������s a/bi s pow(a,b)s cmp(a,b)t :( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i����i ( i����i ( i i
i ( i i
i����( i i
i
( g �?i
g�������?( i i
i ( i i
i����( R R R t sortedRW ( t constructor_testt cntt tt testsuiteRQ t item( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt test� sn *
6 $+ $+ $+ $+ $ % t __main__( ( R
RN t piR R1 R R R R R R R= RW Ra RF ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt <module>A s
� J README 0000644 00000001012 15040042263 0005412 0 ustar 00 Examples of classes that implement special operators (see reference manual):
Complex.py Complex numbers
Dates.py Date manipulation package by Tim Peters
Dbm.py Wrapper around built-in dbm, supporting arbitrary values
Range.py Example of a generator: re-implement built-in range()
Rev.py Yield the reverse of a sequence
Vec.py A simple vector class
bitvec.py A bit-vector class by Jan-Hein B\"uhrman
(For straightforward examples of basic class features, such as use of
methods and inheritance, see the library code.)
Range.pyc 0000644 00000007773 15040042263 0006327 0 ustar 00 �
��^c @ sN d Z d � Z d � Z d d d � � YZ d � Z e d k rJ e � n d S( s Example of a generator: re-implement the built-in range function
without actually constructing the list of values.
OldStyleRange is coded in the way required to work in a 'for' loop before
iterators were introduced into the language; using __getitem__ and __len__ .
c C s� y� t | � d k r, d t | d � d f St | � d k r_ t | d � t | d � d f St | � d k r� | d d k r� t d � � n t d � | D� � St d t | � � � Wn t k
r� t d � � n Xd S(
sg Take list of arguments and extract/create proper start, stop, and step
values and return in a tuplei i i i s step argument must not be zeroc s s | ] } t | � Vq d S( N( t int( t .0t x( ( s* /usr/lib64/python2.7/Demo/classes/Range.pys <genexpr> s s$ range() accepts 1-3 arguments, givensA range() arguments must be numbers or strings representing numbersN( t lenR t
ValueErrort tuplet TypeError( t arglist( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt
handleargs s !
c g sA t | � \ } } } | } x | | k r< | V| | 7} q Wd S( s, Function to implement 'range' as a generatorN( R ( t at startt stopt stept value( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt genrange s
t oldrangec B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s Class implementing a range object.
To the user the instances feel like immutable sequences
(and you can't concatenate or slice them)
Done using the old way (pre-iterators; __len__ and __getitem__) to have an
object be used by a 'for' loop.
c G sE t | � \ | _ | _ | _ t d | j | j | j � | _ d S( s� Initialize start, stop, and step values along with calculating the
nubmer of values (what __len__ will return) in the rangei N( R R
R R t maxR ( t selfR ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __init__, s c C s d | j | j | j f S( s- implement repr(x) which is also used by prints range(%r, %r, %r)( R
R R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __repr__2 s c C s | j S( s implement len(x)( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __len__6 s c C s> d | k o | j k n r1 | j | j | St d � d S( s implement x[i]i s range[i] index out of rangeN( R R
R t
IndexError( R t i( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __getitem__: s ( t __name__t
__module__t __doc__R R R R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyR " s
c
C s9 d d l } d d l } | j d d d � } t t d d d � � } t t d d d � � } | | k su | | k r� t d | | | f � � n d GH| j � } x t d � D] } q� W| j � } x t d � D] } q� W| j � } x | j d � D] } q� W| j � } | | Gd GH| | Gd GH| | Gd
GHd S( Ni����i id i sE error in implementation:
correct = %s
old-style = %s
generator = %ss Timings for range(1000):i� s sec (old-style class)s sec (generator)s sec (built-in)( t timet __builtin__t ranget listR R t Exception(
R R t correct_resultt oldrange_resultt genrange_resultt t1R t t2t t3t t4( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt testB s*
t __main__N( ( R R R R R' R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt <module> s Dbm.pyo 0000644 00000004730 15040042263 0005777 0 ustar 00 �
��^c @ s' d d d � � YZ d � Z e � d S( t Dbmc B sP e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s( d d l } | j | | | � | _ d S( Ni����( t dbmt opent db( t selft filenamet modet permR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __init__ s c C sd d } xO | j � D]A } t | � d t | | � } | rJ d | } n | | } q Wd | d S( Nt s : s , t {t }( t keyst repr( R t st keyt t( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __repr__
s
c C s
t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __len__ s c C s t | j t | � � S( N( t evalR R
( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __getitem__ s c C s t | � | j t | � <d S( N( R
R ( R R t value( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __setitem__ s c C s | j t | � =d S( N( R R
( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __delitem__ s c C s7 g } x* | j j � D] } | j t | � � q W| S( N( R R t appendR ( R t resR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ! s c C s | j j t | � � S( N( R t has_keyR
( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ' s (
t __name__t
__module__R R R R R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR s c C s� t d d d � } | GHx� ya t d � } | j | � rN | | } d G| GHn t d � } | d k rp | | =n
| | | <Wq t k
r� d GH| GHq t k
r� d GHPq Xq W| GHd S( Ns @dbmt rwi� s key: s
currently:s value: R s [eof]( R t inputR t Nonet KeyboardInterruptt EOFError( t dR R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt test+ s&
N( ( R R$ ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt <module> s $ Complex.py 0000644 00000023342 15040042263 0006525 0 ustar 00 # Complex numbers
# ---------------
# [Now that Python has a complex data type built-in, this is not very
# useful, but it's still a nice example class]
# This module represents complex numbers as instances of the class Complex.
# A Complex instance z has two data attribues, z.re (the real part) and z.im
# (the imaginary part). In fact, z.re and z.im can have any value -- all
# arithmetic operators work regardless of the type of z.re and z.im (as long
# as they support numerical operations).
#
# The following functions exist (Complex is actually a class):
# Complex([re [,im]) -> creates a complex number from a real and an imaginary part
# IsComplex(z) -> true iff z is a complex number (== has .re and .im attributes)
# ToComplex(z) -> a complex number equal to z; z itself if IsComplex(z) is true
# if z is a tuple(re, im) it will also be converted
# PolarToComplex([r [,phi [,fullcircle]]]) ->
# the complex number z for which r == z.radius() and phi == z.angle(fullcircle)
# (r and phi default to 0)
# exp(z) -> returns the complex exponential of z. Equivalent to pow(math.e,z).
#
# Complex numbers have the following methods:
# z.abs() -> absolute value of z
# z.radius() == z.abs()
# z.angle([fullcircle]) -> angle from positive X axis; fullcircle gives units
# z.phi([fullcircle]) == z.angle(fullcircle)
#
# These standard functions and unary operators accept complex arguments:
# abs(z)
# -z
# +z
# not z
# repr(z) == `z`
# str(z)
# hash(z) -> a combination of hash(z.re) and hash(z.im) such that if z.im is zero
# the result equals hash(z.re)
# Note that hex(z) and oct(z) are not defined.
#
# These conversions accept complex arguments only if their imaginary part is zero:
# int(z)
# long(z)
# float(z)
#
# The following operators accept two complex numbers, or one complex number
# and one real number (int, long or float):
# z1 + z2
# z1 - z2
# z1 * z2
# z1 / z2
# pow(z1, z2)
# cmp(z1, z2)
# Note that z1 % z2 and divmod(z1, z2) are not defined,
# nor are shift and mask operations.
#
# The standard module math does not support complex numbers.
# The cmath modules should be used instead.
#
# Idea:
# add a class Polar(r, phi) and mixed-mode arithmetic which
# chooses the most appropriate type for the result:
# Complex for +,-,cmp
# Polar for *,/,pow
import math
import sys
twopi = math.pi*2.0
halfpi = math.pi/2.0
def IsComplex(obj):
return hasattr(obj, 're') and hasattr(obj, 'im')
def ToComplex(obj):
if IsComplex(obj):
return obj
elif isinstance(obj, tuple):
return Complex(*obj)
else:
return Complex(obj)
def PolarToComplex(r = 0, phi = 0, fullcircle = twopi):
phi = phi * (twopi / fullcircle)
return Complex(math.cos(phi)*r, math.sin(phi)*r)
def Re(obj):
if IsComplex(obj):
return obj.re
return obj
def Im(obj):
if IsComplex(obj):
return obj.im
return 0
class Complex:
def __init__(self, re=0, im=0):
_re = 0
_im = 0
if IsComplex(re):
_re = re.re
_im = re.im
else:
_re = re
if IsComplex(im):
_re = _re - im.im
_im = _im + im.re
else:
_im = _im + im
# this class is immutable, so setting self.re directly is
# not possible.
self.__dict__['re'] = _re
self.__dict__['im'] = _im
def __setattr__(self, name, value):
raise TypeError, 'Complex numbers are immutable'
def __hash__(self):
if not self.im:
return hash(self.re)
return hash((self.re, self.im))
def __repr__(self):
if not self.im:
return 'Complex(%r)' % (self.re,)
else:
return 'Complex(%r, %r)' % (self.re, self.im)
def __str__(self):
if not self.im:
return repr(self.re)
else:
return 'Complex(%r, %r)' % (self.re, self.im)
def __neg__(self):
return Complex(-self.re, -self.im)
def __pos__(self):
return self
def __abs__(self):
return math.hypot(self.re, self.im)
def __int__(self):
if self.im:
raise ValueError, "can't convert Complex with nonzero im to int"
return int(self.re)
def __long__(self):
if self.im:
raise ValueError, "can't convert Complex with nonzero im to long"
return long(self.re)
def __float__(self):
if self.im:
raise ValueError, "can't convert Complex with nonzero im to float"
return float(self.re)
def __cmp__(self, other):
other = ToComplex(other)
return cmp((self.re, self.im), (other.re, other.im))
def __rcmp__(self, other):
other = ToComplex(other)
return cmp(other, self)
def __nonzero__(self):
return not (self.re == self.im == 0)
abs = radius = __abs__
def angle(self, fullcircle = twopi):
return (fullcircle/twopi) * ((halfpi - math.atan2(self.re, self.im)) % twopi)
phi = angle
def __add__(self, other):
other = ToComplex(other)
return Complex(self.re + other.re, self.im + other.im)
__radd__ = __add__
def __sub__(self, other):
other = ToComplex(other)
return Complex(self.re - other.re, self.im - other.im)
def __rsub__(self, other):
other = ToComplex(other)
return other - self
def __mul__(self, other):
other = ToComplex(other)
return Complex(self.re*other.re - self.im*other.im,
self.re*other.im + self.im*other.re)
__rmul__ = __mul__
def __div__(self, other):
other = ToComplex(other)
d = float(other.re*other.re + other.im*other.im)
if not d: raise ZeroDivisionError, 'Complex division'
return Complex((self.re*other.re + self.im*other.im) / d,
(self.im*other.re - self.re*other.im) / d)
def __rdiv__(self, other):
other = ToComplex(other)
return other / self
def __pow__(self, n, z=None):
if z is not None:
raise TypeError, 'Complex does not support ternary pow()'
if IsComplex(n):
if n.im:
if self.im: raise TypeError, 'Complex to the Complex power'
else: return exp(math.log(self.re)*n)
n = n.re
r = pow(self.abs(), n)
phi = n*self.angle()
return Complex(math.cos(phi)*r, math.sin(phi)*r)
def __rpow__(self, base):
base = ToComplex(base)
return pow(base, self)
def exp(z):
r = math.exp(z.re)
return Complex(math.cos(z.im)*r,math.sin(z.im)*r)
def checkop(expr, a, b, value, fuzz = 1e-6):
print ' ', a, 'and', b,
try:
result = eval(expr)
except:
result = sys.exc_type
print '->', result
if isinstance(result, str) or isinstance(value, str):
ok = (result == value)
else:
ok = abs(result - value) <= fuzz
if not ok:
print '!!\t!!\t!! should be', value, 'diff', abs(result - value)
def test():
print 'test constructors'
constructor_test = (
# "expect" is an array [re,im] "got" the Complex.
( (0,0), Complex() ),
( (0,0), Complex() ),
( (1,0), Complex(1) ),
( (0,1), Complex(0,1) ),
( (1,2), Complex(Complex(1,2)) ),
( (1,3), Complex(Complex(1,2),1) ),
( (0,0), Complex(0,Complex(0,0)) ),
( (3,4), Complex(3,Complex(4)) ),
( (-1,3), Complex(1,Complex(3,2)) ),
( (-7,6), Complex(Complex(1,2),Complex(4,8)) ) )
cnt = [0,0]
for t in constructor_test:
cnt[0] += 1
if ((t[0][0]!=t[1].re)or(t[0][1]!=t[1].im)):
print " expected", t[0], "got", t[1]
cnt[1] += 1
print " ", cnt[1], "of", cnt[0], "tests failed"
# test operators
testsuite = {
'a+b': [
(1, 10, 11),
(1, Complex(0,10), Complex(1,10)),
(Complex(0,10), 1, Complex(1,10)),
(Complex(0,10), Complex(1), Complex(1,10)),
(Complex(1), Complex(0,10), Complex(1,10)),
],
'a-b': [
(1, 10, -9),
(1, Complex(0,10), Complex(1,-10)),
(Complex(0,10), 1, Complex(-1,10)),
(Complex(0,10), Complex(1), Complex(-1,10)),
(Complex(1), Complex(0,10), Complex(1,-10)),
],
'a*b': [
(1, 10, 10),
(1, Complex(0,10), Complex(0, 10)),
(Complex(0,10), 1, Complex(0,10)),
(Complex(0,10), Complex(1), Complex(0,10)),
(Complex(1), Complex(0,10), Complex(0,10)),
],
'a/b': [
(1., 10, 0.1),
(1, Complex(0,10), Complex(0, -0.1)),
(Complex(0, 10), 1, Complex(0, 10)),
(Complex(0, 10), Complex(1), Complex(0, 10)),
(Complex(1), Complex(0,10), Complex(0, -0.1)),
],
'pow(a,b)': [
(1, 10, 1),
(1, Complex(0,10), 1),
(Complex(0,10), 1, Complex(0,10)),
(Complex(0,10), Complex(1), Complex(0,10)),
(Complex(1), Complex(0,10), 1),
(2, Complex(4,0), 16),
],
'cmp(a,b)': [
(1, 10, -1),
(1, Complex(0,10), 1),
(Complex(0,10), 1, -1),
(Complex(0,10), Complex(1), -1),
(Complex(1), Complex(0,10), 1),
],
}
for expr in sorted(testsuite):
print expr + ':'
t = (expr,)
for item in testsuite[expr]:
checkop(*(t+item))
if __name__ == '__main__':
test()
Dates.py 0000644 00000017215 15040042263 0006160 0 ustar 00 # 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 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
# Adapted to Python 1.1 (where some hacks to overcome coercion are unnecessary)
# by Guido van Rossum
# Note that as of Python 2.3, a datetime module is included in the stardard
# library.
# vi:set tabsize=8:
_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: %r' % type(n)
ans = Date(1,1,1) # arguments irrelevant; just getting a Date obj
del ans.ord, ans.month, ans.day, ans.year # un-initialize it
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, OverflowError): 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: %r' % (month,)
dim = _days_in_month(month, year)
if not 1 <= day <= dim:
raise ValueError, 'day must be in 1..%r: %r' % (dim, day)
self.month, self.day, self.year = month, day, year
self.ord = _date2num(self)
# don't allow setting existing attributes
def __setattr__(self, name, value):
if self.__dict__.has_key(name):
raise AttributeError, 'read-only attribute ' + name
self.__dict__[name] = value
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 %r' % (
self.weekday(),
self.day,
_MONTH_NAMES[self.month-1],
self.year)
# Python 1.1 coerces neither int+date nor date+int
def __add__(self, n):
if type(n) not in _INT_TYPES:
raise TypeError, 'can\'t add %r to date' % type(n)
return _num2date(self.ord + n)
__radd__ = __add__ # handle int+date
# Python 1.1 coerces neither date-int nor date-date
def __sub__(self, other):
if type(other) in _INT_TYPES: # date-int
return _num2date(self.ord - other)
else:
return self.ord - other.ord # date-date
# complain about int-date
def __rsub__(self, other):
raise TypeError, 'Can\'t subtract date from integer'
def weekday(self):
return _num2day(self.ord)
def today():
import time
local = time.localtime(time.time())
return Date(local[1], local[2], local[0])
class DateTestError(Exception):
pass
def test(firstyear, lastyear):
a = Date(9,30,1913)
b = Date(9,30,1914)
if repr(a) != 'Tue 30 Sep 1913':
raise DateTestError, '__repr__ failure'
if (not a < b) or a == b or a > b or b != b:
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
if __name__ == '__main__':
test(1850, 2150)
bitvec.pyc 0000644 00000024065 15040042263 0006540 0 ustar 00 �
��^c @ s{ d d l Z e j j Z d e f d � � YZ d � Z d d l Z d � Z d � Z d � Z
d f d � � YZ e Z d S(
i����Nt errorc B s e Z RS( ( t __name__t
__module__( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR s c C sE t | � t d � k s5 d | k o/ d k n rA t d � n d S( Ni i s) bitvec() items must have int value 0 or 1( t typeR ( t value( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_value
s 5c C s� t j t | � � \ } } d | >} | | k rM t d | | f f � � n x, | r{ | d ?} | | @rn Pn | d } qP W| S( Nl s (param, l) = %ri ( t matht frexpt floatt RuntimeError( t paramt mantt lt bitmask( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _compute_len s
c C si t | � t d � k r$ t d � n | d k r= | | } n d | k oT | k n se t d � n | S( Ni s sequence subscript not ints list index out of range( R t TypeErrort
IndexError( t lent key( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt
_check_key! s
c C s> t | d � t | | � } } | | k r4 | } n | | f S( Ni ( t maxt min( R t it j( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_slice* s t BitVecc B s
e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c G s� d | _ d | _ t | � s! n�t | � d k r | \ } t | � t g � k r� d } d } x+ | D]# } | r� | | B} n | d >} qg W| | _ t | � | _ q�t | � t d � k r� | d k r� t d � n | | _ t | � | _ q�t d � n� t | � d k r�| \ } } t | � t d � k r�| d k rNt d � n | | _ t | � t d � k r{t d � n t | � } | | k r�d
GH| j d | >d @| _ n | | _ q�t d � n t d � d S( Nl i i l s$ bitvec() can't handle negative longss) bitvec() requires array or long parameteri s can't handle negative longss$ bitvec()'s 2nd parameter must be intsM warning: bitvec() value is longer than the length indicates, truncating values% bitvec() requires 0 -- 2 parameter(s)( t _datat _lenR R R R ( t selft paramsR
R t bit_maskt itemt lengtht computed_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __init__4 sL
c C s( t t | � d � | | j | j +d S( Ni ( R t longR ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt appendb s c C sR | r | j } n
| j } d } x) | rM | d ?| | d @d k } } q% W| S( Ni i ( R ( R R t datat count( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR& i s
#c C s^ | r | j } n
| j } d } | s4 t d � n x# | d @sY | d ?| d } } q7 W| S( Ni s list.index(x): x not in listi ( R t
ValueError( R R R% t index( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR( u s
c C s" t t | � d � | | | +d S( Ni ( R R# ( R R( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt insert� s c C s | | j | � =d S( N( R( ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt remove� s c C so | j d } } xO t | j � D]> } | sA | | j | >} Pn | d >| d @B| d ?} } q W| | _ d S( Nl i ( R t rangeR ( R R% t resultR ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt reverse� s !c C s/ | j d � } d | >d | j | >| _ d S( Ni l ( R& R R ( R t c( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt sort� s c C s t | j | j � S( N( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt copy� s c C s( g } x | D] } | j | � q
W| S( N( R$ ( R R, R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt seq� s
c C s d | j | j f S( Ns bitvec(%r, %r)( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __repr__� s c G s# t | � t | � k r1 t t | f | � } n | j } | d k sU | j d k re t | | j � S| | j k r� t | | j � } t | | | | � p� t | | | | � S| j | j k r� d S| d k r� t | d | d � S| d ?} t | | | | � p t | | | | � Sd S( Ni i ( R t applyt bitvecR t cmpR R ( R t othert restR t
min_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __cmp__� s
c C s | j S( N( R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __len__� s c C s' t | j | � } | j d | >@d k S( Nl i ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getitem__� s c C sH t | j | � } | r/ | j d | >B| _ n | j d | >@| _ d S( Nl ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setitem__� s c C sI t | j | � } | | j | | d j | ?B| _ | j d | _ d S( Ni ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delitem__� s #c C s� t | j | | � \ } } | | k r4 t d d � S| rJ | j | ?} n | j } | | } | | j k r� | d | >d @} n t | | � S( Nl i l i ( R R R R ( R R R t ndatat nlength( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getslice__� s
c G s� t | j | | � \ } } t | � t | � k rL t t | f | � } n | | } | | } | j | j | j | j >B| j >B| _ | j | | | j | _ d S( N( R R R R3 R4 R ( R R R t sequenceR7 t ls_partt ms_part( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setslice__� s
c C s� t | j | | � \ } } | d k rK | | j k rK d \ | _ | _ nB | | k r� | | j | | j | ?B| _ | j | | | _ n d S( Ni l ( l i ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delslice__� s c C s# | j � } | | | j | j +| S( N( R0 R ( R R6 t retval( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __add__ s c C s� t | � t d � k r$ t d � n | d k r= t d d � S| d k rS | j � S| j d k rv t d | j | � S| j d k r� t d | j | � St d d � } x | r� | | | d } } q� W| S( Ni s sequence subscript not intl i ( R R R R0 R R ( R t
multiplierRF ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __mul__ s
c G sW t | � t | � k r1 t t | f | � } n t | j | j @t | j | j � � S( N( R R3 R4 R R R R ( R t otherseqR7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __and__ s c G sW t | � t | � k r1 t t | f | � } n t | j | j At | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __xor__% s c G sW t | � t | � k r1 t t | f | � } n t | j | j Bt | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __or__. s c C s# t | j d | j >d @| j � S( Nl i ( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt
__invert__7 s c G s; t | � t | � k r1 t t | f | � } n | | f S( N( R R3 R4 ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt
__coerce__< s c C s
t | j � S( N( t intR ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __int__C s c C s
t | j � S( N( R# R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __long__F s c C s
t | j � S( N( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __float__I s ( R R R" R$ R& R( R) R* R- R/ R0 R1 R2 R9 R: R; R< R= R@ RD RE RG RI RK RL RM RN RO RQ RR RS ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR 2 s: .
(
t syst stderrt writet rprtt ExceptionR R R R R R R R4 ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt <module> s
� Vec.pyo 0000644 00000005404 15040042263 0006011 0 ustar 00 �
��^c @ s' d d d � � YZ d � Z e � d S( t Vecc B sb e Z d Z d � Z e d � � Z d � Z d � Z d � Z d � Z d � Z
d � Z e Z RS( sx A simple vector class
Instances of the Vec class can be constructed from numbers
>>> a = Vec(1, 2, 3)
>>> b = Vec(3, 2, 1)
added
>>> a + b
Vec(4, 4, 4)
subtracted
>>> a - b
Vec(-2, 0, 2)
and multiplied by a scalar on the left
>>> 3.0 * a
Vec(3.0, 6.0, 9.0)
or on the right
>>> a * 3.0
Vec(3.0, 6.0, 9.0)
c G s t | � | _ d S( N( t listt v( t selfR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __init__ s c C s. t | t � s t � n | � } | | _ | S( N( t
isinstanceR t TypeErrorR ( t clsR t inst( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt fromlist s
c C s) d j d � | j D� � } d j | � S( Ns , c s s | ] } t | � Vq d S( N( t repr( t .0t x( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pys <genexpr>% s s Vec({0})( t joinR t format( R t args( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __repr__$ s c C s
t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __len__( s c C s | j | S( N( R ( R t i( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __getitem__+ s c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( t zipR R R ( R t otherR t yR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __add__. s 2c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( R R R R ( R R R R R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __sub__3 s 2c C s- g | j D] } | | ^ q
} t j | � S( N( R R R ( R t scalarR R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __mul__8 s (
t __name__t
__module__t __doc__R t classmethodR R R R R R R t __rmul__( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyR s c C s d d l } | j � d S( Ni����( t doctestt testmod( R! ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt test@ s N( ( R R# ( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt <module> s ? bitvec.py 0000644 00000024377 15040042263 0006403 0 ustar 00 #
# this is a rather strict implementation of a bit vector class
# it is accessed the same way as an array of python-ints, except
# the value must be 0 or 1
#
import sys; rprt = sys.stderr.write #for debugging
class error(Exception):
pass
def _check_value(value):
if type(value) != type(0) or not 0 <= value < 2:
raise error, 'bitvec() items must have int value 0 or 1'
import math
def _compute_len(param):
mant, l = math.frexp(float(param))
bitmask = 1L << l
if bitmask <= param:
raise RuntimeError('(param, l) = %r' % ((param, l),))
while l:
bitmask = bitmask >> 1
if param & bitmask:
break
l = l - 1
return l
def _check_key(len, key):
if type(key) != type(0):
raise TypeError, 'sequence subscript not int'
if key < 0:
key = key + len
if not 0 <= key < len:
raise IndexError, 'list index out of range'
return key
def _check_slice(len, i, j):
#the type is ok, Python already checked that
i, j = max(i, 0), min(len, j)
if i > j:
i = j
return i, j
class BitVec:
def __init__(self, *params):
self._data = 0L
self._len = 0
if not len(params):
pass
elif len(params) == 1:
param, = params
if type(param) == type([]):
value = 0L
bit_mask = 1L
for item in param:
# strict check
#_check_value(item)
if item:
value = value | bit_mask
bit_mask = bit_mask << 1
self._data = value
self._len = len(param)
elif type(param) == type(0L):
if param < 0:
raise error, 'bitvec() can\'t handle negative longs'
self._data = param
self._len = _compute_len(param)
else:
raise error, 'bitvec() requires array or long parameter'
elif len(params) == 2:
param, length = params
if type(param) == type(0L):
if param < 0:
raise error, \
'can\'t handle negative longs'
self._data = param
if type(length) != type(0):
raise error, 'bitvec()\'s 2nd parameter must be int'
computed_length = _compute_len(param)
if computed_length > length:
print 'warning: bitvec() value is longer than the length indicates, truncating value'
self._data = self._data & \
((1L << length) - 1)
self._len = length
else:
raise error, 'bitvec() requires array or long parameter'
else:
raise error, 'bitvec() requires 0 -- 2 parameter(s)'
def append(self, item):
#_check_value(item)
#self[self._len:self._len] = [item]
self[self._len:self._len] = \
BitVec(long(not not item), 1)
def count(self, value):
#_check_value(value)
if value:
data = self._data
else:
data = (~self)._data
count = 0
while data:
data, count = data >> 1, count + (data & 1 != 0)
return count
def index(self, value):
#_check_value(value):
if value:
data = self._data
else:
data = (~self)._data
index = 0
if not data:
raise ValueError, 'list.index(x): x not in list'
while not (data & 1):
data, index = data >> 1, index + 1
return index
def insert(self, index, item):
#_check_value(item)
#self[index:index] = [item]
self[index:index] = BitVec(long(not not item), 1)
def remove(self, value):
del self[self.index(value)]
def reverse(self):
#ouch, this one is expensive!
#for i in self._len>>1: self[i], self[l-i] = self[l-i], self[i]
data, result = self._data, 0L
for i in range(self._len):
if not data:
result = result << (self._len - i)
break
result, data = (result << 1) | (data & 1), data >> 1
self._data = result
def sort(self):
c = self.count(1)
self._data = ((1L << c) - 1) << (self._len - c)
def copy(self):
return BitVec(self._data, self._len)
def seq(self):
result = []
for i in self:
result.append(i)
return result
def __repr__(self):
##rprt('<bitvec class instance object>.' + '__repr__()\n')
return 'bitvec(%r, %r)' % (self._data, self._len)
def __cmp__(self, other, *rest):
#rprt('%r.__cmp__%r\n' % (self, (other,) + rest))
if type(other) != type(self):
other = apply(bitvec, (other, ) + rest)
#expensive solution... recursive binary, with slicing
length = self._len
if length == 0 or other._len == 0:
return cmp(length, other._len)
if length != other._len:
min_length = min(length, other._len)
return cmp(self[:min_length], other[:min_length]) or \
cmp(self[min_length:], other[min_length:])
#the lengths are the same now...
if self._data == other._data:
return 0
if length == 1:
return cmp(self[0], other[0])
else:
length = length >> 1
return cmp(self[:length], other[:length]) or \
cmp(self[length:], other[length:])
def __len__(self):
#rprt('%r.__len__()\n' % (self,))
return self._len
def __getitem__(self, key):
#rprt('%r.__getitem__(%r)\n' % (self, key))
key = _check_key(self._len, key)
return self._data & (1L << key) != 0
def __setitem__(self, key, value):
#rprt('%r.__setitem__(%r, %r)\n' % (self, key, value))
key = _check_key(self._len, key)
#_check_value(value)
if value:
self._data = self._data | (1L << key)
else:
self._data = self._data & ~(1L << key)
def __delitem__(self, key):
#rprt('%r.__delitem__(%r)\n' % (self, key))
key = _check_key(self._len, key)
#el cheapo solution...
self._data = self[:key]._data | self[key+1:]._data >> key
self._len = self._len - 1
def __getslice__(self, i, j):
#rprt('%r.__getslice__(%r, %r)\n' % (self, i, j))
i, j = _check_slice(self._len, i, j)
if i >= j:
return BitVec(0L, 0)
if i:
ndata = self._data >> i
else:
ndata = self._data
nlength = j - i
if j != self._len:
#we'll have to invent faster variants here
#e.g. mod_2exp
ndata = ndata & ((1L << nlength) - 1)
return BitVec(ndata, nlength)
def __setslice__(self, i, j, sequence, *rest):
#rprt('%s.__setslice__%r\n' % (self, (i, j, sequence) + rest))
i, j = _check_slice(self._len, i, j)
if type(sequence) != type(self):
sequence = apply(bitvec, (sequence, ) + rest)
#sequence is now of our own type
ls_part = self[:i]
ms_part = self[j:]
self._data = ls_part._data | \
((sequence._data | \
(ms_part._data << sequence._len)) << ls_part._len)
self._len = self._len - j + i + sequence._len
def __delslice__(self, i, j):
#rprt('%r.__delslice__(%r, %r)\n' % (self, i, j))
i, j = _check_slice(self._len, i, j)
if i == 0 and j == self._len:
self._data, self._len = 0L, 0
elif i < j:
self._data = self[:i]._data | (self[j:]._data >> i)
self._len = self._len - j + i
def __add__(self, other):
#rprt('%r.__add__(%r)\n' % (self, other))
retval = self.copy()
retval[self._len:self._len] = other
return retval
def __mul__(self, multiplier):
#rprt('%r.__mul__(%r)\n' % (self, multiplier))
if type(multiplier) != type(0):
raise TypeError, 'sequence subscript not int'
if multiplier <= 0:
return BitVec(0L, 0)
elif multiplier == 1:
return self.copy()
#handle special cases all 0 or all 1...
if self._data == 0L:
return BitVec(0L, self._len * multiplier)
elif (~self)._data == 0L:
return ~BitVec(0L, self._len * multiplier)
#otherwise el cheapo again...
retval = BitVec(0L, 0)
while multiplier:
retval, multiplier = retval + self, multiplier - 1
return retval
def __and__(self, otherseq, *rest):
#rprt('%r.__and__%r\n' % (self, (otherseq,) + rest))
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
#sequence is now of our own type
return BitVec(self._data & otherseq._data, \
min(self._len, otherseq._len))
def __xor__(self, otherseq, *rest):
#rprt('%r.__xor__%r\n' % (self, (otherseq,) + rest))
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
#sequence is now of our own type
return BitVec(self._data ^ otherseq._data, \
max(self._len, otherseq._len))
def __or__(self, otherseq, *rest):
#rprt('%r.__or__%r\n' % (self, (otherseq,) + rest))
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
#sequence is now of our own type
return BitVec(self._data | otherseq._data, \
max(self._len, otherseq._len))
def __invert__(self):
#rprt('%r.__invert__()\n' % (self,))
return BitVec(~self._data & ((1L << self._len) - 1), \
self._len)
def __coerce__(self, otherseq, *rest):
#needed for *some* of the arithmetic operations
#rprt('%r.__coerce__%r\n' % (self, (otherseq,) + rest))
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
return self, otherseq
def __int__(self):
return int(self._data)
def __long__(self):
return long(self._data)
def __float__(self):
return float(self._data)
bitvec = BitVec
Rev.py 0000644 00000004004 15040042263 0005644 0 ustar 00 '''
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.
>>> chars = list(Rev('Hello World!'))
>>> print ''.join(chars)
!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(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
Hello World! !dlroW olleH
>>> nnn = Rev(range(1, 10))
>>> print nnn.forw
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print nnn.back
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> rrr = Rev(nnn)
>>> rrr
<1, 2, 3, 4, 5, 6, 7, 8, 9>
'''
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 isinstance(seq, list):
wrap = '[]'
sep = ', '
elif isinstance(seq, tuple):
wrap = '()'
sep = ', '
elif isinstance(seq, str):
wrap = ''
sep = ''
else:
wrap = '<>'
sep = ', '
outstrs = [str(item) for item in self.back]
return wrap[:1] + sep.join(outstrs) + wrap[-1:]
def _test():
import doctest, Rev
return doctest.testmod(Rev)
if __name__ == "__main__":
_test()
Vec.py 0000644 00000002515 15040042263 0005632 0 ustar 00 class Vec:
""" A simple vector class
Instances of the Vec class can be constructed from numbers
>>> a = Vec(1, 2, 3)
>>> b = Vec(3, 2, 1)
added
>>> a + b
Vec(4, 4, 4)
subtracted
>>> a - b
Vec(-2, 0, 2)
and multiplied by a scalar on the left
>>> 3.0 * a
Vec(3.0, 6.0, 9.0)
or on the right
>>> a * 3.0
Vec(3.0, 6.0, 9.0)
"""
def __init__(self, *v):
self.v = list(v)
@classmethod
def fromlist(cls, v):
if not isinstance(v, list):
raise TypeError
inst = cls()
inst.v = v
return inst
def __repr__(self):
args = ', '.join(repr(x) for x in self.v)
return 'Vec({0})'.format(args)
def __len__(self):
return len(self.v)
def __getitem__(self, i):
return self.v[i]
def __add__(self, other):
# Element-wise addition
v = [x + y for x, y in zip(self.v, other.v)]
return Vec.fromlist(v)
def __sub__(self, other):
# Element-wise subtraction
v = [x - y for x, y in zip(self.v, other.v)]
return Vec.fromlist(v)
def __mul__(self, scalar):
# Multiply by scalar
v = [x * scalar for x in self.v]
return Vec.fromlist(v)
__rmul__ = __mul__
def test():
import doctest
doctest.testmod()
test()
Complex.pyo 0000644 00000023446 15040042263 0006711 0 ustar 00 �
��^c @ s� d d l Z d d l Z e j d Z e j d Z d � Z d � Z d d e d � Z d � Z d � Z d d d
� � YZ
d � Z d d
� Z d � Z
e d k r� e
� n d S( i����Ng @c C s t | d � o t | d � S( Nt ret im( t hasattr( t obj( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt IsComplexG s c C s7 t | � r | St | t � r) t | � St | � Sd S( N( R t
isinstancet tuplet Complex( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ToComplexJ s
i c C s5 | t | } t t j | � | t j | � | � S( N( t twopiR t matht cost sin( t rt phit
fullcircle( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt PolarToComplexR s c C s t | � r | j S| S( N( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ReV s c C s t | � r | j Sd S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt Im[ s R c B s� e Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d
� Z d � Z d � Z
d
� Z d � Z e Z Z e d � Z e Z d � Z e Z d � Z d � Z d � Z e Z d � Z d � Z d d � Z d � Z RS( i c C s� d } d } t | � r- | j } | j } n | } t | � r\ | | j } | | j } n
| | } | | j d <| | j d <d S( Ni R R ( R R R t __dict__( t selfR R t _ret _im( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __init__b s
c C s
t d � d S( Ns Complex numbers are immutable( t TypeError( R t namet value( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __setattr__t s c C s, | j s t | j � St | j | j f � S( N( R t hashR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __hash__w s
c C s/ | j s d | j f Sd | j | j f Sd S( Ns Complex(%r)s Complex(%r, %r)( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __repr__| s c C s. | j s t | j � Sd | j | j f Sd S( Ns Complex(%r, %r)( R t reprR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __str__� s
c C s t | j | j � S( N( R R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __neg__� s c C s | S( N( ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pos__� s c C s t j | j | j � S( N( R
t hypotR R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __abs__� s c C s" | j r t d � n t | j � S( Ns, can't convert Complex with nonzero im to int( R t
ValueErrort intR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __int__� s c C s" | j r t d � n t | j � S( Ns- can't convert Complex with nonzero im to long( R R% t longR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __long__� s c C s" | j r t d � n t | j � S( Ns. can't convert Complex with nonzero im to float( R R% t floatR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __float__� s c C s1 t | � } t | j | j f | j | j f � S( N( R t cmpR R ( R t other( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __cmp__� s c C s t | � } t | | � S( N( R R, ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rcmp__� s c C s! | j | j k o d k n S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __nonzero__� s c C s& | t t t j | j | j � t S( N( R t halfpiR
t atan2R R ( R R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt angle� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __add__� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __sub__� s c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rsub__� s c C sI t | � } t | j | j | j | j | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __mul__� s c C s� t | � } t | j | j | j | j � } | sB t d � n t | j | j | j | j | | j | j | j | j | � S( Ns Complex division( R R* R R t ZeroDivisionErrorR ( R R- t d( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __div__� s $ "c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rdiv__� s c C s� | d k r t d � n t | � rk | j r_ | j rB t d � q_ t t j | j � | � Sn | j } n t | j � | � } | | j
� } t t j | � | t j
| � | � S( Ns& Complex does not support ternary pow()s Complex to the Complex power( t NoneR R R t expR
t logR t powt absR3 R R R ( R t nt zR
R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pow__� s c C s t | � } t | | � S( N( R R? ( R t base( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rpow__� s N( t __name__t
__module__R R R R R R! R" R$ R' R) R+ R. R/ R0 R@ t radiusR R3 R R4 t __radd__R5 R6 R7 t __rmul__R: R; R< RC RE ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR ` s6
c C s? t j | j � } t t j | j � | t j | j � | � S( N( R
R= R R R R R ( RB R
( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR= � s g���ư>c C s� d G| Gd G| Gy t | � } Wn t j } n Xd G| GHt | t � sZ t | t � ri | | k } n t | | � | k } | s� d G| Gd Gt | | � GHn d S( Ns t ands ->s !! !! !! should bet diff( t evalt syst exc_typeR t strR@ ( t exprt at bR t fuzzt resultt ok( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt checkop� s
c C s d GHd t � f d t � f d! t d � f d" t d d � f d# t t d d � � f d$ t t d d � d � f d% t d t d d � � f d& t d t d � � f d' t d t d d � � f d( t t d d � t d d
� � f f
} d d g } x� | D]x } | d c d 7<| d d | d j k sH| d d | d j k r� d G| d Gd G| d GH| d c d 7<q� q� Wd
G| d Gd G| d Gd GHi d) d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d* d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d+ d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d, d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d- d t d d � d f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � d f d t d d � d f g d 6d. d t d d � d f t d d � d d f t d d � t d � d f t d � t d d � d f g d 6} xI t | � D]; } | d GH| f } x | | D] } t | | � q�Wq�Wd S(/ Ns test constructorsi i i i i i����i����i i s expectedt gots t ofs tests failedi
i s a+bi����i����s a-bs a*bg �?g�������?g��������s a/bi s pow(a,b)s cmp(a,b)t :( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i����i ( i����i ( i i
i ( i i
i����( i i
i
( g �?i
g�������?( i i
i ( i i
i����( R R R t sortedRW ( t constructor_testt cntt tt testsuiteRQ t item( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt test� sn *
6 $+ $+ $+ $+ $ % t __main__( ( R
RN t piR R1 R R R R R R R= RW Ra RF ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt <module>A s
� J Dates.pyc 0000644 00000016246 15040042263 0006326 0 ustar 00 �
��^c @ sp d d d d d d d d d d d
d g Z d d
d d d d d g Z d d d d d d d d d d d d g Z g Z d Z x% e D] Z e j e � e e Z q� W[ [ e d � e d � f Z d � Z d � Z
d � Z d � Z d � Z
d � Z e d � Z d � Z d! � Z d" d, d# � � YZ d$ � Z d% e f d& � � YZ d' � Z e d( k rle d) d* � n d+ S(- t Januaryt Februaryt Marcht Aprilt Mayt Junet Julyt Augustt Septembert Octobert Novembert Decembert Fridayt Saturdayt Sundayt Mondayt Tuesdayt Wednesdayt Thursdayi i i i i l c C s6 | d d k r d S| d d k r( d S| d d k S( Ni i i� i id ( ( t year( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _is_leap> s
c C s d t | � S( Nim ( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt
_days_in_yearC s c C s, | d | d d | d d | d d S( Nl mi i ic id i� i� ( ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_yearF s c C s( | d k r t | � r d St | d S( Ni i i ( R t _DAYS_IN_MONTH( t monthR ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_in_monthI s c C s" t | d | d k o t | � S( Ni i ( t _DAYS_BEFORE_MONTHR ( R R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_monthM s c C s' t | j � t | j | j � | j S( N( R R R R t day( t date( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _date2numP s i� c C s} t | � t k r( t d t | � � n t d d d � } | ` | ` | ` | ` | | _ | d t } d | | t | } } | d } t | � } | | k r� | d } | t
| � } n | | t | | � } } y t | � } Wn t t
f k
rn Xt | d d d � } t | | � } | | k rX| d } | t | | � } n | | | | | _ | _ | _ | S( Ns argument must be integer: %ri i� im i i ( t typet
_INT_TYPESt TypeErrort Datet ordR R R t _DI400YR R t intt
ValueErrort
OverflowErrort minR R ( t nt anst n400R t moret dbyR t dbm( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dateW s0
!c C s t t | d � S( Ni ( t
_DAY_NAMESR% ( R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dayt s R" c B s_ e Z d � Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z
d � Z RS( c C s� d | k o d k n s/ t d | f � n t | | � } d | k oU | k n sp t d | | f � n | | | | _ | _ | _ t | � | _ d S( Ni i s month must be in 1..12: %rs day must be in 1..%r: %r( R& R R R R R R# ( t selfR R R t dim( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __init__y s c C s3 | j j | � r" t d | � n | | j | <d S( Ns read-only attribute ( t __dict__t has_keyt AttributeError( R2 t namet value( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __setattr__� s c C s t | j | j � S( N( t cmpR# ( R2 t other( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __cmp__� s c C s
t | j � S( N( t hashR# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __hash__� s c C s+ d | j � | j t | j d | j f S( Ns %.3s %2d %.3s %ri ( t weekdayR t _MONTH_NAMESR R ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __repr__� s
c C s9 t | � t k r( t d t | � � n t | j | � S( Ns can't add %r to date( R R R! R/ R# ( R2 R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __add__� s c C s5 t | � t k r# t | j | � S| j | j Sd S( N( R R R/ R# ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __sub__� s c C s
t d � d S( Ns Can't subtract date from integer( R! ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __rsub__� s c C s
t | j � S( N( R1 R# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR@ � s ( t __name__t
__module__R4 R: R= R? RB RC t __radd__RD RE R@ ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR" x s
c C s= d d l } | j | j � � } t | d | d | d � S( Ni����i i i ( t timet localtimeR" ( RI t local( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt today� s t
DateTestErrorc B s e Z RS( ( RF RG ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyRM � s c C s� t d d d � } t d d d � } t | � d k rB t d � n | | k ss | | k ss | | k ss | | k r t d � n | d | k s� d | | k r� t d � n | | d k s� | d | k r� t d
� n y d | } t d � Wn t k
rn Xy | | } t d
� Wn t k
r,n X| j � d k rKt d � n t | | � | k sut | | � | k r�t d � n i | | d 6| d | 6} | | d | k s�| | | | t d d d � k r�t d � n t | � } | } x� | | k r�| d } | t | � d } t d d | � t d d | � } }
| j |
j f | | f k rut d | f � n t
| � t
| � } }
d d | d d | f | j | j | j
|
j |
j |
j
f k r�t d | f � n | d } q�Wd S( Ni i iy iz s Tue 30 Sep 1913s __repr__ failures __cmp__ failureim s __add__ failures __sub__ failurei s int-date should have faileds date+date should have failedR s weekday() failures min/max failurein i
s dictionary failurei i s date->num faileds num->date failed( R" t reprRM R! R@ t maxR( R R R# R/ R R R ( t firstyeart lastyeart at bt xt dt lordt yt fordt fdt ld( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt test� sP 1
* 8
% -t __main__i: if N( ( RA R0 R R R. R3 t appendR R R R R R R R R$ R/ R1 R" RL t ExceptionRM R[ RF ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt <module>, s6 *
4 . bitvec.pyo 0000644 00000024065 15040042263 0006554 0 ustar 00 �
��^c @ s{ d d l Z e j j Z d e f d � � YZ d � Z d d l Z d � Z d � Z d � Z
d f d � � YZ e Z d S(
i����Nt errorc B s e Z RS( ( t __name__t
__module__( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR s c C sE t | � t d � k s5 d | k o/ d k n rA t d � n d S( Ni i s) bitvec() items must have int value 0 or 1( t typeR ( t value( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_value
s 5c C s� t j t | � � \ } } d | >} | | k rM t d | | f f � � n x, | r{ | d ?} | | @rn Pn | d } qP W| S( Nl s (param, l) = %ri ( t matht frexpt floatt RuntimeError( t paramt mantt lt bitmask( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _compute_len s
c C si t | � t d � k r$ t d � n | d k r= | | } n d | k oT | k n se t d � n | S( Ni s sequence subscript not ints list index out of range( R t TypeErrort
IndexError( t lent key( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt
_check_key! s
c C s> t | d � t | | � } } | | k r4 | } n | | f S( Ni ( t maxt min( R t it j( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_slice* s t BitVecc B s
e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c G s� d | _ d | _ t | � s! n�t | � d k r | \ } t | � t g � k r� d } d } x+ | D]# } | r� | | B} n | d >} qg W| | _ t | � | _ q�t | � t d � k r� | d k r� t d � n | | _ t | � | _ q�t d � n� t | � d k r�| \ } } t | � t d � k r�| d k rNt d � n | | _ t | � t d � k r{t d � n t | � } | | k r�d
GH| j d | >d @| _ n | | _ q�t d � n t d � d S( Nl i i l s$ bitvec() can't handle negative longss) bitvec() requires array or long parameteri s can't handle negative longss$ bitvec()'s 2nd parameter must be intsM warning: bitvec() value is longer than the length indicates, truncating values% bitvec() requires 0 -- 2 parameter(s)( t _datat _lenR R R R ( t selft paramsR
R t bit_maskt itemt lengtht computed_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __init__4 sL
c C s( t t | � d � | | j | j +d S( Ni ( R t longR ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt appendb s c C sR | r | j } n
| j } d } x) | rM | d ?| | d @d k } } q% W| S( Ni i ( R ( R R t datat count( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR& i s
#c C s^ | r | j } n
| j } d } | s4 t d � n x# | d @sY | d ?| d } } q7 W| S( Ni s list.index(x): x not in listi ( R t
ValueError( R R R% t index( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR( u s
c C s" t t | � d � | | | +d S( Ni ( R R# ( R R( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt insert� s c C s | | j | � =d S( N( R( ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt remove� s c C so | j d } } xO t | j � D]> } | sA | | j | >} Pn | d >| d @B| d ?} } q W| | _ d S( Nl i ( R t rangeR ( R R% t resultR ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt reverse� s !c C s/ | j d � } d | >d | j | >| _ d S( Ni l ( R& R R ( R t c( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt sort� s c C s t | j | j � S( N( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt copy� s c C s( g } x | D] } | j | � q
W| S( N( R$ ( R R, R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt seq� s
c C s d | j | j f S( Ns bitvec(%r, %r)( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __repr__� s c G s# t | � t | � k r1 t t | f | � } n | j } | d k sU | j d k re t | | j � S| | j k r� t | | j � } t | | | | � p� t | | | | � S| j | j k r� d S| d k r� t | d | d � S| d ?} t | | | | � p t | | | | � Sd S( Ni i ( R t applyt bitvecR t cmpR R ( R t othert restR t
min_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __cmp__� s
c C s | j S( N( R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __len__� s c C s' t | j | � } | j d | >@d k S( Nl i ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getitem__� s c C sH t | j | � } | r/ | j d | >B| _ n | j d | >@| _ d S( Nl ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setitem__� s c C sI t | j | � } | | j | | d j | ?B| _ | j d | _ d S( Ni ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delitem__� s #c C s� t | j | | � \ } } | | k r4 t d d � S| rJ | j | ?} n | j } | | } | | j k r� | d | >d @} n t | | � S( Nl i l i ( R R R R ( R R R t ndatat nlength( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getslice__� s
c G s� t | j | | � \ } } t | � t | � k rL t t | f | � } n | | } | | } | j | j | j | j >B| j >B| _ | j | | | j | _ d S( N( R R R R3 R4 R ( R R R t sequenceR7 t ls_partt ms_part( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setslice__� s
c C s� t | j | | � \ } } | d k rK | | j k rK d \ | _ | _ nB | | k r� | | j | | j | ?B| _ | j | | | _ n d S( Ni l ( l i ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delslice__� s c C s# | j � } | | | j | j +| S( N( R0 R ( R R6 t retval( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __add__ s c C s� t | � t d � k r$ t d � n | d k r= t d d � S| d k rS | j � S| j d k rv t d | j | � S| j d k r� t d | j | � St d d � } x | r� | | | d } } q� W| S( Ni s sequence subscript not intl i ( R R R R0 R R ( R t
multiplierRF ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __mul__ s
c G sW t | � t | � k r1 t t | f | � } n t | j | j @t | j | j � � S( N( R R3 R4 R R R R ( R t otherseqR7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __and__ s c G sW t | � t | � k r1 t t | f | � } n t | j | j At | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __xor__% s c G sW t | � t | � k r1 t t | f | � } n t | j | j Bt | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __or__. s c C s# t | j d | j >d @| j � S( Nl i ( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt
__invert__7 s c G s; t | � t | � k r1 t t | f | � } n | | f S( N( R R3 R4 ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt
__coerce__< s c C s
t | j � S( N( t intR ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __int__C s c C s
t | j � S( N( R# R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __long__F s c C s
t | j � S( N( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __float__I s ( R R R" R$ R& R( R) R* R- R/ R0 R1 R2 R9 R: R; R< R= R@ RD RE RG RI RK RL RM RN RO RQ RR RS ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR 2 s: .
(
t syst stderrt writet rprtt ExceptionR R R R R R R R4 ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt <module> s
� Rev.pyo 0000644 00000005461 15040042263 0006033 0 ustar 00 �
��^c @ s< d Z d d d � � YZ d � Z e d k r8 e � n d S( s�
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.
>>> chars = list(Rev('Hello World!'))
>>> print ''.join(chars)
!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(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
Hello World! !dlroW olleH
>>> nnn = Rev(range(1, 10))
>>> print nnn.forw
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print nnn.back
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> rrr = Rev(nnn)
>>> rrr
<1, 2, 3, 4, 5, 6, 7, 8, 9>
t Revc B s, e Z d � Z d � Z d � Z d � Z RS( c C s | | _ | | _ d S( N( t forwt back( t selft seq( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __init__? s c C s
t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __len__C s c C s | j | d S( Ni ( R ( R t j( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __getitem__F s c C s� | j } t | t � r' d } d } nH t | t � rE d } d } n* t | t � rc d } d } n d } d } g | j D] } t | � ^ qy } | d | j | � | d S( Ns []s , s ()t s <>i i����( R t
isinstancet listt tuplet strR t join( R R t wrapt sept itemt outstrs( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __repr__I s "( t __name__t
__module__R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyR > s c C s% d d l } d d l } | j | � S( Ni����( t doctestR t testmod( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt _testZ s t __main__N( ( t __doc__R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt <module>< s