test/unit/test_mathtree.py

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