4 files changed, 313 insertions, 185 deletions

diff --git a/Spear/Math/Vector/Vector.hs b/Spear/Math/Vector/Vector.hs
index 35b04e2..e7f6d53 100644
--- a/Spear/Math/Vector/Vector.hs
+++ b/Spear/Math/Vector/Vector.hs
@@ -1,43 +1,50 @@
-module Spear.Math.Vector.Vector

-where

-

-class (Fractional a, Ord a) => Vector a where

-      -- | Create a vector from the given list.

-      fromList :: [Float] -> a

-

-      -- | Return the vector's x coordinate.

-      x :: a -> Float

-      x _ = 0

-

-      -- | Return the vector's y coordinate.

-      y :: a -> Float

-      y _ = 0

-

-      -- | Return the vector's z coordinate.

-      z :: a -> Float

-      z _ = 0

-

-      -- | Return the vector's w coordinate.

-      w :: a -> Float

-      w _ = 0

-

-      -- | Return the vector's ith coordinate.

-      (!) :: a -> Int -> Float

-

-      -- | Compute the given vectors' dot product.

-      dot :: a -> a -> Float

-

-      -- | Compute the given vector's squared norm.

-      normSq :: a -> Float

-

-      -- | Compute the given vector's norm.

-      norm :: a -> Float

-

-      -- | Multiply the given vector with the given scalar.

-      scale :: Float -> a -> a

-

-      -- | Negate the given vector.

-      neg :: a -> a

-

-      -- | Normalise the given vector.

-      normalise :: a -> a

+{-# LANGUAGE FlexibleContexts #-}
+
+module Spear.Math.Vector.Vector where
+
+import           Spear.Math.Algebra
+
+
+class
+  ( Addition v v
+  , Subtraction v v
+  , Product v v v
+  , Product v Float v  -- Scalar product.
+  , Product Float v v) -- Scalar product.
+  => Vector v where
+      -- | Create a vector from the given list.
+      fromList :: [Float] -> v
+
+      -- | Get the vector's x coordinate.
+      x :: v -> Float
+      x _ = 0
+
+      -- | Get the vector's y coordinate.
+      y :: v -> Float
+      y _ = 0
+
+      -- | Get the vector's z coordinate.
+      z :: v -> Float
+      z _ = 0
+
+      -- | Get the vector's w coordinate.
+      w :: v -> Float
+      w _ = 0
+
+      -- | Get the vector's ith coordinate.
+      (!) :: v -> Int -> Float
+
+      -- | Compute the given vectors' dot product.
+      dot :: v -> v -> Float
+
+      -- | Compute the given vector's squared norm.
+      normSq :: v -> Float
+
+      -- | Compute the given vector's norm.
+      norm :: v -> Float
+
+      -- | Negate the given vector.
+      neg :: v -> v
+
+      -- | Normalise the given vector.
+      normalise :: v -> v
diff --git a/Spear/Math/Vector/Vector2.hs b/Spear/Math/Vector/Vector2.hs
index 5bbb632..1ede3a9 100644
--- a/Spear/Math/Vector/Vector2.hs
+++ b/Spear/Math/Vector/Vector2.hs
@@ -1,3 +1,7 @@
+{-# LANGUAGE MultiParamTypeClasses #-}

+{-# LANGUAGE NoImplicitPrelude     #-}

+{-# LANGUAGE TypeFamilies          #-}

+

 module Spear.Math.Vector.Vector2

 (

     Vector2(..)

@@ -14,30 +18,72 @@ module Spear.Math.Vector.Vector2
 )

 where

 

+import           Spear.Math.Algebra

 import           Spear.Math.Vector.Vector

+import           Spear.Prelude

 

 import           Foreign.C.Types          (CFloat)

 import           Foreign.Storable

+import qualified Prelude                  as P

+

 

-type Right2 = Vector2

-type Up2 = Vector2

+type Right2    = Vector2

+type Up2       = Vector2

 type Position2 = Vector2

 

+

 -- | Represents a vector in 2D.

 data Vector2 = Vector2 {-# UNPACK #-} !Float {-# UNPACK #-} !Float deriving (Eq, Show)

 

 

-instance Num Vector2 where

+instance Addition Vector2 Vector2 where

+    {-# INLINABLE (+) #-}

     Vector2 ax ay + Vector2 bx by = Vector2 (ax + bx) (ay + by)

+

+

+instance Subtraction Vector2 Vector2 where

+    {-# INLINABLE (-) #-}

     Vector2 ax ay - Vector2 bx by = Vector2 (ax - bx) (ay - by)

+

+

+instance Product Vector2 Vector2 Vector2 where

+    {-# INLINABLE (*) #-}

     Vector2 ax ay * Vector2 bx by = Vector2 (ax * bx) (ay * by)

+

+

+instance Quotient Vector2 Vector2 where

+    {-# INLINABLE (/) #-}

+    Vector2 ax ay / Vector2 bx by = Vector2 (ax / bx) (ay / by)

+

+

+-- Scalar product.

+instance Product Vector2 Float Vector2 where

+    {-# INLINABLE (*) #-}

+    (Vector2 x y) * s = Vector2 (s * x) (s * y)

+

+

+instance Product Float Vector2 Vector2 where

+    {-# INLINABLE (*) #-}

+    s * (Vector2 x y) = Vector2 (s * x) (s * y)

+

+

+-- Scalar division.

+instance Quotient Vector2 Float where

+    {-# INLINABLE (/) #-}

+    (Vector2 x y) / s = Vector2 (x / s) (y / s)

+

+

+instance Num Vector2 where

+    (+) = add

+    (-) = sub

+    (*) = mul

     abs (Vector2 ax ay) = Vector2 (abs ax) (abs ay)

     signum (Vector2 ax ay) = Vector2 (signum ax) (signum ay)

     fromInteger i = Vector2 i' i' where i' = fromInteger i

 

 

 instance Fractional Vector2 where

-    Vector2 ax ay / Vector2 bx by = Vector2 (ax / bx) (ay / by)

+    (/) = Spear.Math.Algebra.div

     fromRational r = Vector2 r' r' where r' = fromRational r

 

 

@@ -46,52 +92,49 @@ instance Ord Vector2 where
     Vector2 ax ay >= Vector2 bx by =  (ax >= bx) || (ax == bx && ay >= by)

     Vector2 ax ay < Vector2 bx by  =  (ax < bx)  || (ax == bx && ay < by)

     Vector2 ax ay > Vector2 bx by  =  (ax > bx)  || (ax == bx && ay > by)

-    max (Vector2 ax ay) (Vector2 bx by) = Vector2 (Prelude.max ax bx) (Prelude.max ay by)

-    min (Vector2 ax ay) (Vector2 bx by) = Vector2 (Prelude.min ax bx) (Prelude.min ay by)

+    max (Vector2 ax ay) (Vector2 bx by) = Vector2 (max ax bx) (max ay by)

+    min (Vector2 ax ay) (Vector2 bx by) = Vector2 (min ax bx) (min ay by)

 

 

 instance Vector Vector2 where

-         {-# INLINABLE fromList #-}

-         fromList (ax:ay:_) = Vector2 ax ay

-

-         {-# INLINABLE x #-}

-         x (Vector2 ax _) = ax

+    {-# INLINABLE fromList #-}

+    fromList (ax:ay:_) = Vector2 ax ay

 

-         {-# INLINABLE y #-}

-         y (Vector2 _ ay) = ay

+    {-# INLINABLE x #-}

+    x (Vector2 ax _) = ax

 

-         {-# INLINABLE (!) #-}

-         (Vector2 ax _) ! 0 = ax

-         (Vector2 _ ay) ! 1 = ay

-         _              ! _ = 0

+    {-# INLINABLE y #-}

+    y (Vector2 _ ay) = ay

 

-         {-# INLINABLE dot #-}

-         Vector2 ax ay `dot` Vector2 bx by = ax*bx + ay*by

+    {-# INLINABLE (!) #-}

+    (Vector2 ax _) ! 0 = ax

+    (Vector2 _ ay) ! 1 = ay

+    _              ! _ = 0

 

-         {-# INLINABLE normSq #-}

-         normSq (Vector2 ax ay) = ax*ax + ay*ay

+    {-# INLINABLE dot #-}

+    Vector2 ax ay `dot` Vector2 bx by = ax*bx + ay*by

 

-         {-# INLINABLE norm #-}

-         norm = sqrt . normSq

+    {-# INLINABLE normSq #-}

+    normSq (Vector2 ax ay) = ax*ax + ay*ay

 

-         {-# INLINABLE scale #-}

-         scale s (Vector2 ax ay) = Vector2 (s*ax) (s*ay)

+    {-# INLINABLE norm #-}

+    norm = sqrt . normSq

 

-         {-# INLINABLE neg #-}

-         neg (Vector2 ax ay) = Vector2 (-ax) (-ay)

+    {-# INLINABLE neg #-}

+    neg (Vector2 ax ay) = Vector2 (-ax) (-ay)

 

-         {-# INLINABLE normalise #-}

-         normalise v =

-                   let n' = norm v

-                       n = if n' == 0 then 1 else n'

-                   in scale (1.0 / n) v

+    {-# INLINABLE normalise #-}

+    normalise v =

+            let n' = norm v

+                n = if n' == 0 then 1 else n'

+            in ((1.0::Float) / n) * v

 

 

 sizeFloat = sizeOf (undefined :: CFloat)

 

 

 instance Storable Vector2 where

-    sizeOf _    = 2*sizeFloat

+    sizeOf _    = (2::Int) * sizeFloat

     alignment _ = alignment (undefined :: CFloat)

 

     peek ptr = do

@@ -115,9 +158,9 @@ zero2 = Vector2 0 0
 

 -- | Create a vector from the given values.

 vec2 :: Float -> Float -> Vector2

-vec2 ax ay = Vector2 ax ay

+vec2 = Vector2

 

--- | Compute a vector perpendicular to the given one, satisfying:

+-- | Compute a perpendicular vector satisfying:

 --

 -- perp (Vector2 0 1) = Vector2 1 0

 --

diff --git a/Spear/Math/Vector/Vector3.hs b/Spear/Math/Vector/Vector3.hs
index 82deba2..9d44c8b 100644
--- a/Spear/Math/Vector/Vector3.hs
+++ b/Spear/Math/Vector/Vector3.hs
@@ -1,3 +1,7 @@
+{-# LANGUAGE MultiParamTypeClasses #-}

+{-# LANGUAGE NoImplicitPrelude     #-}

+{-# LANGUAGE TypeFamilies          #-}

+

 module Spear.Math.Vector.Vector3

 (

     Vector3(..)

@@ -5,6 +9,7 @@ module Spear.Math.Vector.Vector3
 ,   Up3

 ,   Forward3

 ,   Position3

+,   sizeVector3

     -- * Construction

 ,   unitx3

 ,   unity3

@@ -17,15 +22,17 @@ module Spear.Math.Vector.Vector3
 )

 where

 

-

+import           Spear.Math.Algebra

 import           Spear.Math.Vector.Vector

+import           Spear.Prelude

 

 import           Foreign.C.Types          (CFloat)

 import           Foreign.Storable

+import qualified Prelude                  as P

 

-type Right3 = Vector3

-type Up3 = Vector3

-type Forward3 = Vector3

+type Right3    = Vector3

+type Up3       = Vector3

+type Forward3  = Vector3

 type Position3 = Vector3

 

 

@@ -36,17 +43,58 @@ data Vector3 = Vector3
     {-# UNPACK #-} !Float

     deriving (Eq, Show)

 

-instance Num Vector3 where

+

+sizeVector3 = (3::Int) * sizeOf (undefined :: CFloat)

+

+

+instance Addition Vector3 Vector3 where

+    {-# INLINABLE (+) #-}

     Vector3 ax ay az + Vector3 bx by bz = Vector3 (ax + bx) (ay + by) (az + bz)

+

+

+instance Subtraction Vector3 Vector3 where

+    {-# INLINABLE (-) #-}

     Vector3 ax ay az - Vector3 bx by bz = Vector3 (ax - bx) (ay - by) (az - bz)

+

+

+instance Product Vector3 Vector3 Vector3 where

+    {-# INLINABLE (*) #-}

     Vector3 ax ay az * Vector3 bx by bz = Vector3 (ax * bx) (ay * by) (az * bz)

+

+

+instance Quotient Vector3 Vector3 where

+    {-# INLINABLE (/) #-}

+    Vector3 ax ay az / Vector3 bx by bz = Vector3 (ax / bx) (ay / by) (az / bz)

+

+

+-- Scalar product.

+instance Product Vector3 Float Vector3 where

+    {-# INLINABLE (*) #-}

+    (Vector3 x y z) * s = Vector3 (s * x) (s * y) (s * z)

+

+

+instance Product Float Vector3 Vector3 where

+    {-# INLINABLE (*) #-}

+    s * (Vector3 x y z) = Vector3 (s * x) (s * y) (s * z)

+

+

+-- Scalar division.

+instance Quotient Vector3 Float where

+    {-# INLINABLE (/) #-}

+    (Vector3 x y z) / s = Vector3 (x / s) (y / s) (y / s)

+

+

+instance Num Vector3 where

+    (+) = add

+    (-) = sub

+    (*) = mul

     abs (Vector3 ax ay az) = Vector3 (abs ax) (abs ay) (abs az)

     signum (Vector3 ax ay az) = Vector3 (signum ax) (signum ay) (signum az)

     fromInteger i = Vector3 i' i' i' where i' = fromInteger i

 

 

 instance Fractional Vector3 where

-    Vector3 ax ay az / Vector3 bx by bz = Vector3 (ax / bx) (ay / by) (az / bz)

+    (/) = Spear.Math.Algebra.div

     fromRational r = Vector3 r' r' r' where r' = fromRational r

 

 

@@ -71,91 +119,85 @@ instance Ord Vector3 where
         || (ax == bx && ay > by)

         || (ax == bx && ay == by && az > bz)

 

-    max (Vector3 ax ay az) (Vector3 bx by bz) = Vector3 (Prelude.max ax bx) (Prelude.max ay by) (Prelude.max az bz)

+    max (Vector3 ax ay az) (Vector3 bx by bz) =

+        Vector3 (max ax bx) (max ay by) (max az bz)

 

-    min (Vector3 ax ay az) (Vector3 bx by bz) = Vector3 (Prelude.min ax bx) (Prelude.min ay by) (Prelude.min az bz)

+    min (Vector3 ax ay az) (Vector3 bx by bz) =

+        Vector3 (min ax bx) (min ay by) (min az bz)

 

 

 instance Vector Vector3 where

-         {-# INLINABLE fromList #-}

-         fromList (ax:ay:az:_) = Vector3 ax ay az

-

-         {-# INLINABLE x #-}

-         x (Vector3 ax _  _ ) = ax

+    {-# INLINABLE fromList #-}

+    fromList (ax:ay:az:_) = Vector3 ax ay az

 

-         {-# INLINABLE y #-}

-         y (Vector3 _  ay _ ) = ay

+    {-# INLINABLE x #-}

+    x (Vector3 ax _  _ ) = ax

 

-         {-# INLINABLE z #-}

-         z (Vector3 _  _  az) = az

+    {-# INLINABLE y #-}

+    y (Vector3 _  ay _ ) = ay

 

-         {-# INLINABLE (!) #-}

-         (Vector3 ax _ _) ! 0 = ax

-         (Vector3 _ ay _) ! 1 = ay

-         (Vector3 _ _ az) ! 2 = az

-         _                ! _ = 0

+    {-# INLINABLE z #-}

+    z (Vector3 _  _  az) = az

 

-         {-# INLINABLE dot #-}

-         Vector3 ax ay az `dot` Vector3 bx by bz = ax*bx + ay*by + az*bz

+    {-# INLINABLE (!) #-}

+    (Vector3 ax _ _) ! 0 = ax

+    (Vector3 _ ay _) ! 1 = ay

+    (Vector3 _ _ az) ! 2 = az

+    _                ! _ = 0

 

-         {-# INLINABLE normSq #-}

-         normSq (Vector3 ax ay az) = ax*ax + ay*ay + az*az

+    {-# INLINABLE dot #-}

+    Vector3 ax ay az `dot` Vector3 bx by bz = ax*bx + ay*by + az*bz

 

-         {-# INLINABLE norm #-}

-         norm = sqrt . normSq

+    {-# INLINABLE normSq #-}

+    normSq (Vector3 ax ay az) = ax*ax + ay*ay + az*az

 

-         {-# INLINABLE scale #-}

-         scale s (Vector3 ax ay az) = Vector3 (s*ax) (s*ay) (s*az)

+    {-# INLINABLE norm #-}

+    norm = sqrt . normSq

 

-         {-# INLINABLE neg #-}

-         neg (Vector3 ax ay az) = Vector3 (-ax) (-ay) (-az)

+    {-# INLINABLE neg #-}

+    neg (Vector3 ax ay az) = Vector3 (-ax) (-ay) (-az)

 

-         {-# INLINABLE normalise #-}

-         normalise v =

-                   let n' = norm v

-                       n = if n' == 0 then 1 else n'

-                   in scale (1.0 / n) v

+    {-# INLINABLE normalise #-}

+    normalise v =

+            let n' = norm v

+                n = if n' == 0 then 1 else n'

+            in ((1.0::Float) / n) * v

 

 

 sizeFloat = sizeOf (undefined :: CFloat)

 

 

 instance Storable Vector3 where

-    sizeOf _    = 3*sizeFloat

+    sizeOf _    = (3::Int) * sizeFloat

     alignment _ = alignment (undefined :: CFloat)

 

     peek ptr = do

         ax <- peekByteOff ptr 0

-        ay <- peekByteOff ptr $ 1*sizeFloat

-        az <- peekByteOff ptr $ 2*sizeFloat

+        ay <- peekByteOff ptr $ (1::Int) * sizeFloat

+        az <- peekByteOff ptr $ (2::Int) * sizeFloat

         return (Vector3 ax ay az)

 

     poke ptr (Vector3 ax ay az) = do

         pokeByteOff ptr 0 ax

-        pokeByteOff ptr (1*sizeFloat) ay

-        pokeByteOff ptr (2*sizeFloat) az

+        pokeByteOff ptr ((1::Int) * sizeFloat) ay

+        pokeByteOff ptr ((2::Int) * sizeFloat) az

 

 

 -- | Unit vector along the X axis.

 unitx3 = Vector3 1 0 0

 

-

 -- | Unit vector along the Y axis.

 unity3 = Vector3 0 1 0

 

-

 -- | Unit vector along the Z axis.

 unitz3 = Vector3 0 0 1

 

-

 -- | Zero vector.

 zero3 = Vector3 0 0 0

 

-

 -- | Create a 3D vector from the given values.

 vec3 :: Float -> Float -> Float -> Vector3

-vec3 ax ay az = Vector3 ax ay az

-

+vec3 = Vector3

 

 -- | Create a 3D vector as a point on a sphere.

 orbit :: Vector3 -- ^ Sphere center.

@@ -163,21 +205,17 @@ orbit :: Vector3 -- ^ Sphere center.
       -> Float -- ^ Azimuth angle.

       -> Float -- ^ Zenith angle.

       -> Vector3

-

 orbit center radius anglex angley =

-    let ax = anglex * pi / 180

-        ay = angley * pi / 180

-        sx = sin ax

-        sy = sin ay

-        cx = cos ax

-        cy = cos ay

+    let sx = sin anglex

+        sy = sin angley

+        cx = cos anglex

+        cy = cos angley

         px = x center + radius*cy*sx

         py = y center + radius*sy

         pz = z center + radius*cx*cy

     in

         vec3 px py pz

 

-

 -- | Compute the given vectors' cross product.

 cross :: Vector3 -> Vector3 -> Vector3

 (Vector3 ax ay az) `cross` (Vector3 bx by bz) =

diff --git a/Spear/Math/Vector/Vector4.hs b/Spear/Math/Vector/Vector4.hs
index 325eefc..907295e 100644
--- a/Spear/Math/Vector/Vector4.hs
+++ b/Spear/Math/Vector/Vector4.hs
@@ -1,3 +1,7 @@
+{-# LANGUAGE MultiParamTypeClasses #-}

+{-# LANGUAGE NoImplicitPrelude     #-}

+{-# LANGUAGE TypeFamilies          #-}

+

 module Spear.Math.Vector.Vector4

 (

     Vector4(..)

@@ -11,11 +15,13 @@ module Spear.Math.Vector.Vector4
 )

 where

 

-

+import           Spear.Math.Algebra

 import           Spear.Math.Vector.Vector

+import           Spear.Prelude

 

 import           Foreign.C.Types          (CFloat)

 import           Foreign.Storable

+import qualified Prelude                  as P

 

 

 -- | Represents a vector in 3D.

@@ -27,17 +33,58 @@ data Vector4 = Vector4
     deriving (Eq, Show)

 

 

+instance Addition Vector4 Vector4 where

+    {-# INLINABLE (+) #-}

+    Vector4 ax ay az aw + Vector4 bx by bz bw =

+        Vector4 (ax + bx) (ay + by) (az + bz) (aw + bw)

+

+

+instance Subtraction Vector4 Vector4 where

+    {-# INLINABLE (-) #-}

+    Vector4 ax ay az aw - Vector4 bx by bz bw =

+        Vector4 (ax - bx) (ay - by) (az - bz) (aw - bw)

+

+

+instance Product Vector4 Vector4 Vector4 where

+    {-# INLINABLE (*) #-}

+    Vector4 ax ay az aw * Vector4 bx by bz bw =

+        Vector4 (ax * bx) (ay * by) (az * bz) (aw * bw)

+

+

+instance Quotient Vector4 Vector4 where

+    {-# INLINABLE (/) #-}

+    Vector4 ax ay az aw / Vector4 bx by bz bw =

+        Vector4 (ax / bx) (ay / by) (az / bz) (aw / bw)

+

+

+-- Scalar product.

+instance Product Vector4 Float Vector4 where

+    {-# INLINABLE (*) #-}

+    (Vector4 x y z w) * s = Vector4 (s * x) (s * y) (s * z) (s * w)

+

+

+instance Product Float Vector4 Vector4 where

+    {-# INLINABLE (*) #-}

+    s * (Vector4 x y z w) = Vector4 (s * x) (s * y) (s * z) (s * w)

+

+

+-- Scalar division.

+instance Quotient Vector4 Float where

+    {-# INLINABLE (/) #-}

+    (Vector4 x y z w) / s = Vector4 (x / s) (y / s) (y / s) (w / s)

+

+

 instance Num Vector4 where

-    Vector4 ax ay az aw + Vector4 bx by bz bw = Vector4 (ax + bx) (ay + by) (az + bz) (aw + bw)

-    Vector4 ax ay az aw - Vector4 bx by bz bw = Vector4 (ax - bx) (ay - by) (az - bz) (aw - bw)

-    Vector4 ax ay az aw * Vector4 bx by bz bw = Vector4 (ax * bx) (ay * by) (az * bz) (aw * bw)

+    (+) = add

+    (-) = sub

+    (*) = mul

     abs (Vector4 ax ay az aw) = Vector4 (abs ax) (abs ay) (abs az) (abs aw)

     signum (Vector4 ax ay az aw) = Vector4 (signum ax) (signum ay) (signum az) (signum aw)

     fromInteger i = Vector4 i' i' i' i' where i' = fromInteger i

 

 

 instance Fractional Vector4 where

-    Vector4 ax ay az aw / Vector4 bx by bz bw = Vector4 (ax / bx) (ay / by) (az / bz) (aw / bw)

+    (/) = Spear.Math.Algebra.div

     fromRational r = Vector4 r' r' r' r' where r' = fromRational r

 

 

@@ -67,97 +114,90 @@ instance Ord Vector4 where
         || (ax == bx && ay == by && az == bz && aw > bw)

 

     min (Vector4 ax ay az aw) (Vector4 bx by bz bw) =

-        Vector4 (Prelude.min ax bx) (Prelude.min ay by) (Prelude.min az bz) (Prelude.min aw bw)

+        Vector4 (min ax bx) (min ay by) (min az bz) (min aw bw)

 

     max (Vector4 ax ay az aw) (Vector4 bx by bz bw) =

-        Vector4 (Prelude.max ax bx) (Prelude.max ay by) (Prelude.max az bz) (Prelude.min aw bw)

+        Vector4 (max ax bx) (max ay by) (max az bz) (min aw bw)

 

 

 instance Vector Vector4 where

-         {-# INLINABLE fromList #-}

-         fromList (ax:ay:az:aw:_) = Vector4 ax ay az aw

+    {-# INLINABLE fromList #-}

+    fromList (ax:ay:az:aw:_) = Vector4 ax ay az aw

 

-         {-# INLINABLE x #-}

-         x (Vector4 ax _  _  _ ) = ax

+    {-# INLINABLE x #-}

+    x (Vector4 ax _  _  _ ) = ax

 

-         {-# INLINABLE y #-}

-         y (Vector4 _  ay _  _ ) = ay

+    {-# INLINABLE y #-}

+    y (Vector4 _  ay _  _ ) = ay

 

-         {-# INLINABLE z #-}

-         z (Vector4 _  _  az _ ) = az

+    {-# INLINABLE z #-}

+    z (Vector4 _  _  az _ ) = az

 

-         {-# INLINABLE w #-}

-         w (Vector4 _  _  _  aw) = aw

+    {-# INLINABLE w #-}

+    w (Vector4 _  _  _  aw) = aw

 

-         {-# INLINABLE (!) #-}

-         (Vector4 ax _ _ _) ! 0 = ax

-         (Vector4 _ ay _ _) ! 1 = ay

-         (Vector4 _ _ az _) ! 2 = az

-         (Vector4 _ _ _ aw) ! 3 = aw

-         _                  ! _ = 0

+    {-# INLINABLE (!) #-}

+    (Vector4 ax _ _ _) ! 0 = ax

+    (Vector4 _ ay _ _) ! 1 = ay

+    (Vector4 _ _ az _) ! 2 = az

+    (Vector4 _ _ _ aw) ! 3 = aw

+    _                  ! _ = 0

 

-         {-# INLINABLE dot #-}

-         Vector4 ax ay az aw `dot` Vector4 bx by bz bw = ax*bx + ay*by + az*bz + aw*bw

+    {-# INLINABLE dot #-}

+    Vector4 ax ay az aw `dot` Vector4 bx by bz bw = ax*bx + ay*by + az*bz + aw*bw

 

-         {-# INLINABLE normSq #-}

-         normSq (Vector4 ax ay az aw) = ax*ax + ay*ay + az*az + aw*aw

+    {-# INLINABLE normSq #-}

+    normSq (Vector4 ax ay az aw) = ax*ax + ay*ay + az*az + aw*aw

 

-         {-# INLINABLE norm #-}

-         norm = sqrt . normSq

+    {-# INLINABLE norm #-}

+    norm = sqrt . normSq

 

-         {-# INLINABLE scale #-}

-         scale s (Vector4 ax ay az aw) = Vector4 (s*ax) (s*ay) (s*az) (s*aw)

+    {-# INLINABLE neg #-}

+    neg (Vector4 ax ay az aw) = Vector4 (-ax) (-ay) (-az) (-aw)

 

-         {-# INLINABLE neg #-}

-         neg (Vector4 ax ay az aw) = Vector4 (-ax) (-ay) (-az) (-aw)

-

-         {-# INLINABLE normalise #-}

-         normalise v =

-                   let n' = norm v

-                       n = if n' == 0 then 1 else n'

-                   in scale (1.0 / n) v

+    {-# INLINABLE normalise #-}

+    normalise v =

+            let n' = norm v

+                n  = if n' == 0 then 1 else n'

+            in ((1.0::Float) / n) * v

 

 

 sizeFloat = sizeOf (undefined :: CFloat)

 

 

 instance Storable Vector4 where

-    sizeOf _    = 4*sizeFloat

+    sizeOf _    = (4::Int) * sizeFloat

     alignment _ = alignment (undefined :: CFloat)

 

     peek ptr = do

         ax <- peekByteOff ptr 0

-        ay <- peekByteOff ptr $ 1 * sizeFloat

-        az <- peekByteOff ptr $ 2 * sizeFloat

-        aw <- peekByteOff ptr $ 3 * sizeFloat

+        ay <- peekByteOff ptr $ (1::Int) * sizeFloat

+        az <- peekByteOff ptr $ (2::Int) * sizeFloat

+        aw <- peekByteOff ptr $ (3::Int) * sizeFloat

         return (Vector4 ax ay az aw)

 

     poke ptr (Vector4 ax ay az aw) = do

         pokeByteOff ptr 0 ax

-        pokeByteOff ptr (1 * sizeFloat) ay

-        pokeByteOff ptr (2 * sizeFloat) az

-        pokeByteOff ptr (3 * sizeFloat) aw

+        pokeByteOff ptr ((1::Int) * sizeFloat) ay

+        pokeByteOff ptr ((2::Int) * sizeFloat) az

+        pokeByteOff ptr ((3::Int) * sizeFloat) aw

 

 

 -- | Unit vector along the X axis.

 unitx4 = Vector4 1 0 0 0

 

-

 -- | Unit vector along the Y axis.

 unity4 = Vector4 0 1 0 0

 

-

 -- | Unit vector along the Z axis.

 unitz4 = Vector4 0 0 1 0

 

 -- | Unit vector along the W axis.

 unitw4 = Vector4 0 0 0 1

 

-

 -- | Create a 4D vector from the given values.

 vec4 :: Float -> Float -> Float -> Float -> Vector4

-vec4 ax ay az aw = Vector4 ax ay az aw

-

+vec4 = Vector4

 

 -- | Compute the given vectors' cross product.

 -- The vectors are projected to 3D space. The resulting vector is the cross product of the vectors' projections with w=0.