Extensions/param2.py

   1 # -*- coding: utf-8 -*-
   2 from __future__ import division
   3 import math
   4 import Numeric
   5 import types
   6
   7 def mkf(value):
   8     if type(value) in (type(1), type(1L), type(1.5), type(1j),type("hh")) :
   9         return Constant(value)
  10     elif isinstance(value, Formula):
  11         return value
  12     elif type(value) == type([]):
  13         return Constant(value)
  14     else:
  15 #        return Constant(value)
  16         raise TypeError, ("Can't make formula from", value)
  17
  18 #class Formula(object):
  19 class Formula:
  20     def __len__(self):
  21         val=self.eval()
  22         if val is None:return 0
  23         try:
  24            return len(val)
  25         except:
  26            return 1
  27     def __complex__(self): return complex(self.eval())
  28     def __int__(self): return int(self.eval())
  29     def __long__(self): return long(self.eval())
  30     def __float__(self): return float(self.eval())
  31     def __pos__(self): return self  # positive
  32     def __neg__(self): return Unop('-', self)
  33     def __abs__(self): return Unop('abs', self)
  34     def __add__(self, other): return Binop('+', self, other)
  35     def __radd__(self, other): return Binop('+', other, self)
  36     def __sub__(self, other): return Binop('-', self, other)
  37     def __rsub__(self, other): return Binop('-', other, self)
  38     def __mul__(self, other): return Binop('*', self, other)
  39     def __rmul__(self, other): return Binop('*', other, self)
  40     def __div__(self, other): return Binop('/', self, other)
  41     def __truediv__(self, other): return Binop('/', self, other)
  42     def __rdiv__(self, other): return Binop('/', other, self)
  43     def __pow__(self, other): return Binop('**', self, other)
  44     def __rpow__(self, other): return Binop('**', other, self)
  45     def __getitem__(self,i):return Binop('[]',self,i)
  46
  47 class Binop(Formula):
  48     opmap = { '+': lambda a, b: a + b,
  49               '*': lambda a, b: a * b,
  50               '-': lambda a, b: a - b,
  51               '/': lambda a, b: a / b,
  52               '**': lambda a, b: a ** b,
  53               '[]': lambda a, b: a[b] ,
  54             }
  55     def __init__(self, op, value1, value2):
  56         self.op = op
  57         self.values = mkf(value1), mkf(value2)
  58     def __str__(self):
  59         if self.op == '[]':
  60            return "%s[%s]" % (self.values[0], self.values[1])
  61         else:
  62            return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
  63     def __repr__(self):
  64         if self.op == '[]':
  65            return "%s[%s]" % (self.values[0], self.values[1])
  66         else:
  67            return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
  68     def eval(self):
  69         result= self.opmap[self.op](self.values[0].eval(),
  70                                    self.values[1].eval())
  71         while isinstance(result,Formula):
  72               result=result.eval()
  73         return result
  74     def __adapt__(self,validator):
  75         return validator.adapt(self.eval())
  76
  77
  78 class Unop(Formula):
  79     opmap = { '-': lambda x: -x,
  80               'abs': lambda x: abs(x),
  81              }
  82     def __init__(self, op, arg):
  83         self._op = op
  84         self._arg = mkf(arg)
  85     def __str__(self):
  86         return "%s(%s)" % (self._op, self._arg)
  87     def __repr__(self):
  88         return "%s(%s)" % (self._op, self._arg)
  89     def eval(self):
  90         return self.opmap[self._op](self._arg.eval())
  91     def __adapt__(self,validator):
  92         return validator.adapt(self.eval())
  93
  94 class Unop2(Unop):
  95     def __init__(self, nom, op, arg):
  96         self._nom = nom
  97         self._op = op
  98         self._arg=[]
  99         for a in arg:
 100            self._arg.append(mkf(a))
 101     def __str__(self):
 102         s="%s(" % self._nom
 103         for a in self._arg:
 104            s=s+str(a)+','
 105         s=s+")"
 106         return s
 107     def __repr__(self):
 108         s="%s(" % self._nom
 109         for a in self._arg:
 110            s=s+str(a)+','
 111         s=s+")"
 112         return s
 113     def eval(self):
 114         l=[]
 115         for a in self._arg:
 116           l.append(a.eval())
 117         return self._op(*l)
 118
 119 class Constant(Formula):
 120     def __init__(self, value): self._value = value
 121     def eval(self): return self._value
 122     def __str__(self): return str(self._value)
 123     def __adapt__(self,validator):
 124         return validator.adapt(self._value)
 125
 126 class Variable(Formula):
 127     def __init__(self,name,value):
 128         self._name=name
 129         self._value=value
 130     def eval(self): return self._value
 131     def __repr__(self): return "Variable('%s',%s)" % (self._name, self._value)
 132     def __str__(self): return self._name
 133     def __adapt__(self,validator):
 134         return validator.adapt(self._value)
 135
 136 def Eval(f):
 137     if isinstance(f,Formula):
 138         f=f.eval()
 139     elif type(f) in (types.ListType, ):
 140         f=[Eval(i) for i in f]
 141     elif type(f) in (types.TupleType,):
 142         f=tuple([Eval(i) for i in f])
 143     return f
 144
 145
 146 #surcharge de la fonction cos de Numeric pour les parametres
 147 original_ncos=Numeric.cos
 148 def cos(f): return Unop('ncos', f)
 149 Unop.opmap['ncos']=lambda x: original_ncos(x)
 150 Numeric.cos=cos
 151
 152 #surcharge de la fonction sin de Numeric pour les parametres
 153 original_nsin=Numeric.sin
 154 def sin(f): return Unop('nsin', f)
 155 Unop.opmap['nsin']=lambda x: original_nsin(x)
 156 Numeric.sin=sin
 157
 158 #surcharge de la fonction array de Numeric pour les parametres
 159 original_narray=Numeric.array
 160 def array(f,*tup,**args):
 161     """array de Numeric met en défaut la mécanique des parametres
 162        on la supprime dans ce cas. Il faut que la valeur du parametre soit bien définie
 163     """
 164     return original_narray(Eval(f),*tup,**args)
 165 Numeric.array=array
 166
 167 #surcharge de la fonction sin de math pour les parametres
 168 original_sin=math.sin
 169 def sin(f): return Unop('sin', f)
 170 Unop.opmap['sin']=lambda x: original_sin(x)
 171 math.sin=sin
 172
 173 #surcharge de la fonction cos de math pour les parametres
 174 original_cos=math.cos
 175 Unop.opmap['cos']=lambda x: original_cos(x)
 176 def cos(f): return Unop('cos', f)
 177 math.cos=cos
 178
 179 #surcharge de la fonction sqrt de math pour les parametres
 180 original_sqrt=math.sqrt
 181 def sqrt(f): return Unop('sqrt', f)
 182 Unop.opmap['sqrt']=lambda x: original_sqrt(x)
 183 math.sqrt=sqrt
 184
 185 #surcharge de la fonction ceil de math pour les parametres
 186 original_ceil=math.ceil
 187 Unop.opmap['ceil']=lambda x: original_ceil(x)
 188 def ceil(f): return Unop('ceil', f)
 189 math.ceil=ceil