On 11/28/06, Bulat Ziganshin wrote:

Hello Slavomir,

Tuesday, November 28, 2006, 3:46:13 PM, you wrote:

...

Last question: Does haskell have something like C++ templates? For example, some time in the future I may need types like int2, short3, etc., that behave just like float2, float3, but use different types for their components. I really, really wouldn't like to copy-paste the definitions of floatn and manually change their types to intn respectfully.

yes, it's named parameterized types:

data Vec2 a = Vec2 !a !a

instance (Num a) => Num (Vec2 a) where (Vec2 a1 a2) + (Vec2 b1 b2) = Vec2 (a1+b1) (a2+b2) ....

type Float2 = Vec2 Float

I wasn't aware of parameterized types, they are sweet. Thank you very much. What about my other questions? Do you have any suggestions? I know that this is very library specific. All I am asking is for some Haskell common sense. What would you do, if you were writing this kind of library? Cheers. -- Slavomir Kaslev

Slavomir Kaslev wrote:

I have to define a couple of float2, float3, float4 Cg, HLSL style vectors in Haskell. At first I was tempted to make them instances of Num, Floating, RealFrac, etc. but some of the functions defined in those classes have no sense for vectors.

I'd suggest that this implies that these classes are not suitable for Vectors.

One such example is signum from class Num.

There are several workarounds for this. One may come up with some meaning for vectors of such functions, for example:

instance Num Float3 where ..... signum a | a == Float3 0 0 0 = 0 | otherwise = 1

This looks a bit unnatural. Also, testing equality of Floats is not generally recommended.

[snip] I know that I can scrap all those Num, Floating, RealFrac, etc. classes and define class Vector from scratch, but I really don't want to come up and use different names for +, -, etc. that will bloat the code.

While it may be tempting to want to use symbolic operators like + and -, these quickly become very confusing when more distinctions need to be made (eg between cross product, dot product, and scaling, or between transforming a position versus transforming a direction) so I'd argue that for readability descriptive names are better than symbols: class Num a => Vector v a where plus :: v a -> v a -> v a minus :: v a -> v a -> v a cross :: v a -> v a -> v a dot :: v a -> v a -> a scale :: a -> v a -> v a magSquared :: v a -> a class Num a => Transform mat vec a where transformPosition :: mat a -> vec a -> vec a transformDirection :: mat a -> vec a -> vec a instance Num a => Transform Mat44 Vec4 a where -- ... If you're doing matrix transformations, you might also like to consider using separate PositionN and DirectionN types instead of VecN to make use of the type system to catch some math bugs but I haven't looked into this myself yet so I don't know whether this would be practical or not. Best regards, Brian. -- http://www.metamilk.com

On Tue, 28 Nov 2006, Brian Hulley wrote:

While it may be tempting to want to use symbolic operators like + and -, these quickly become very confusing when more distinctions need to be made (eg between cross product, dot product, and scaling, or between transforming a position versus transforming a direction) so I'd argue that for readability descriptive names are better than symbols:

class Num a => Vector v a where plus :: v a -> v a -> v a minus :: v a -> v a -> v a cross :: v a -> v a -> v a dot :: v a -> v a -> a scale :: a -> v a -> v a magSquared :: v a -> a

I'm currently even thinking about an alternative of the multi-parameter class Vector that is Haskell 98. The problem with the multi-parameter type class is, that you cannot define instances where 'a' is a complex number type, say Num a => Vector [Complex a] (Complex a)

It is possible of course but your definition doesn't correspond to any operation in the usual vector algebra. By the way how do you define (*)? Isn't it 3D vector multiplication? Krasimir On 11/29/06, Slavomir Kaslev wrote:

You mean signum = normalize? What do you think of my comments here:

...

After giving some thought on signum, I got to the point, that signum should be defined so that abs x * signum x = x holds. So it can be defined as signum (Vec2 x y) = Vec 2 (signum x) (signum y).

...

It turns out that all the functions in Num, Floating, etc. classes can be given meaningful definitions for vectors in this pattern. That is f (Vecn x1 x2 .. xn) = Vecn (f x1) ... (f xn). And all expected laws just work. One can think of that like the way SIMD processor works, it does the same operations as on floats but on four floats at parallel.

I think this is the way to define vector instances for Num, Floating, etc. For vector specific operations, such as normalize, len, dot, cross, etc. are declared in class Vector.

-- Slavomir Kaslev

Slavomir Kaslev writes:

On 11/29/06, Krasimir Angelov wrote:

...

It is possible of course but your definition doesn't correspond to any operation in the usual vector algebra. By the way how do you define (*)? Isn't it 3D vector multiplication?

(*) is per component multiplication, as it is in Cg/HLSL. For vector to vector, vector to matrix, etc. multiplication there is mul.

Cheers.

Hello, I have defined a class for vectors that I think can be interesting for you, althougt I do NOT use the Num class. I really like infix operators for vectors but using + * ... and so gets things confusing for me and have bad interaction with scalars. So I define infix operators <+> <-> <*> ... with an "<" or ">" on the side when a vector is spected, so (*>) is a scalar multiplication of a vector, (<*>) multiplication of two vectors, <.> dot product .... The class is named Vector, and I don't make distinction bewteen vectors and points. A minimalist instance of Vector class, can be defined by only two method functions, reduceComponent and combineComponent. reduceComponent is like a fold functions over the components of a vector, so for example the max component of a vector is defined as "maxComponent vec = reduceComponent (max) vec". combineComponent apply a function to every pair of components of two vectors, so an addition of two vectors is defined as "(<+>) a b = combineComponent (+) a b". Note that for Vector3 and Vector2 datatypes I define instances with reduceComponent and combineComponent, but for performance reasons I override default implementations of the most used operations. Here is the code, I hope that it makes clear what I have tried to explain. Please, feel free to criticize the code Fco. Javier Loma fjloma <at> andaluciajunta.es --begin code {-# OPTIONS_GHC -fglasgow-exts -fbang-patterns #-} module Data.Vectors where -- Use a Double for each component type VReal = Double --data Dimension = X | Y | Z | W deriving (Show, Read, Eq) data Vector3 = V3 !VReal !VReal !VReal deriving (Show, Read, Eq) class (Floating r, Ord r) => (Vector r) v | v -> r where -- minimun definition by reduceComponent and combineComponent reduceComponent :: (r -> r -> r) -> v -> r combineComponent :: (r -> r -> r) -> v -> v -> v (<+>) :: v -> v -> v (<+>) a b = combineComponent (+) a b (<->) :: v -> v -> v (<->) a b = combineComponent (-) a b (<*>) :: v -> v -> v (<*>) a b = combineComponent (*) a b () :: v -> v -> v () a b = combineComponent (/) a b (<.>) :: v -> v -> r a <.> b = reduceComponent (+) (combineComponent (*) a b) (<*) :: v -> r -> v a <* k = combineComponent (\x -> \_ -> x*k) a a ( r -> v a \_ -> x/k) a a (*>) :: r -> v -> v k *> vec = vec <* k normalize :: v -> v normalize vec = vec r vlength vec = sqrt(vec <.> vec) maxComponent :: v -> r maxComponent vec = reduceComponent (max) vec minComponent :: v -> r minComponent vec = reduceComponent (min) vec middle :: v -> v -> v middle a b = (a <+> b) v -> r distance a b = sqrt (distance2 a b) distance2 :: v -> v -> r distance2 a b = r <.> r where r = b <-> a instance Vector VReal Vector3 where reduceComponent f (V3 a1 a2 a3) = (f a1 (f a2 a3)) combineComponent f (V3 a1 a2 a3) (V3 b1 b2 b3) = V3 (f a1 b1) (f a2 b2) (f a3 b3) (!V3 a1 a2 a3) <+> (!V3 b1 b2 b3) = V3 (a1 + b1) (a2 + b2) (a3 + b3) (!V3 a1 a2 a3) <-> (!V3 b1 b2 b3) = V3 (a1 - b1) (a2 - b2) (a3 - b3) (!V3 a1 a2 a3) <*> (!V3 b1 b2 b3) = V3 (a1 * b1) (a2 * b2) (a3 * b3) (!V3 a1 a2 a3) (!V3 b1 b2 b3) = V3 (a1 / b1) (a2 / b2) (a3 / b3) (!V3 a1 a2 a3) <.> (!V3 b1 b2 b3) = a1 * b1 + a2 * b2 + a3 * b3 (!V3 a1 a2 a3) <* k = V3 (a1 * k) (a2 * k) (a3 * k) (!V3 a1 a2 a3) (V2 b1 b2 ) = a1 * b1 + a2 * b2 (V2 a1 a2 ) <* k = V2 (a1 * k) (a2 * k) (V2 a1 a2 )