1 -- Glasgow Haskell 0.403 : BLAS ( Basic Linear Algebra System )
    2 -- **********************************************************************
    3 -- *                                                                    *
    4 -- * FILE NAME : vector.hs              DATE : 4-3-1991                 *
    5 -- *                                                                    *
    6 -- * CONTENTS : Vector datatype and operations implemented by using     *
    7 -- *            array type of Haskell.                                  *
    8 -- *            Vectors are index from 1 to N, where N is the dimension *
    9 -- *       of the vector, ie the number of elements in the vector. *
   10 -- **********************************************************************
   11 
   12 -- Haskell Arrays:
   13 --
   14 --      Haskell provides indexable arrays, which may be thought of as 
   15 --      functions whose domains are isomorphic to contiguous subsets of 
   16 --      the integers. Such a restricted class of functions are intended
   17 --      to be very efficiently implementable; in particular, the programmer
   18 --      has a reasonable expectation of rapid access to the components. 
   19 --      To ensure the possibility of such an implementation, arrays are 
   20 --      treated, not as general fucntions, but as data.
   21 
   22 --      Data of array type is    Array i e , where i is index type and e
   23 --      is element type.
   24 
   25 --      Index classes of Haskell arrays:
   26 --      ================================
   27 --
   28 --      For an one dimension array, its index is of Int type, Char type,etc.
   29 --      While for a two dimension array, its index is of pair type.
   30 --
   31 --      Index must be within the bound of that array. The bound of an one
   32 --      dimension array is a pair which gives the lower and upper bound
   33 --      of its index value.
   34 --
   35 --      Function ( inRange :: (a,a) -> a -> Bool )  checks if an index is
   36 --      in the range of the bound. Function ( range :: (a,a) -> [a] ) returns
   37 --      a list of all indices in this range.
   38 
   39 --      Array construction operations(functions):
   40 --      =========================================
   41 --
   42 --      array        :: (Ix a) => (a,a) -> [Assoc a b] -> Array a b
   43 --      data Assoc a b = a := b
   44 --
   45 --      (!)  :: (Ix a) => Array a b -> a -> b
   46 --      bounds  :: (Ix a) => Array a b -> (a,a)
   47 --      assocs  :: (Ix a) => (Array a b) -> [Assoc a b]
   48 --      indices :: (Ix a) => (Array a b) -> [a]
   49 --      rangesize :: (Ix a) => (a, a) -> Int
   50 --
   51 --      Array accumulating operations(functions):
   52 --      =========================================
   53 --
   54 --      accumArray :: (Ix a) => (b->c->b) -> b -> (a,a) -> [Assoc a c]
   55 --                           -> Array a b
   56 --      accumArray "accumulating function"  "initial value" 
   57 --                 "bounds" "association list"
   58 
   59 --      Array increment update operations(functions):
   60 --      =============================================
   61 --
   62 --      (//) :: (Ix a) => Array a b -> Assoc a b -> Array a b
   63 --           It takes an array and an Assoc pair and returns an array
   64 --           identical to the first argument except for the one element
   65 --           specified by the second argument.
   66 --
   67 --      accum        :: (Ix a) => (b->c->b) -> Array a b -> [Assoc a c] -> Array a b
   68 --      accum "accumulating function" "array to be updated" "association list"
   69 
   70 --      Other operations(functions):
   71 --      ============================
   72 --
   73 --      listArray :: (Ix a) => (a, a) -> [b] -> Array a b
   74 --      elems :: (Ix a) => (Array a a) -> [a]
   75 --
   76 --      amap :: (Ix a) => (b->c) -> Array a b -> Array a c
   77 --      ixmap :: (Ix a, Ix b) => (b,b) -> (b->a) -> Array a c -> Array b c
   78 
   79 
   80 module Vector(Vec, makevec, boundvec, vecsub, incrvec, updvec, maxupdvec,
   81               vecprod, displayvec) where
   82 
   83 import Array
   84 import Basics
   85 
   86 data Vec a = VEC Int (Array Int a)
   87 
   88 displayvec :: (Show a) => Vec a -> [Char]
   89 
   90 vecprod :: (Num a) => Vec a -> Vec a -> a
   91 
   92 updvec  :: Vec a -> [(Int,a)] -> Vec a
   93 
   94 maxupdvec  :: (Num a, Ord a) => Vec a -> [(Int,a)] -> Vec a
   95 
   96 incrvec :: (Num a) => Vec a -> [(Int,a)] -> Vec a
   97 
   98 vecsub  :: Vec a -> Int -> a
   99 
  100 boundvec :: Vec a -> Int
  101 
  102 makevec :: Int -> (Int -> a) -> Vec a
  103 
  104 makevec n f = VEC n (array (1,n) [ (i,f i) | i <- [1..n] ])
  105 
  106 boundvec (VEC n _) = n 
  107 
  108 vecsub (VEC n va) i = va ! i
  109 
  110 updvec (VEC n va) s =
  111   VEC n (accum f va s)
  112  where
  113   f b c = c
  114 
  115 maxupdvec (VEC n va) s = VEC n (accum max va s)
  116 
  117 incrvec (VEC n va) s = VEC n (accum (+) va s)
  118 
  119 vecprod v1 v2 = 
  120   sum [(vecsub v1 i) * (vecsub v2 i) | i <- [1..n] ]
  121  where 
  122   n = boundvec v1
  123 
  124 displayvec v =
  125         "< " ++ 
  126         concat ([(showrj 8 (vecsub v i) ) | i<- [1..n] ] ) ++ 
  127         ">\n"
  128         where
  129         n = boundvec v
  130