Annotation of python/pyGiNaC/test4/test_numeric.py, revision 1.3

1.1       pearu       1: #!/usr/bin/env python
                      2: """
                      3:   test_symbol - run ginac.symbol tests.
                      4:   Usage:
                      5:     python test_symbol.py [-v]
                      6: """
                      7: """
                      8:   This file is part of the PyGiNaC package.
                      9:   http://cens.ioc.ee/projects/pyginac/
                     10: 
1.3     ! pearu      11:   $Revision: 1.2 $
        !            12:   $Id: test_numeric.py,v 1.2 2001/11/22 14:50:04 pearu Exp $
1.1       pearu      13:  
                     14:   Copyright 2001 Pearu Peterson all rights reserved,
                     15:   Pearu Peterson <pearu@cens.ioc.ee>
                     16:   Permission to use, modify, and distribute this software is given under the
                     17:   terms of the LGPL.  See http://www.fsf.org
                     18:  
                     19:   NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
                     20: """
                     21: 
1.2       pearu      22: import test_all
1.1       pearu      23: import ginac
                     24: 
                     25: class test_numeric(ginac.numeric):
                     26:     """
                     27:     >>> import math
1.2       pearu      28:     >>> a = numeric (2,3)
                     29:     >>> b = numeric (-4)
                     30:     >>> test_save(math=math,a=a,b=b,s=symbol ('s'),f=numeric ('2.3'))
1.1       pearu      31:     """
                     32:     def __init__(self):
                     33:         """
                     34:         >>> numeric()
                     35:         numeric('0')
                     36:         >>> numeric(2)
                     37:         numeric('2')
                     38:         >>> numeric(numeric(3))
                     39:         numeric('3')
                     40:         >>> numeric('3')
                     41:         numeric('3')
                     42:         >>> numeric(4.0)
                     43:         numeric('4.0')
                     44:         >>> numeric(5.0j)
                     45:         numeric('5.0*I')
                     46:         >>> numeric('3.4')
                     47:         numeric('3.4')
                     48:         >>> numeric('3I')
                     49:         numeric('3*I')
                     50:         >>> numeric(3,4)
                     51:         numeric('3/4')
                     52:         >>> numeric('2/4')
                     53:         numeric('1/2')
                     54:         >>> numeric('I')
                     55:         numeric('I')
                     56:         >>> numeric('1+I')
                     57:         numeric('1+I')
                     58:         >>> numeric(3,numeric('4I'))
                     59:         numeric('-3/4*I')
                     60:         """
                     61:     def get_class_name(self):
                     62:         """
                     63:         >>> numeric().get_class_name()
                     64:         'numeric'
                     65:         """
                     66:     def get_precedence(self):
                     67:         """
                     68:         >>> numeric().get_precedence()
                     69:         30
                     70:         >>> numeric(2+5j).get_precedence()
                     71:         30
                     72:         """
                     73:     def extract_archived(self):
                     74:         """
                     75:         >>> numeric(3).extract_archived()
                     76:         {'number': '3', 'class': 'numeric'}
                     77:         >>> numeric(3.5).extract_archived()
                     78:         {'number': 'R1 16140901064495857664 -62', 'class': 'numeric'}
                     79:         >>> numeric(3,5).extract_archived()
                     80:         {'number': '3/5', 'class': 'numeric'}
                     81:         >>> numeric('3+4*I').extract_archived()
                     82:         {'number': '3+4i', 'class': 'numeric'}
                     83:         >>> numeric('3.5+4.5*I').extract_archived()
                     84:         {'number': 'C1 16140901064495857664 -62 1 10376293541461622784 -61', 'class': 'numeric'}
                     85:         """
                     86:     def to_context(self):
                     87:         """
                     88:         >>> numeric(3).to_context(), numeric(3).to_context(context='latex')
                     89:         ('3', '3')
                     90:         >>> numeric(3).to_context(context='csrc')
                     91:         '3.000000e+00'
                     92:         >>> numeric(3).to_context(context='csrc_float')
                     93:         '3.000000e+00'
                     94:         >>> numeric(3).to_context(context='csrc_double')
                     95:         '3.000000e+00'
                     96:         >>> numeric(3).to_context(context='csrc_cl_N')
                     97:         'cln::cl_F(\"3.0\")'
                     98:         >>> numeric('1234567890123456789').to_context(context='csrc_cl_N')
                     99:         'cln::cl_F(\"1.234567890123456789E18\")'
                    100:         """
                    101:     def __repr__(self):
                    102:         """
                    103:         >>> repr(numeric(3,4))
                    104:         \"numeric('3/4')\"
                    105:         """
                    106:     def __str__(self):
                    107:         """
                    108:         >>> str(numeric(3,4))
                    109:         '3/4'
                    110:         """
                    111:     def __complex__(self):
                    112:         """
                    113:         >>> complex(numeric(1+2j))
                    114:         (1+2j)
                    115:         """
                    116:     def __float__(self):
                    117:         """
                    118:         >>> float(numeric(3.5))
                    119:         3.5
                    120:         >>> float(numeric(2+3j))
                    121:         2.0
                    122:         """
                    123:     def __int__(self):
                    124:         """
                    125:         >>> int(numeric(3))
                    126:         3
                    127:         >>> int(numeric(3.4+5.6j))
                    128:         3
                    129:         """
                    130:     def __long__(self):
                    131:         """
                    132:         >>> long(numeric(3))
                    133:         3L
                    134:         """
                    135:     def csgn(self):
                    136:         """
                    137:         >>> numeric(3).csgn()
                    138:         1
                    139:         >>> numeric(-3).csgn()
                    140:         -1
                    141:         >>> numeric(0).csgn()
                    142:         0
                    143:         >>> numeric(3-4j).csgn()
                    144:         1
                    145:         >>> numeric(-3+4j).csgn()
                    146:         -1
                    147:         """
                    148:     def denom(self):
                    149:         """
                    150:         >>> numeric(3,4).denom()
                    151:         numeric('4')
                    152:         >>> numeric(3.4).denom()
                    153:         numeric('1')
                    154:         >>> numeric(3.4j).denom()
                    155:         numeric('1')
                    156:         """
                    157:     def numer(self):
                    158:         """
                    159:         >>> numeric(3,4).numer()
                    160:         numeric('3')
                    161:         >>> numeric(3.5).numer()
                    162:         numeric('3.5')
                    163:         >>> numeric(3.4j).numer()
                    164:         numeric('3.4*I')
                    165:         """
                    166:     def real(self):
                    167:         """
                    168:         >>> numeric('3+4*I').real()
                    169:         numeric('3')
                    170:         >>> numeric(3).real()
                    171:         numeric('3')
                    172:         """
                    173:     def imag(self):
                    174:         """
                    175:         >>> numeric('3+4*I').imag()
                    176:         numeric('4')
                    177:         >>> numeric(3).imag()
                    178:         numeric('0')
                    179: 
                    180:         """
                    181:     def is_integer(self):
                    182:         """
                    183:         >>> nums = numeric(2), numeric(2,3), numeric(3.4), numeric(1+2j)
                    184:         >>> [n.is_integer() for n in nums]
                    185:         [1, 0, 0, 0]
                    186:         """
                    187:     def is_rational(self):
                    188:         """
                    189:         >>> nums = numeric(2), numeric(2,3), numeric(3.4), numeric(1+2j)
                    190:         >>> [n.is_rational() for n in nums]
                    191:         [1, 1, 0, 0]
                    192:         """
                    193:     def is_real(self):
                    194:         """
                    195:         >>> nums = numeric(2), numeric(2,3), numeric(3.4), numeric(1+2j)
                    196:         >>> [n.is_real() for n in nums]
                    197:         [1, 1, 1, 0]
                    198:         """
                    199:     def is_cinteger(self):
                    200:         """
                    201:         >>> nums = numeric(2), numeric(2,3), numeric(3.4), numeric(1+2j), numeric('2I')
                    202:         >>> [n.is_cinteger() for n in nums]
                    203:         [1, 0, 0, 0, 1]
                    204:         """
                    205:     def is_crational(self):
                    206:         """
                    207:         >>> nums = numeric(2), numeric(2,3), numeric(3.4), numeric(1+2j), numeric('2I'), numeric('2/3*I')
                    208:         >>> [n.is_crational() for n in nums]
                    209:         [1, 1, 0, 0, 1, 1]
                    210:         """
                    211:     def is_even(self):
                    212:         """
                    213:         >>> [numeric(n).is_even() for n in [2,3,2.4,'1/2',4j, 2+0j]]
                    214:         [1, 0, 0, 0, 0, 0]
                    215:         """
                    216:     def is_odd(self):
                    217:         """
                    218:         >>> [numeric(n).is_odd() for n in [2,3,2.4,'1/2',4j, 2+0j]]
                    219:         [0, 1, 0, 0, 0, 0]
                    220:         """
                    221:     def is_prime(self):
                    222:         """
                    223:         >>> [numeric(n).is_prime() for n in range(1,12)]
                    224:         [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1]
                    225:         >>> numeric(3.4).is_prime()
                    226:         0
                    227:         """
                    228:     def is_negative(self):
                    229:         """
                    230:         >>> [numeric(n).is_negative() for n in [-3,0,4,3j,-3j,-1+2j, -3.4]]
                    231:         [1, 0, 0, 0, 0, 0, 1]
                    232:         """
                    233:     def is_positive(self):
                    234:         """
                    235:         >>> [numeric(n).is_positive() for n in [-3,0,4,3j,-3j,-1+2j, -3.4]]
                    236:         [0, 0, 1, 0, 0, 0, 0]
                    237:         """
                    238:     def is_pos_integer(self):
                    239:         """
                    240:         >>> [numeric(n).is_pos_integer() for n in [-3,0,4,3j,-3j,-1+2j, 3.4]]
                    241:         [0, 0, 1, 0, 0, 0, 0]
                    242:         """
                    243:     def is_nonneg_integer(self):
                    244:         """
                    245:         >>> [numeric(n).is_nonneg_integer() for n in [-3,0,4,3j,-3j,-1+2j, 3.4]]
                    246:         [0, 1, 1, 0, 0, 0, 0]
                    247:         """
                    248:     def is_zero(self):
                    249:         """
                    250:         >>> [numeric(n).is_zero() for n in [0,0.0,0j,3,-4.5]]
                    251:         [1, 1, 1, 0, 0]
                    252:         """
                    253:     def __nonzero__(self):
                    254:         """
                    255:         >>> [not numeric(n) for n in [0,0.0,0j,3,-4.5]]
                    256:         [1, 1, 1, 0, 0]
                    257:         """
                    258:     def is_equal(self):
                    259:         """
                    260:         >>> numeric(3).is_equal(3)
                    261:         1
                    262:         """
                    263:     def __abs__(self):
                    264:         """
                    265:         >>> [abs(numeric(n)) for n in [-2,3,3-4j]]
                    266:         [numeric('2'), numeric('3'), numeric('5.0')]
                    267:         """
                    268:     def __neg__(self):
                    269:         """
                    270:         >>> [-numeric(n) for n in [-2,3,3-4j]]
                    271:         [numeric('2'), numeric('-3'), numeric('-3.0+4.0*I')]
                    272:         """
                    273:     def __add__(self):
                    274:         """
                    275:         >>> numeric(4) + numeric('5I')
                    276:         numeric('4+5*I')
                    277:         >>> numeric(3) + 2
                    278:         numeric('5')
                    279:         """
                    280:     def __radd__(self):
                    281:         """
                    282:         >>> 2 + numeric(3)
                    283:         numeric('5')
                    284:         """
                    285:     def __sub__(self):
                    286:         """
                    287:         >>> numeric(4) - numeric('5I')
                    288:         numeric('4-5*I')
                    289:         >>> numeric(3) - 2
                    290:         numeric('1')
                    291:         """
                    292:     def __rsub__(self):
                    293:         """
                    294:         >>> 2 - numeric(3)
                    295:         numeric('-1')
                    296:         """
                    297:     def __mul__(self):
                    298:         """
                    299:         >>> numeric(4) * numeric('5I')
                    300:         numeric('20*I')
                    301:         >>> numeric(3) * 2
                    302:         numeric('6')
                    303:         """
                    304:     def __rmul__(self):
                    305:         """
                    306:         >>> 2 * numeric(3)
                    307:         numeric('6')
                    308:         """
                    309:     def __div__(self):
                    310:         """
                    311:         >>> numeric(4) / numeric('5I')
                    312:         numeric('-4/5*I')
                    313:         >>> numeric(3) / 2
                    314:         numeric('3/2')
                    315:         """
                    316:     def __rdiv__(self):
                    317:         """
                    318:         >>> 2 / numeric(3)
                    319:         numeric('2/3')
                    320:         """
                    321:     def __pow__(self):
                    322:         """
                    323:         >>> numeric(4) ** numeric('5I')
                    324:         numeric('0.79711961721848725724+0.6038214271168690096*I')
                    325:         >>> numeric(3) ** 2
                    326:         numeric('9')
                    327:         """
                    328:     def __rpow__(self):
                    329:         """
                    330:         >>> 2 ** numeric(3)
                    331:         numeric('8')
                    332:         """
                    333:     def inverse(self):
                    334:         """
                    335:         >>> [numeric(n).inverse() for n in [3,'I']]
                    336:         [numeric('1/3'), numeric('-I')]
                    337:         >>> numeric(0.0).inverse()
                    338:         Traceback (most recent call last):
                    339:         ...
                    340:         ZeroDivisionError: division by zero
                    341:         """
                    342:     def int_length(self):
                    343:         """
                    344:         >>> [numeric(n).int_length() for n in [0,1,2,3,4,5,6,-1,-2]]
                    345:         [0, 1, 2, 2, 3, 3, 3, 0, 1]
                    346:         >>> numeric('30I').int_length()
                    347:         0
                    348:         """
                    349:     def compare(self):
                    350:         """
                    351:         >>> numeric(3).compare(5)
                    352:         -1
                    353:         >>> numeric(3).compare(-5j)
                    354:         1
                    355:         
                    356:         """
                    357:     def __lshift__(self):
                    358:         """
                    359:         >>> 0 in [(numeric(n)<<m).is_equal(n<<m) for n,m in [(2,3),(-4,5)]]
                    360:         0
                    361:         >>> numeric(2)<<-3
                    362:         numeric('1/4')
                    363:         >>> numeric(3.5)<<2
                    364:         numeric('14.0')
                    365:         >>> numeric('I')<<3
                    366:         numeric('8*I')
                    367:         """
                    368:     def __rshift__(self):
                    369:         """
                    370:         >>> 0 in [(numeric(n)>>m).is_equal(n>>m) for n,m in [(2,3),(-4,5)]]
                    371:         0
                    372:         >>> numeric(2)>>-3
                    373:         numeric('16')
                    374:         >>> numeric(3.5)>>2
                    375:         numeric('0.875')
                    376:         >>> numeric('I')>>3
                    377:         numeric('1/8*I')
                    378:         """
                    379:     def __pos__(self):
                    380:         """
                    381:         >>> (+numeric(1+2j)).is_equal(1+2j)
                    382:         1
                    383:         """
                    384:     def __invert__(self):
                    385:         """
                    386:         >>> ~numeric(3)
                    387:         numeric('-4')
                    388:         """
                    389:     def conjugate(self):
                    390:         """
                    391:         >>> numeric('3+4I').conjugate()
                    392:         numeric('3-4*I')
                    393:         """
                    394:     def exp(self):
                    395:         """
                    396:         >>> numeric(1).exp()
                    397:         numeric('2.7182818284590452354')
                    398:         """
                    399:     def gcd(self):
                    400:         """
                    401:         >>> numeric(45).gcd(9)
                    402:         numeric('9')
                    403:         """
                    404:     def lcm(self):
                    405:         """
                    406:         >>> numeric(9).lcm(24)
                    407:         numeric('72')
                    408:         """
                    409:     def abs(self):
                    410:         """
                    411:         >>> numeric(-3).abs()
                    412:         numeric('3')
                    413:         """
                    414:     def Li2(self):
                    415:         """
                    416:         >>> numeric(5).Li2()
                    417:         numeric('1.7837191612666306279-5.056198322111862682*I')
                    418:         """
                    419:     def sin(self):
                    420:         """
                    421:         >>> float(numeric(5).sin()) == math.sin(5)
                    422:         1
                    423:         """
                    424:     def cos(self):
                    425:         """
                    426:         >>> float(numeric(5).cos()) == math.cos(5)
                    427:         1
                    428:         """
                    429:     def tan(self):
                    430:         """
                    431:         >>> float(numeric(5).tan()) == math.tan(5)
                    432:         1
                    433:         """
                    434:     def asin(self):
                    435:         """
                    436:         >>> float(numeric(.5).asin()) == math.asin(.5)
                    437:         1
                    438:         """
                    439:     def acos(self):
                    440:         """
                    441:         >>> float(numeric(.5).acos()) == math.acos(.5)
                    442:         1
                    443:         """
                    444:     def atan(self):
                    445:         """
                    446:         >>> float(numeric(5).atan()) == math.atan(5)
                    447:         1
                    448:         """
                    449:     def sinh(self):
                    450:         """
                    451:         >>> float(numeric(5).sinh()) == math.sinh(5)
                    452:         1
                    453:         """
                    454:     def cosh(self):
                    455:         """
                    456:         >>> float(numeric(5).cosh()) == math.cosh(5)
                    457:         1
                    458:         """
                    459:     def tanh(self):
                    460:         """
                    461:         >>> float(numeric(5).tanh()) == math.tanh(5)
                    462:         1
                    463:         """
                    464:     def asinh(self):
                    465:         """
                    466:         >>> float(numeric(5).asinh().sinh()) == 5
                    467:         1
                    468:         """
                    469:     def acosh(self):
                    470:         """
                    471:         >>> float(numeric(5).acosh().cosh()) == 5
                    472:         1
                    473:         """
                    474:     def atanh(self):
                    475:         """
                    476:         >>> float(numeric(5).atanh().tanh()) == 5
                    477:         1
                    478:         """
                    479:     def atan2(self):
                    480:         """
                    481:         >>> float(numeric(5).atan2(4)) == math.atan2(5,4)
                    482:         1
                    483:         """
                    484:     def bernoulli(self):
                    485:         """
                    486:         >>> [numeric(n).bernoulli() for n in range(5)]
                    487:         [numeric('1'), numeric('-1/2'), numeric('1/6'), numeric('0'), numeric('-1/30')]
                    488:         """
                    489:     def factorial(self):
                    490:         """
                    491:         >>> [int(numeric(n).factorial()) for n in range(10)]
                    492:         [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
                    493:         """
                    494:     def doublefactorial(self):
                    495:         """
                    496:         >>> [int(numeric(n).doublefactorial()) for n in range(10)]
                    497:         [1, 1, 2, 3, 8, 15, 48, 105, 384, 945]
                    498:         """
                    499:     def fibonacci(self):
                    500:         """
                    501:         >>> [int(numeric(n).fibonacci()) for n in range(10)]
                    502:         [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
                    503:         """
                    504:     def sqrt(self):
                    505:         """
                    506:         >>> float(numeric(5).sqrt()) == math.sqrt(5)
                    507:         1
                    508:         """
                    509:     def isqrt(self):
                    510:         """
                    511:         >>> numeric(5).isqrt()
                    512:         numeric('2')
                    513:         """
                    514:     def log(self):
                    515:         """
                    516:         >>> float(numeric(5).log().exp()) == 5
                    517:         1
                    518:         """
                    519:     def binomial(self):
                    520:         """
                    521:         >>> [int(numeric(5).binomial(n)) for n in range(-5,10)]
                    522:         [0, 0, 0, 0, 0, 1, 5, 10, 10, 5, 1, 0, 0, 0, 0]
                    523:         """
                    524:     def mod(self):
                    525:         """
                    526:         >>> [int(numeric(5).mod(n)) for n in range(1,15)]
                    527:         [0, 1, 2, 1, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5]
                    528:         >>> numeric(5).mod(0)
                    529:         Traceback (most recent call last):
                    530:         ...
                    531:         ZeroDivisionError: division by zero
                    532:         """
                    533:     def smod(self):
                    534:         """
                    535:         >>> [int(numeric(5).smod(n)) for n in range(1,15)]
                    536:         [1, 1, 2, 1, 0, -1, -2, -3, 5, 5, 5, 5, 5, 5]
                    537:         >>> numeric(5).smod(0)
                    538:         Traceback (most recent call last):
                    539:         ...
                    540:         ZeroDivisionError: division by zero
                    541:         """
                    542:     def irem(self):
                    543:         """
                    544:         >>> [int(numeric(5).irem(n)) for n in range(1,15)]
                    545:         [0, 1, 2, 1, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5]
                    546:         >>> numeric(5).irem(0)
                    547:         Traceback (most recent call last):
                    548:         ...
                    549:         ZeroDivisionError: division by zero
                    550:         """
                    551:     def iquo(self):
                    552:         """
                    553:         >>> [int(numeric(5).iquo(n)) for n in range(1,15)]
                    554:         [5, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
                    555:         >>> numeric(5).iquo(0)
                    556:         Traceback (most recent call last):
                    557:         ...
                    558:         ZeroDivisionError: division by zero
                    559:         """
1.2       pearu     560:     def __eq__ (self):
                    561:         """
                    562:         >>> a==b
1.3     ! pearu     563:         relational(numeric('2/3'),numeric('-4'),'==')
1.2       pearu     564:         >>> not a==b
                    565:         1
                    566:         >>> a==2
1.3     ! pearu     567:         relational(numeric('2/3'),numeric('2'),'==')
1.2       pearu     568:         >>> -2==b
1.3     ! pearu     569:         relational(numeric('-4'),numeric('-2'),'==')
1.2       pearu     570:         """
                    571:     def __ne__ (self):
                    572:         """
                    573:         >>> a!=b
1.3     ! pearu     574:         relational(numeric('2/3'),numeric('-4'),'!=')
1.2       pearu     575:         >>> not a!=b
                    576:         0
                    577:         """
                    578:     def __lt__ (self):
                    579:         """
                    580:         >>> a<b
1.3     ! pearu     581:         relational(numeric('2/3'),numeric('-4'),'<')
1.2       pearu     582:         >>> not a<b
                    583:         1
                    584:         >>> a<3
1.3     ! pearu     585:         relational(numeric('2/3'),numeric('3'),'<')
1.2       pearu     586:         >>> 3<a
1.3     ! pearu     587:         relational(numeric('3'),numeric('2/3'),'<')
1.2       pearu     588:         """
                    589:     def __le__ (self):
                    590:         """
                    591:         >>> a<=b
1.3     ! pearu     592:         relational(numeric('2/3'),numeric('-4'),'<=')
1.2       pearu     593:         >>> not a<=b
                    594:         1
                    595:         """
                    596:     def __gt__ (self):
                    597:         """
                    598:         >>> a>b
1.3     ! pearu     599:         relational(numeric('-4'),numeric('2/3'),'<')
1.2       pearu     600:         >>> not a>b
                    601:         0
                    602:         """
                    603:     def __ge__ (self):
                    604:         """
                    605:         >>> a>=b
1.3     ! pearu     606:         relational(numeric('-4'),numeric('2/3'),'<=')
1.2       pearu     607:         >>> not a>=b
                    608:         0
                    609:         """
                    610:     def eval (self):
                    611:         """
                    612:         >>> a.eval ()
                    613:         numeric('2/3')
                    614:         """
                    615:     def evalf (self):
                    616:         """
                    617:         >>> a.evalf ()
                    618:         numeric('0.6666666666666666667')
                    619:         """
                    620:     def evalm (self):
                    621:         """
                    622:         >>> a.evalm ()
                    623:         numeric('2/3')
                    624:         """
                    625:     def to_list (self):
                    626:         """
                    627:         >>> a.to_list ()
                    628:         []
                    629:         """
                    630:     def op (self):
                    631:         """
                    632:         >>> a.op (0)
                    633:         Traceback (most recent call last):
                    634:         ...
                    635:         IndexError: op(): index out of range
                    636:         """
                    637:     def nops (self):
                    638:         """
                    639:         >>> a.nops ()
                    640:         0
                    641:         """
                    642:     def numer_denom (seld):
                    643:         """
                    644:         >>> a.numer_denom ()
                    645:         (numeric('2'), numeric('3'))
                    646:         >>> numeric ('2.3').numer_denom ()
                    647:         (numeric('2.3'), numeric('1'))
                    648:         """
                    649:     def coeff (self):
                    650:         """
                    651:         >>> a.coeff (s)
                    652:         numeric('0')
                    653:         >>> a.coeff (a)
                    654:         numeric('0')
                    655:         >>> a.coeff (s,0)
                    656:         numeric('2/3')
                    657:         """
                    658:     def lcoeff (self):
                    659:         """
                    660:         >>> a.lcoeff (s)
                    661:         numeric('2/3')
                    662:         """
                    663:     def tcoeff (self):
                    664:         """
                    665:         >>> a.tcoeff (s)
                    666:         numeric('2/3')
                    667:         """
                    668:     def degree (self):
                    669:         """
                    670:         >>> a.degree (a)
                    671:         0
                    672:         >>> a.degree (s)
                    673:         0
                    674:         """
                    675:     def ldegree (self):
                    676:         """
                    677:         >>> a.ldegree (s)
                    678:         0
                    679:         >>> a.degree (a)
                    680:         0
                    681:         """
                    682:     def integer_content (self):
                    683:         """
                    684:         >>> a.integer_content ()
                    685:         numeric('2/3')
                    686:         >>> f.integer_content ()
                    687:         numeric('2.3')
                    688:         """
                    689:     def content (self):
                    690:         """
                    691:         >>> a.content (s)
                    692:         numeric('2/3')
                    693:         """
                    694:     def unit (self):
                    695:         """
                    696:         >>> a.unit (s)
                    697:         numeric('1')
                    698:         """
                    699:     def primpart (self):
                    700:         """
                    701:         >>> a.primpart (s)
                    702:         numeric('1')
                    703:         """
                    704:     def has (self):
                    705:         """
                    706:         >>> a.has (a)
                    707:         1
                    708:         >>> a.has (numeric (2,3))
                    709:         1
                    710:         >>> a.has (2)
                    711:         0
                    712:         >>> a.has (3)
                    713:         0
                    714:         >>> f.has (2)
                    715:         0
                    716:         >>> numeric (2).has (2)
                    717:         1
                    718:         >>> a.has (s)
                    719:         0
                    720:         """
                    721:     def swap (self):
                    722:         """
                    723:         >>> a.swap (f)
                    724:         >>> a,f
                    725:         (numeric('2.3'), numeric('2/3'))
                    726:         >>> a.swap (f)
                    727:         >>> a,f
                    728:         (numeric('2/3'), numeric('2.3'))
                    729:         """
                    730:     def max_coefficient (self):
                    731:         """
                    732:         >>> a.max_coefficient ()
                    733:         numeric('2/3')
                    734:         >>> b.max_coefficient ()
                    735:         numeric('4')
                    736:         >>> f.max_coefficient ()
                    737:         numeric('2.3')
                    738:         """
                    739:     def diff (self):
                    740:         """
                    741:         >>> a.diff (s)
                    742:         numeric('0')
                    743:         >>> a.diff (s,0)
                    744:         numeric('2/3')
                    745:         >>> a.diff (s,-1)
                    746:         Traceback (most recent call last):
                    747:         ...
                    748:         TypeError: diff() method 2nd argument must be positive int
                    749:         """
                    750:     def get_hash (self):
                    751:         """
                    752:         >>> type (a.get_hash ()) is type (0)
                    753:         1
                    754:         """
                    755:     def __coerce__ (self):
                    756:         """
                    757:         >>> coerce (a,2)
                    758:         (numeric('2/3'), numeric('2'))
                    759:         """
                    760:     def psi_fixme (self):
                    761:         """
                    762:         >>> #numeric (2).psi ()
                    763:         
1.3     ! pearu     764:         """
        !           765:     def is_function (self):
        !           766:         """
        !           767:         >>> a.is_function ()
        !           768:         0
1.2       pearu     769:         """
1.1       pearu     770: def _test():
                    771:     import test_numeric
                    772:     return test_all.test(test_numeric)
                    773: 
                    774: if __name__ == "__main__":
                    775:     _test()

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>