Extensions/param2.py

   1 from __future__ import division
   2 import math
   3
   4 def mkf(value):
   5     if type(value) in (type(1), type(1L), type(1.5), type(1j),type("hh")):
   6         return Constant(value)
   7     elif isinstance(value, Formula):
   8         return value
   9     else:
  10         raise TypeError, ("Can't make formula from", value)
  11
  12 #class Formula(object):
  13 class Formula:
  14     def __complex__(self): return complex(self.eval())
  15     def __int__(self): return int(self.eval())
  16     def __long__(self): return long(self.eval())
  17     def __float__(self): return float(self.eval())
  18     def __pos__(self): return self  # positive
  19     def __neg__(self): return Unop('-', self)
  20     def __add__(self, other): return Binop('+', self, other)
  21     def __radd__(self, other): return Binop('+', other, self)
  22     def __sub__(self, other): return Binop('-', self, other)
  23     def __rsub__(self, other): return Binop('-', other, self)
  24     def __mul__(self, other): return Binop('*', self, other)
  25     def __rmul__(self, other): return Binop('*', other, self)
  26     def __div__(self, other): return Binop('/', self, other)
  27     def __truediv__(self, other): return Binop('/', self, other)
  28     def __rdiv__(self, other): return Binop('/', other, self)
  29     def __pow__(self, other): return Binop('**', self, other)
  30     def __rpow__(self, other): return Binop('**', other, self)
  31     def __getitem__(self,i):return Binop('[]',self,i)
  32
  33 class Binop(Formula):
  34     opmap = { '+': lambda a, b: a + b,
  35               '*': lambda a, b: a * b,
  36               '-': lambda a, b: a - b,
  37               '/': lambda a, b: a / b,
  38               '**': lambda a, b: a ** b,
  39               '[]': lambda a, b: a[b] ,
  40             }
  41     def __init__(self, op, value1, value2):
  42         self.op = op
  43         self.values = mkf(value1), mkf(value2)
  44     def __str__(self):
  45         if self.op == '[]':
  46            return "(%s[%s])" % (self.values[0], self.values[1])
  47         else:
  48            return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
  49     def __repr__(self):
  50         if self.op == '[]':
  51            return "(%s[%s])" % (self.values[0], self.values[1])
  52         else:
  53            return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
  54     def eval(self):
  55         result= self.opmap[self.op](self.values[0].eval(),
  56                                    self.values[1].eval())
  57         while isinstance(result,Formula):
  58               result=result.eval()
  59         return result
  60
  61 class Unop(Formula):
  62     opmap = { '-': lambda x: -x,
  63               'sin': lambda x: math.sin(x),
  64               'cos': lambda x: math.cos(x) }
  65     def __init__(self, op, arg):
  66         self._op = op
  67         self._arg = mkf(arg)
  68     def __str__(self):
  69         return "%s(%s)" % (self._op, self._arg)
  70     def eval(self):
  71         return self.opmap[self._op](self._arg.eval())
  72
  73 class Constant(Formula):
  74     def __init__(self, value): self._value = value
  75     def eval(self): return self._value
  76     def __str__(self): return str(self._value)
  77
  78 class Variable(Formula):
  79     def __init__(self,name,value):
  80         self._name=name
  81         self._value=value
  82     def eval(self): return self._value
  83     def __repr__(self): return "Variable('%s',%s)" % (self._name, self._value)
  84     def __str__(self): return self._name
  85
  86 def cos(f): return Unop('cos', f)
  87 def sin(f): return Unop('sin', f)