test/unit/test_mathtree.py

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