(<>) and (·)

use <> for general contraction, remove ×, use Alt Gr . for cdot

5 files changed, 81 insertions, 99 deletions

diff --git a/CHANGELOG b/CHANGELOG
index dea29a9..8388e5e 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -2,12 +2,12 @@
 --------
 
     * join deprecated, use vjoin
-    * dot and (<.>) deprecated, use udot or (×)
+    * dot and (<.>) deprecated, use udot or (<>)
 
     * added udot (unconjugated dot product)
-    * added (⋅) = cdot, which conjugates the first input vector
+    * added (·) = cdot, which conjugates the first input vector
     
-    * added a general multiplication operator (×)
+    * more general multiplication operator (<>)
     
     * improved build and konst
     
diff --git a/examples/multiply.hs b/examples/multiply.hs
index fbfb9d7..572961c 100644
--- a/examples/multiply.hs
+++ b/examples/multiply.hs
@@ -6,26 +6,13 @@
 --           , OverlappingInstances
            , UndecidableInstances #-}
 
-import Numeric.LinearAlgebra hiding (Contraction(..))
+import Numeric.LinearAlgebra
 
 class Scaling a b c | a b -> c where
  -- ^ 0x22C5    8901    DOT OPERATOR, scaling
  infixl 7 ⋅
  (⋅) :: a -> b -> c
 
-class Contraction a b c | a b -> c where
- -- ^ 0x00D7    215     MULTIPLICATION SIGN     ×, contraction
- infixl 7 ×
- (×) :: a -> b -> c
-
-class Outer a b c | a b -> c where
- -- ^ 0x2297    8855    CIRCLED TIMES   ⊗, outer product (not associative)
- infixl 7 ⊗
- (⊗) :: a -> b -> c
-
-
--------
-
 instance (Num t) => Scaling t t t where
     (⋅) = (*)
 
@@ -42,37 +29,49 @@ instance Container Vector t => Scaling (Matrix t) t (Matrix t) where
     (⋅) = flip scale
 
 
-instance Product t => Contraction (Vector t) (Vector t) t where
+class Mul a b c | a b -> c, a c -> b, b c -> a where
+ -- ^ 0x00D7    215     MULTIPLICATION SIGN     ×, contraction
+ infixl 7 ×
+ (×) :: a -> b -> c
+
+
+-------
+
+
+
+instance Product t => Mul (Vector t) (Vector t) t where
     (×) = udot
 
-instance Product t => Contraction (Matrix t) (Vector t) (Vector t) where
+instance Product t => Mul (Matrix t) (Vector t) (Vector t) where
     (×) = mXv
 
-instance Product t => Contraction (Vector t) (Matrix t) (Vector t) where
+instance Product t => Mul (Vector t) (Matrix t) (Vector t) where
     (×) = vXm
 
-instance Product t => Contraction (Matrix t) (Matrix t) (Matrix t) where
+instance Product t => Mul (Matrix t) (Matrix t) (Matrix t) where
     (×) = mXm
 
 
 --instance Scaling a b c => Contraction a b c where
 --    (×) = (⋅)
 
------
-
-instance Product t => Outer (Vector t) (Vector t) (Matrix t) where
-    (⊗) = outer
+--------------------------------------------------------------------------------
 
-instance Product t => Outer (Vector t) (Matrix t) (Matrix t) where
-    v ⊗ m = kronecker (asColumn v) m
+class Outer a
+  where
+    infixl 7 ⊗
+    -- | unicode 0x2297 8855 CIRCLED TIMES      ⊗
+    --
+    -- vector outer product and matrix Kronecker product
+    (⊗) :: Product t => a t -> a t -> Matrix t
 
-instance Product t => Outer (Matrix t) (Vector t) (Matrix t) where
-    m ⊗ v = kronecker m (asRow v)
+instance Outer Vector where
+    (⊗) = outer
 
-instance Product t => Outer (Matrix t) (Matrix t) (Matrix t) where
+instance Outer Matrix where
     (⊗) = kronecker
 
------
+--------------------------------------------------------------------------------
 
 
 v = 3 |> [1..] :: Vector Double
@@ -83,18 +82,23 @@ s = 3 :: Double
 
 a = s ⋅ v × m × m × v ⋅ s
 
-b = (v ⊗ m) ⊗ (v ⊗ m)
+--b = (v ⊗ m) ⊗ (v ⊗ m)
 
-c = v ⊗ m ⊗ v ⊗ m
+--c = v ⊗ m ⊗ v ⊗ m
 
 d = s ⋅ (3 |> [10,20..] :: Vector Double)
 
+u = fromList [3,0,5]
+w = konst 1 (2,3) :: Matrix Double
+
 main = do
     print $ (scale s v <> m) `udot` v
     print $ scale s v `udot` (m <> v)
     print $ s * ((v <> m) `udot` v)
     print $ s ⋅ v × m × v
     print a
-    print (b == c)
+--    print (b == c)
     print d
+    print $ asColumn u ⊗ w
+    print $ w ⊗ asColumn u
 
diff --git a/hmatrix.cabal b/hmatrix.cabal
index e9107f3..127f359 100644
--- a/hmatrix.cabal
+++ b/hmatrix.cabal
@@ -20,6 +20,9 @@ Description:        Purely functional interface to basic linear algebra
                     - "Numeric.LinearAlgebra.Algorithms": matrix computations
                     .
                     - "Numeric.LinearAlgebra": everything + instances of standard Haskell numeric classes
+                    .
+                    - "Numeric.LinearAlgebra.Util": additional functions
+                    
 Category:           Math
 tested-with:        GHC ==7.8
 
diff --git a/lib/Numeric/Container.hs b/lib/Numeric/Container.hs
index aac8c10..a612aa1 100644
--- a/lib/Numeric/Container.hs
+++ b/lib/Numeric/Container.hs
@@ -38,7 +38,7 @@ module Numeric.Container (
     Product(..),
     Contraction(..),
     optimiseMult,
-    mXm,mXv,vXm,Mul(..),LSDiv(..), cdot, (⋅), dot, (<.>),
+    mXm,mXv,vXm,LSDiv(..), cdot, (·), dot, (<.>),
     outer, kronecker,
     -- * Random numbers
     RandDist(..),
@@ -55,7 +55,7 @@ module Numeric.Container (
 
     IndexOf,
     module Data.Complex,
-    -- * Input / Output
+    -- * IO
     dispf, disps, dispcf, vecdisp, latexFormat, format,
     loadMatrix, saveMatrix, fromFile, fileDimensions,
     readMatrix,
@@ -101,19 +101,23 @@ cdot u v = udot (conj u) v
 
 --------------------------------------------------------
 
-class Mul a b c | a b -> c where
- infixl 7 <>
- -- | Matrix-matrix, matrix-vector, and vector-matrix products.
- (<>)  :: Product t => a t -> b t -> c t
+class Contraction a b c | a b -> c, a c -> b, b c -> a
+  where
+    infixl 7 <>
+    -- | matrix-matrix product, matrix-vector product, unconjugated dot product
+    (<>) :: a -> b -> c
 
-instance Mul Matrix Matrix Matrix where
-    (<>) = mXm
+instance Product t => Contraction (Vector t) (Vector t) t where
+    (<>) = udot
 
-instance Mul Matrix Vector Vector where
-    (<>) m v = flatten $ m <> asColumn v
+instance Product t => Contraction (Matrix t) (Vector t) (Vector t) where
+    (<>) = mXv
 
-instance Mul Vector Matrix Vector where
-    (<>) v m = flatten $ asRow v <> m
+instance Product t => Contraction (Vector t) (Matrix t) (Vector t) where
+    (<>) = vXm
+
+instance Product t => Contraction (Matrix t) (Matrix t) (Matrix t) where
+    (<>) = mXm
 
 --------------------------------------------------------
 
@@ -130,55 +134,12 @@ instance LSDiv Matrix Matrix where
 
 --------------------------------------------------------
 
--- | Compute mean vector and covariance matrix of the rows of a matrix.
-meanCov :: Matrix Double -> (Vector Double, Matrix Double)
-meanCov x = (med,cov) where
-    r    = rows x
-    k    = 1 / fromIntegral r
-    med  = konst k r `vXm` x
-    meds = konst 1 r `outer` med
-    xc   = x `sub` meds
-    cov  = scale (recip (fromIntegral (r-1))) (trans xc `mXm` xc)
-
---------------------------------------------------------------------------------
-
--- | matrix-matrix product, matrix-vector product, unconjugated dot product, and scaling
-class Contraction a b c | a b -> c
-  where
-    -- ^ 0x00d7 multiplication sign
-    infixl 7 ×
-    (×) :: a -> b -> c
-
-instance Product t => Contraction (Vector t) (Vector t) t where
-    (×) = udot
-
-instance Product t => Contraction (Matrix t) (Vector t) (Vector t) where
-    (×) = mXv
-
-instance Product t => Contraction (Vector t) (Matrix t) (Vector t) where
-    (×) = vXm
-
-instance Product t => Contraction (Matrix t) (Matrix t) (Matrix t) where
-    (×) = mXm
-
-instance Container Vector t => Contraction t (Vector t) (Vector t) where
-    (×) = scale
-
-instance Container Vector t => Contraction (Vector t) t (Vector t) where
-    (×) = flip scale
-
-instance Container Matrix t => Contraction t (Matrix t) (Matrix t) where
-    (×) = scale
-
-instance Container Matrix t => Contraction (Matrix t) t (Matrix t) where
-    (×) = flip scale
-
---------------------------------------------------------------------------------
-
--- | dot product (0x22C5): @u ⋅ v = 'cdot' u v@
-(⋅) :: (Container Vector t, Product t) => Vector t -> Vector t -> t
-infixl 7 ⋅
-u ⋅ v = cdot u v
+-- | dot product : @u · v = 'cdot' u v@
+--
+-- unicode 0x00b7, Alt-Gr .
+(·) :: (Container Vector t, Product t) => Vector t -> Vector t -> t
+infixl 7 ·
+u · v = cdot u v
 
 --------------------------------------------------------------------------------
 
@@ -195,6 +156,8 @@ instance Container Vector e => Konst e (Int,Int) Matrix
   where
     konst = konst'
 
+--------------------------------------------------------------------------------
+
 class Build d f c e | d -> c, c -> d, f -> e, f -> d, f -> c, c e -> f, d e -> f
   where
     build :: d -> f -> c e
@@ -209,11 +172,23 @@ instance Container Matrix e => Build (Int,Int) (e -> e -> e) Matrix e
 
 --------------------------------------------------------------------------------
 
+-- | Compute mean vector and covariance matrix of the rows of a matrix.
+meanCov :: Matrix Double -> (Vector Double, Matrix Double)
+meanCov x = (med,cov) where
+    r    = rows x
+    k    = 1 / fromIntegral r
+    med  = konst k r `vXm` x
+    meds = konst 1 r `outer` med
+    xc   = x `sub` meds
+    cov  = scale (recip (fromIntegral (r-1))) (trans xc `mXm` xc)
+
+--------------------------------------------------------------------------------
+
 {-# DEPRECATED dot "use udot" #-}
 dot :: Product e => Vector e -> Vector e -> e
 dot = udot
 
-{-# DEPRECATED (<.>) "use udot or (×)" #-}
+{-# DEPRECATED (<.>) "use udot or (<>)" #-}
 infixl 7 <.>
 (<.>) :: Product e => Vector e -> Vector e -> e
 (<.>) = udot
diff --git a/packages/tests/src/Numeric/LinearAlgebra/Tests/Instances.hs b/packages/tests/src/Numeric/LinearAlgebra/Tests/Instances.hs
index 647a06c..30bf690 100644
--- a/packages/tests/src/Numeric/LinearAlgebra/Tests/Instances.hs
+++ b/packages/tests/src/Numeric/LinearAlgebra/Tests/Instances.hs
@@ -153,7 +153,7 @@ instance (ArbitraryField a) => Arbitrary (WC a) where
             n = min r c
         sv' <- replicateM n (choose (1,100))
         let s = diagRect 0 (fromList sv') r c
-        return $ WC (u <> real s <> trans v)
+        return $ WC (u `mXm` real s `mXm` trans v)
 
 #if MIN_VERSION_QuickCheck(2,0,0)
 #else
@@ -170,7 +170,7 @@ instance (ArbitraryField a) => Arbitrary (SqWC a) where
             n = rows m
         sv' <- replicateM n (choose (1,100))
         let s = diag (fromList sv')
-        return $ SqWC (u <> real s <> trans v)
+        return $ SqWC (u `mXm` real s `mXm` trans v)
 
 #if MIN_VERSION_QuickCheck(2,0,0)
 #else
@@ -188,7 +188,7 @@ instance (ArbitraryField a, Num (Vector a))
             n = rows m
         l <- replicateM n (choose (0,100))
         let s = diag (fromList l)
-            p = v <> real s <> ctrans v
+            p = v `mXm` real s `mXm` ctrans v
         return $ PosDef (0.5 * p + 0.5 * ctrans p)
 
 #if MIN_VERSION_QuickCheck(2,0,0)