Hi,
I've posted a couple messages to the Haskell Cafe in the last few months.
I'm new to Haskell. But, I've set out to implement my own vectors,
matrices, complex numbers, etc.
One goal I have, is to overload operators to work with my new types. The
pursuit of this goal, has pushed me to learn a lot about the
Haskell type system. When I get stuck from time-to-time, the kind folks on
this list have pointed me in the right direction.
I'm stuck now. One thing I want to avoid is adding new multiplication
operators to handle multiplication of dissimilar types. For instance, I'd
like to be able to have an expression like k * m where k is a Double and m
is a Matrix. This doesn't work with the prelude's (*) operator because
the prelude's (*) has signature:
(*) :: (Num a) => a -> a -> a.
To get around this, I wrote my own versions of a Multiply class that
allows dissimilar types to be multiplied. You can see my Multiply class
in the module at the end of this Email.
At the bottom of the module, I've attempted to implement multiplication of
the forms:
scalar * matrix
matrix * scalar
matrix * matrix
The problem is that when I try to do matrix * matrix at the interpreter, I
get an error message from Glaskgow:
*My_matrix> m1 * m2
<interactive>:1:3:
Overlapping instances for Multiply (Matrix Double) (Matrix Double)
(Matrix c)
arising from use of `*' at <interactive>:1:3
Matching instances:
My_matrix.hs:63:0:
instance (Multiply a b c, Add c c c, Num a, Num b, Num c) =>
Multiply (Matrix a) (Matrix b) (Matrix c)
My_matrix.hs:57:0:
instance (Multiply a b c, Num a, Num b, Num c) =>
Multiply (Matrix a) b (Matrix c)
My_matrix.hs:51:0:
instance (Multiply a b c, Num a, Num b, Num c) =>
Multiply a (Matrix b) (Matrix c)
In the definition of `it': it = m1 * m2
I don't understand how m1 * m2 can match the scalar multiplication
instances. For instance, the scalar * matrix instance has signature:
instance (Multiply a b c, Num a, Num b, Num c)
=> Multiply a (Matrix b) (Matrix c) where
m1 in my expression would correspond to the 'a' type variable. But, 'a'
is constrained to be a Num. However, I never made my Matrix type an
instance of Num.
Is there a work around for this? In my first implementation, I did not
have the Num constraints in the matrix Multiply instances. I added the
Num constraints specifically, to remove the ambiguity of the overlapping
instance. Why didn't this work?
Thanks,
Jeff Harper
>> Begining of code for My_matrix.hs
------------------------------------------
{-# OPTIONS -fglasgow-exts #-}
module My_matrix where
import qualified Prelude as P
import Prelude hiding ( (*), (+), (-), negate)
default ( )
class Add a b c | a b -> c where
(+) :: a -> b -> c
class Multiply a b c | a b -> c where
(*) :: a -> b -> c
class Coerce a b where
coerce :: a -> b
infixl 7 *
infixl 6 +
instance Coerce Float Float where { coerce x = x }
instance Coerce Float Double where { coerce x = realToFrac x }
instance Coerce Double Double where { coerce x = x }
instance Add Float Float Float where { (+) x y = ( x) P.+ ( y) }
instance Add Float Double Double where { (+) x y = (coerce x) P.+ ( y) }
instance Add Double Float Double where { (+) x y = ( x) P.+ (coerce y) }
instance Add Double Double Double where { (+) x y = ( x) P.+ ( y) }
instance Multiply Float Float Float where { (*) x y = ( x) P.* ( y) }
instance Multiply Float Double Double where { (*) x y = (coerce x) P.* (
y) }
instance Multiply Double Float Double where { (*) x y = ( x) P.* (coerce
y) }
instance Multiply Double Double Double where { (*) x y = ( x) P.* ( y) }
-- Matrices are stored in a list of list. For now, I can create a
-- matrix of Float, or Double. Later, I'd like to extend this and
-- make it possible to create a matrix of other number types. For
-- instance, it might be possible to have a matrix of complex or
-- imaginary numbers.
data Matrix a = Matrix [[a]] deriving Show
-- For simplicity, the instances below omit the implementation for (*).
-- This instance of Multiply is for doing multiplication of the form
-- k * m where k is a scalar and m is a matrix.
instance (Multiply a b c, Num a, Num b, Num c) => Multiply a (Matrix b)
(Matrix c) where
(*) x y = Matrix [[]]
-- This instance of Multiply is for doing multiplication of the form
-- m * k where k is a scalar and m is a matrix.
instance (Multiply a b c, Num a, Num b, Num c) => Multiply (Matrix a) b
(Matrix c) where
(*) x y = Matrix [[]]
-- This instance of Multiply is for doing multiplication of the form
-- m1 * m2 where m1 and m2 are both matrices
instance (Multiply a b c, Add c c c, Num a, Num b, Num c) => Multiply
(Matrix a) (Matrix b) (Matrix c) where
(*) x y = Matrix [[]]
-- Some test variables to use in the interpreter
k = (3.0::Double)
m1 = Matrix [[1.0::Double]]
m2 = Matrix [[2.0::Double]]
