test/unit/test_mathtree.py

   1 import sys
   2 if sys.path[0] != "../..":
   3     sys.path.insert(0, "../..")
   4
   5 import unittest
   6
   7 import parser
   8 from pyx import *
   9 from pyx import mathtree
  10
  11 class MathTreeTestCase(unittest.TestCase):
  12
  13     def testStr(self):
  14         myparser = mathtree.parser()
  15         assert str(myparser.parse("a+b-c")) == "a+b-c"
  16         assert str(myparser.parse("(a+b)-c")) == "a+b-c"
  17         assert str(myparser.parse("a+(b-c)")) == "a+(b-c)" # XXX: needs no parenthesis
  18         assert str(myparser.parse("a-b+c")) == "a-b+c"
  19         assert str(myparser.parse("(a-b)+c")) == "a-b+c"
  20         assert str(myparser.parse("a-(b+c)")) == "a-(b+c)"
  21         assert str(myparser.parse("a+b-c*d/e**f")) == "a+b-c*d/e^f"
  22         assert str(myparser.parse("a**b/c*d-e+f")) == "a^b/c*d-e+f"
  23         assert str(myparser.parse("((a-(b+c))/(d*e))**f")) == "((a-(b+c))/(d*e))^f"
  24         assert str(myparser.parse("sin(pi/2)")) == "sin(pi/2.0)"
  25         assert str(myparser.parse("a+b*sin(c)**d")) == "a+b*sin(c)^d"
  26         assert str(myparser.parse("a+b*(c)")) == "a+b*c"
  27         assert str(myparser.parse("norm(a,b)")) == "norm(a,b)"
  28
  29     def testRepr(self):
  30         myparser = mathtree.parser()
  31         assert repr(myparser.parse("a+b-c")) == """MathTreeOpSub(
  32     MathTreeOpAdd(
  33         MathTreeValVar(
  34             'a'),
  35         MathTreeValVar(
  36             'b')),
  37     MathTreeValVar(
  38         'c'))"""
  39         assert repr(myparser.parse("(a+b)-c")) == """MathTreeOpSub(
  40     MathTreeOpAdd(
  41         MathTreeValVar(
  42             'a'),
  43         MathTreeValVar(
  44             'b')),
  45     MathTreeValVar(
  46         'c'))"""
  47         assert repr(myparser.parse("a+(b-c)")) == """MathTreeOpAdd(
  48     MathTreeValVar(
  49         'a'),
  50     MathTreeOpSub(
  51         MathTreeValVar(
  52             'b'),
  53         MathTreeValVar(
  54             'c')))"""
  55         assert repr(myparser.parse("a-b+c")) == """MathTreeOpAdd(
  56     MathTreeOpSub(
  57         MathTreeValVar(
  58             'a'),
  59         MathTreeValVar(
  60             'b')),
  61     MathTreeValVar(
  62         'c'))"""
  63         assert repr(myparser.parse("(a-b)+c")) == """MathTreeOpAdd(
  64     MathTreeOpSub(
  65         MathTreeValVar(
  66             'a'),
  67         MathTreeValVar(
  68             'b')),
  69     MathTreeValVar(
  70         'c'))"""
  71         assert repr(myparser.parse("a-(b+c)")) == """MathTreeOpSub(
  72     MathTreeValVar(
  73         'a'),
  74     MathTreeOpAdd(
  75         MathTreeValVar(
  76             'b'),
  77         MathTreeValVar(
  78             'c')))"""
  79         assert repr(myparser.parse("a+b-c*d/e**f")) == """MathTreeOpSub(
  80     MathTreeOpAdd(
  81         MathTreeValVar(
  82             'a'),
  83         MathTreeValVar(
  84             'b')),
  85     MathTreeOpDiv(
  86         MathTreeOpMul(
  87             MathTreeValVar(
  88                 'c'),
  89             MathTreeValVar(
  90                 'd')),
  91         MathTreeOpPow(
  92             MathTreeValVar(
  93                 'e'),
  94             MathTreeValVar(
  95                 'f'))))"""
  96         assert repr(myparser.parse("a**b/c*d-e+f")) == """MathTreeOpAdd(
  97     MathTreeOpSub(
  98         MathTreeOpMul(
  99             MathTreeOpDiv(
 100                 MathTreeOpPow(
 101                     MathTreeValVar(
 102                         'a'),
 103                     MathTreeValVar(
 104                         'b')),
 105                 MathTreeValVar(
 106                     'c')),
 107             MathTreeValVar(
 108                 'd')),
 109         MathTreeValVar(
 110             'e')),
 111     MathTreeValVar(
 112         'f'))"""
 113         assert repr(myparser.parse("((a-(b+c))/(d*e))**f")) == """MathTreeOpPow(
 114     MathTreeOpDiv(
 115         MathTreeOpSub(
 116             MathTreeValVar(
 117                 'a'),
 118             MathTreeOpAdd(
 119                 MathTreeValVar(
 120                     'b'),
 121                 MathTreeValVar(
 122                     'c'))),
 123         MathTreeOpMul(
 124             MathTreeValVar(
 125                 'd'),
 126             MathTreeValVar(
 127                 'e'))),
 128     MathTreeValVar(
 129         'f'))"""
 130         assert repr(myparser.parse("sin(pi/2)")) == """MathTreeFunc1Sin(
 131     MathTreeOpDiv(
 132         MathTreeValVar(
 133             'pi'),
 134         MathTreeValConst(
 135             2.0)))"""
 136         assert repr(myparser.parse("a+b*sin(c)**d")) == """MathTreeOpAdd(
 137     MathTreeValVar(
 138         'a'),
 139     MathTreeOpMul(
 140         MathTreeValVar(
 141             'b'),
 142         MathTreeOpPow(
 143             MathTreeFunc1Sin(
 144                 MathTreeValVar(
 145                     'c')),
 146             MathTreeValVar(
 147                 'd'))))"""
 148         assert repr(myparser.parse("a+b*(c)")) == """MathTreeOpAdd(
 149     MathTreeValVar(
 150         'a'),
 151     MathTreeOpMul(
 152         MathTreeValVar(
 153             'b'),
 154         MathTreeValVar(
 155             'c')))"""
 156         assert repr(myparser.parse("norm(a,b)")) == """MathTreeFunc2Norm(
 157     MathTreeValVar(
 158         'a'),
 159     MathTreeValVar(
 160         'b'))"""
 161
 162     def testCalc(self):
 163         myparser = mathtree.parser()
 164         abc = {"a": 1, "b": 2, "c": 3}
 165         abcdef = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6}
 166         assert abs(myparser.parse("a+b-c").Calc(**abc)) <= 1e-10
 167         assert abs(myparser.parse("(a+b)-c").Calc(**abc)) <= 1e-10
 168         assert abs(myparser.parse("a+(b-c)").Calc(**abc)) <= 1e-10
 169         assert abs(myparser.parse("a-b+c-2").Calc(**abc)) <= 1e-10
 170         assert abs(myparser.parse("(a-b)+c-2").Calc(**abc)) <= 1e-10
 171         assert abs(myparser.parse("a-(b+c)+4").Calc(**abc)) <= 1e-10
 172         assert abs(myparser.parse("a+b-c*d/e**f-2.999232").Calc(**abcdef)) <= 1e-10
 173         assert abs(myparser.parse("a**b/c*d-e+f-7/3").Calc(**abcdef)) <= 1e-10
 174         assert abs(myparser.parse("((a-(b+c))/(d*e))**f-6.4e-5").Calc(**abcdef)) <= 1e-10
 175         assert abs(myparser.parse("-a**2+1").Calc(**abc)) <= 1e-10
 176         assert abs(myparser.parse("-1**2+1").Calc(**abc)) <= 1e-10
 177         assert abs(myparser.parse("1-a**2").Calc(**abc)) <= 1e-10
 178         assert abs(myparser.parse("--1-a**2").Calc(**abc)) <= 1e-10
 179         assert abs(myparser.parse("1+-a**2").Calc(**abc)) <= 1e-10
 180         assert abs(myparser.parse("neg(1)+1").Calc()) <= 1e-10
 181         assert abs(myparser.parse("abs(2)-2").Calc()) <= 1e-10
 182         assert abs(myparser.parse("abs(-2)-2").Calc()) <= 1e-10
 183         assert abs(myparser.parse("sgn(1)-1").Calc()) <= 1e-10
 184         assert abs(myparser.parse("sgn(-1)+1").Calc()) <= 1e-10
 185         assert abs(myparser.parse("sqrt(4)-2").Calc()) <= 1e-10
 186         assert abs(myparser.parse("log(e)-1").Calc()) <= 1e-10
 187         assert abs(myparser.parse("exp(1)-e").Calc()) <= 1e-10
 188         assert abs(myparser.parse("sin(pi/2)-1").Calc()) <= 1e-10
 189         assert abs(myparser.parse("cos(pi)+1").Calc()) <= 1e-10
 190         assert abs(myparser.parse("tan(pi/4)-1").Calc()) <= 1e-10
 191         assert abs(myparser.parse("asin(1) - pi/2").Calc()) <= 1e-10
 192         assert abs(myparser.parse("acos(-1) - pi").Calc()) <= 1e-10
 193         assert abs(myparser.parse("atan(1) - pi/4").Calc()) <= 1e-10
 194         assert abs(myparser.parse("sind(90)-1").Calc()) <= 1e-10
 195         assert abs(myparser.parse("cosd(180)+1").Calc()) <= 1e-10
 196         assert abs(myparser.parse("tand(45)-1").Calc()) <= 1e-10
 197         assert abs(myparser.parse("asind(1) - 90").Calc()) <= 1e-10
 198         assert abs(myparser.parse("acosd(-1) - 180").Calc()) <= 1e-10
 199         assert abs(myparser.parse("atand(1) - 45").Calc()) <= 1e-10
 200         assert abs(myparser.parse("norm(3,4)").Calc() - 5) <= 1e-10
 201
 202     def testExtern(self):
 203         myparser = mathtree.parser()
 204         assert abs(myparser.parse("a+b-c").Calc(a=1, b=2, c=3)) <= 1e-10
 205         assert abs(myparser.parse("f(2)-4").Calc(f=lambda x: x*x)) <= 1e-10
 206
 207     def testException(self):
 208         myparser = mathtree.parser()
 209         self.failUnlessRaises((parser.ParserError, SyntaxError), myparser.parse, "")
 210         self.failUnlessRaises((parser.ParserError, SyntaxError), myparser.parse, "???")
 211         self.failUnlessRaises(Exception, myparser.parse, "sin()")
 212         self.failUnlessRaises(mathtree.ArgCountError, myparser.parse, "sin(x,y)")
 213         self.failUnlessRaises(KeyError, myparser.parse("sin(x)").Calc)
 214         self.failUnlessRaises(IndexError, myparser.parse("norm(x)").Calc, x=1)
 215         self.failUnlessRaises((parser.ParserError, SyntaxError), myparser.parse, "xxx yyy")
 216         self.failUnlessRaises((parser.ParserError, SyntaxError), myparser.parse, "(1+2")
 217         self.failUnlessRaises((parser.ParserError, SyntaxError), myparser.parse, "1+2)")
 218         self.failUnlessEqual(len(myparser.parse("1,2")), 2)
 219         self.failUnlessRaises(Exception, myparser.parse, "1^2")
 220         self.failUnlessRaises(Exception, myparser.parse, "1+2 and 3")
 221
 222
 223 if __name__ == "__main__":
 224     unittest.main()