home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / vector.py < prev   
Encoding:
Python Source  |  2005-11-09  |  7.2 KB  |  392 lines
  1. #!/usr/bin/env python
  2. # 
  3. # a python vector class
  4. # A. Pletzer 5 Jan 00/11 April 2002
  5. #
  6. import math
  7.  
  8. """
  9. A list based vector class that supports elementwise mathematical operations
  10.  
  11. In this version, the vector call inherits from list; this 
  12. requires Python 2.2 or later.
  13. """
  14.  
  15. class vector(list):
  16.     """
  17.         A list based vector class
  18.     """
  19.     # no c'tor
  20.  
  21.     def __getslice__(self, i, j):
  22.         try:
  23.             # use the list __getslice__ method and convert
  24.             # result to vector
  25.             return vector(super(vector, self).__getslice__(i,j))
  26.         except:
  27.             raise TypeError, 'vector::FAILURE in __getslice__'
  28.         
  29.     def __add__(self, other):
  30.         return vector(map(lambda x,y: x+y, self, other))
  31.  
  32.     def __neg__(self):
  33.         return vector(map(lambda x: -x, self))
  34.     
  35.     def __sub__(self, other):
  36.         return vector(map(lambda x,y: x-y, self, other))
  37.  
  38.     def __mul__(self, other):
  39.         """
  40.         Element by element multiplication
  41.         """
  42.         try:
  43.             return vector(map(lambda x,y: x*y, self,other))
  44.         except:
  45.             # other is a const
  46.             return vector(map(lambda x: x*other, self))
  47.  
  48.  
  49.     def __rmul__(self, other):
  50.         return (self*other)
  51.  
  52.  
  53.     def __div__(self, other):
  54.         """
  55.         Element by element division.
  56.         """
  57.         try:
  58.             return vector(map(lambda x,y: x/y, self, other))
  59.         except:
  60.             return vector(map(lambda x: x/other, self))
  61.  
  62.     def __rdiv__(self, other):
  63.         """
  64.         The same as __div__
  65.         """
  66.         try:
  67.             return vector(map(lambda x,y: x/y, other, self))
  68.         except:
  69.             # other is a const
  70.             return vector(map(lambda x: other/x, self))
  71.  
  72.         def size(self): return len(self)
  73.  
  74.     def conjugate(self):
  75.         return vector(map(lambda x: x.conjugate(), self))
  76.  
  77.         def ReIm(self):
  78.         """
  79.         Return the real and imaginary parts
  80.         """
  81.         return [
  82.             vector(map(lambda x: x.real, self)),
  83.             vector(map(lambda x: x.imag, self)),
  84.             ]
  85.     
  86.         def AbsArg(self):
  87.         """
  88.         Return modulus and phase parts
  89.         """
  90.         return [
  91.             vector(map(lambda x: abs(x), self)),
  92.             vector(map(lambda x: math.atan2(x.imag,x.real), self)),
  93.             ]
  94.  
  95.  
  96.     def out(self):
  97.         """
  98.         Prints out the vector.
  99.         """
  100.         print self
  101.  
  102. ###############################################################################
  103.  
  104.  
  105. def isVector(x):
  106.     """
  107.     Determines if the argument is a vector class object.
  108.     """
  109.     return hasattr(x,'__class__') and x.__class__ is vector
  110.  
  111. def zeros(n):
  112.     """
  113.     Returns a zero vector of length n.
  114.     """
  115.     return vector(map(lambda x: 0., range(n)))
  116.  
  117. def ones(n):
  118.     """
  119.     Returns a vector of length n with all ones.
  120.     """
  121.     return vector(map(lambda x: 1., range(n)))
  122.  
  123. def random(n, lmin=0.0, lmax=1.0):
  124.     """
  125.     Returns a random vector of length n.
  126.     """
  127.     import whrandom
  128.     new = vector([])
  129.     gen = whrandom.whrandom()
  130.     dl = lmax-lmin
  131.     return vector(map(lambda x: dl*gen.random(),
  132.                range(n)))
  133.     
  134. def dot(a, b):
  135.     """
  136.     dot product of two vectors.
  137.     """
  138.     try:
  139.     return reduce(lambda x, y: x+y, a*b, 0.)
  140.     except:
  141.     raise TypeError, 'vector::FAILURE in dot'
  142.     
  143.  
  144. def norm(a):
  145.     """
  146.     Computes the norm of vector a.
  147.     """
  148.     try:
  149.     return math.sqrt(abs(dot(a,a)))
  150.     except:
  151.     raise TypeError, 'vector::FAILURE in norm'
  152.  
  153. def sum(a):
  154.     """
  155.     Returns the sum of the elements of a.
  156.     """
  157.     try:
  158.     return reduce(lambda x, y: x+y, a, 0)
  159.     except:
  160.     raise TypeError, 'vector::FAILURE in sum'
  161.  
  162. # elementwise operations
  163.     
  164. def log10(a):
  165.     """
  166.     log10 of each element of a.
  167.     """
  168.     try:
  169.     return vector(map(math.log10, a))
  170.     except:
  171.     raise TypeError, 'vector::FAILURE in log10'
  172.  
  173. def log(a):
  174.     """
  175.     log of each element of a.
  176.     """
  177.     try:
  178.     return vector(map(math.log, a))
  179.     except:
  180.     raise TypeError, 'vector::FAILURE in log'
  181.         
  182. def exp(a):
  183.     """
  184.     Elementwise exponential.
  185.     """
  186.     try:
  187.     return vector(map(math.exp, a))
  188.     except:
  189.     raise TypeError, 'vector::FAILURE in exp'
  190.  
  191. def sin(a):
  192.     """
  193.     Elementwise sine.
  194.     """
  195.     try:
  196.     return vector(map(math.sin, a))
  197.     except:
  198.     raise TypeError, 'vector::FAILURE in sin'
  199.         
  200. def tan(a):
  201.     """
  202.     Elementwise tangent.
  203.     """
  204.     try:
  205.     return vector(map(math.tan, a))
  206.     except:
  207.     raise TypeError, 'vector::FAILURE in tan'
  208.         
  209. def cos(a):
  210.     """
  211.     Elementwise cosine.
  212.     """
  213.     try:
  214.     return vector(map(math.cos, a))
  215.     except:
  216.     raise TypeError, 'vector::FAILURE in cos'
  217.  
  218. def asin(a):
  219.     """
  220.     Elementwise inverse sine.
  221.     """
  222.     try:
  223.     return vector(map(math.asin, a))
  224.     except:
  225.     raise TypeError, 'vector::FAILURE in asin'
  226.  
  227. def atan(a):
  228.     """
  229.     Elementwise inverse tangent.
  230.     """    
  231.     try:
  232.     return vector(map(math.atan, a))
  233.     except:
  234.     raise TypeError, 'vector::FAILURE in atan'
  235.  
  236. def acos(a):
  237.     """
  238.     Elementwise inverse cosine.
  239.     """
  240.     try:
  241.     return vector(map(math.acos, a))
  242.     except:
  243.     raise TypeError, 'vector::FAILURE in acos'
  244.  
  245. def sqrt(a):
  246.     """
  247.     Elementwise sqrt.
  248.     """
  249.     try:
  250.     return vector(map(math.sqrt, a))
  251.     except:
  252.     raise TypeError, 'vector::FAILURE in sqrt'
  253.  
  254. def sinh(a):
  255.     """
  256.     Elementwise hyperbolic sine.
  257.     """
  258.     try:
  259.     return vector(map(math.sinh, a))
  260.     except:
  261.     raise TypeError, 'vector::FAILURE in sinh'
  262.  
  263. def tanh(a):
  264.     """
  265.     Elementwise hyperbolic tangent.
  266.     """
  267.     try:
  268.     return vector(map(math.tanh, a))
  269.     except:
  270.     raise TypeError, 'vector::FAILURE in tanh'
  271.  
  272. def cosh(a):
  273.     """
  274.     Elementwise hyperbolic cosine.
  275.     """
  276.     try:
  277.     return vector(map(math.cosh, a))
  278.     except:
  279.     raise TypeError, 'vector::FAILURE in cosh'
  280.  
  281.  
  282. def pow(a,b):
  283.     """
  284.     Takes the elements of a and raises them to the b-th power
  285.     """
  286.     try:
  287.         return vector(map(lambda x: x**b, a))
  288.     except:
  289.         try:
  290.         return vector(map(lambda x,y: x**y, a, b))
  291.     except:
  292.         raise TypeError, 'vector::FAILURE in pow'
  293.     
  294. def atan2(a,b):    
  295.     """
  296.     Arc tangent
  297.     
  298.     """
  299.     try:
  300.     return vector(map(math.atan2, a, b))
  301.     except:
  302.     raise TypeError, 'vector::FAILURE in atan2'
  303.     
  304.  
  305. ###############################################################################
  306. if __name__ == "__main__":
  307.  
  308.     print 'a = zeros(4)'
  309.     a = zeros(4)
  310.  
  311.     print 'a.__doc__=',a.__doc__
  312.  
  313.     print 'a[0] = 1.0'
  314.     a[0] = 1.0
  315.  
  316.     print 'a[3] = 3.0'
  317.     a[3] = 3.0
  318.  
  319.     print 'a[0]=', a[0]
  320.     print 'a[1]=', a[1]
  321.  
  322.     print 'len(a)=',len(a)
  323.     print 'a.size()=', a.size()
  324.             
  325.     b = vector([1, 2, 3, 4])
  326.     print 'a=', a
  327.     print 'b=', b
  328.  
  329.     print 'a+b'
  330.     c = a + b
  331.     c.out()
  332.  
  333.     print '-a'
  334.     c = -a
  335.     c.out()
  336.     a.out()
  337.  
  338.     print 'a-b'
  339.     c = a - b
  340.     c.out()
  341.  
  342.     print 'a*1.2'
  343.     c = a*1.2
  344.     c.out()
  345.  
  346.  
  347.     print '1.2*a'
  348.     c = 1.2*a
  349.     c.out()
  350.     print 'a=', a
  351.  
  352.     print 'dot(a,b) = ', dot(a,b)
  353.     print 'dot(b,a) = ', dot(b,a)
  354.  
  355.     print 'a*b'
  356.     c = a*b
  357.     c.out()
  358.     
  359.     print 'a/1.2'
  360.     c = a/1.2
  361.     c.out()
  362.  
  363.     print 'a[0:2]'
  364.     c = a[0:2]
  365.     c.out()
  366.  
  367.     print 'a[2:5] = [9.0, 4.0, 5.0]'
  368.     a[2:5] = [9.0, 4.0, 5.0]
  369.     a.out()
  370.  
  371.     print 'sqrt(a)=',sqrt(a)
  372.     print 'pow(a, 2*ones(len(a)))=',pow(a, 2*ones(len(a)))
  373.     print 'pow(a, 2)=',pow(a, 2*ones(len(a)))
  374.  
  375.     print 'ones(10)'
  376.     c = ones(10)
  377.     c.out()
  378.  
  379.     print 'zeros(10)'
  380.     c = zeros(10)
  381.     c.out()    
  382.  
  383.     print 'del a'
  384.     del a
  385.  
  386.     try:
  387.         a = random(11, 0., 2.)
  388.         a.out()
  389.  
  390.     except: pass
  391.  
  392.