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 __add__(self, other): return Binop('+', self, other)
  34     def __radd__(self, other): return Binop('+', other, self)
  35     def __sub__(self, other): return Binop('-', self, other)
  36     def __rsub__(self, other): return Binop('-', other, self)
  37     def __mul__(self, other): return Binop('*', self, other)
  38     def __rmul__(self, other): return Binop('*', other, self)
  39     def __div__(self, other): return Binop('/', self, other)
  40     def __truediv__(self, other): return Binop('/', self, other)
  41     def __rdiv__(self, other): return Binop('/', other, self)
  42     def __pow__(self, other): return Binop('**', self, other)
  43     def __rpow__(self, other): return Binop('**', other, self)
  44     def __getitem__(self,i):return Binop('[]',self,i)
  45
  46 class Binop(Formula):
  47     opmap = { '+': lambda a, b: a + b,
  48               '*': 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             }
  54     def __init__(self, op, value1, value2):
  55         self.op = op
  56         self.values = mkf(value1), mkf(value2)
  57     def __str__(self):
  58         if self.op == '[]':
  59            return "%s[%s]" % (self.values[0], self.values[1])
  60         else:
  61            return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
  62     def __repr__(self):
  63         if self.op == '[]':
  64            return "%s[%s]" % (self.values[0], self.values[1])
  65         else:
  66            return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
  67     def eval(self):
  68         result= self.opmap[self.op](self.values[0].eval(),
  69                                    self.values[1].eval())
  70         while isinstance(result,Formula):
  71               result=result.eval()
  72         return result
  73     def __adapt__(self,validator):
  74         return validator.adapt(self.eval())
  75
  76
  77 class Unop(Formula):
  78     opmap = { '-': lambda x: -x,
  79              }
  80     def __init__(self, op, arg):
  81         self._op = op
  82         self._arg = mkf(arg)
  83     def __str__(self):
  84         return "%s(%s)" % (self._op, self._arg)
  85     def __repr__(self):
  86         return "%s(%s)" % (self._op, self._arg)
  87     def eval(self):
  88         return self.opmap[self._op](self._arg.eval())
  89     def __adapt__(self,validator):
  90         return validator.adapt(self.eval())
  91
  92 class Unop2(Unop):
  93     def __init__(self, nom, op, arg):
  94         self._nom = nom
  95         self._op = op
  96         self._arg=[]
  97         for a in arg:
  98            self._arg.append(mkf(a))
  99     def __str__(self):
 100         s="%s(" % self._nom
 101         for a in self._arg:
 102            s=s+str(a)+','
 103         s=s+")"
 104         return s
 105     def __repr__(self):
 106         s="%s(" % self._nom
 107         for a in self._arg:
 108            s=s+str(a)+','
 109         s=s+")"
 110         return s
 111     def eval(self):
 112         l=[]
 113         for a in self._arg:
 114           l.append(a.eval())
 115         return self._op(*l)
 116
 117 class Constant(Formula):
 118     def __init__(self, value): self._value = value
 119     def eval(self): return self._value
 120     def __str__(self): return str(self._value)
 121     def __adapt__(self,validator):
 122         return validator.adapt(self._value)
 123
 124 class Variable(Formula):
 125     def __init__(self,name,value):
 126         self._name=name
 127         self._value=value
 128     def eval(self): return self._value
 129     def __repr__(self): return "Variable('%s',%s)" % (self._name, self._value)
 130     def __str__(self): return self._name
 131     def __adapt__(self,validator):
 132         return validator.adapt(self._value)
 133
 134 def Eval(f):
 135     if isinstance(f,Formula):
 136         f=f.eval()
 137     elif type(f) in (types.ListType, ):
 138         f=[Eval(i) for i in f]
 139     elif type(f) in (types.TupleType,):
 140         f=tuple([Eval(i) for i in f])
 141     return f
 142
 143
 144 #surcharge de la fonction cos de Numeric pour les parametres
 145 original_ncos=Numeric.cos
 146 def cos(f): return Unop('ncos', f)
 147 Unop.opmap['ncos']=lambda x: original_ncos(x)
 148 Numeric.cos=cos
 149
 150 #surcharge de la fonction sin de Numeric pour les parametres
 151 original_nsin=Numeric.sin
 152 def sin(f): return Unop('nsin', f)
 153 Unop.opmap['nsin']=lambda x: original_nsin(x)
 154 Numeric.sin=sin
 155
 156 #surcharge de la fonction array de Numeric pour les parametres
 157 original_narray=Numeric.array
 158 def array(f,*tup,**args):
 159     """array de Numeric met en défaut la mécanique des parametres
 160        on la supprime dans ce cas. Il faut que la valeur du parametre soit bien définie
 161     """
 162     return original_narray(Eval(f),*tup,**args)
 163 Numeric.array=array
 164
 165 #surcharge de la fonction sin de math pour les parametres
 166 original_sin=math.sin
 167 def sin(f): return Unop('sin', f)
 168 Unop.opmap['sin']=lambda x: original_sin(x)
 169 math.sin=sin
 170
 171 #surcharge de la fonction cos de math pour les parametres
 172 original_cos=math.cos
 173 Unop.opmap['cos']=lambda x: original_cos(x)
 174 def cos(f): return Unop('cos', f)
 175 math.cos=cos
 176
 177 #surcharge de la fonction sqrt de math pour les parametres
 178 original_sqrt=math.sqrt
 179 def sqrt(f): return Unop('sqrt', f)
 180 Unop.opmap['sqrt']=lambda x: original_sqrt(x)
 181 math.sqrt=sqrt
 182
 183 #surcharge de la fonction ceil de math pour les parametres
 184 original_ceil=math.ceil
 185 Unop.opmap['ceil']=lambda x: original_ceil(x)
 186 def ceil(f): return Unop('ceil', f)
 187 math.ceil=ceil