-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Low-dimensional vectors
--   
--   A lightweight, opinionated clone of the low-dimensional vector parts
--   of linear. See README.md for more information.
@package nonlinear
@version 0.1.0


-- | Adapted from <a>Linear.Vector</a>
module Nonlinear.Vector

-- | Class of vectors of statically known size.
--   
--   Conceptually, this is <a>Representable</a>, but with a
--   <a>Traversable</a> and <a>Monad</a> constraint instead of just
--   <a>Functor</a>. This makes it a catch-all class for things that we
--   would normally think of as vectors of statically known size. The Monad
--   constraint might seem weird, but since we can implement the normal
--   (diagonal) Monad instance in terms of <a>construct</a>, it doesn't
--   actually preclude anything.
class (Traversable v, Monad v) => Vec v
construct :: Vec v => ((forall b. Lens' (v b) b) -> a) -> v a

-- | Compute the negation of a vector
--   
--   <pre>
--   &gt;&gt;&gt; negated (V2 2 4)
--   V2 (-2) (-4)
--   </pre>
negated :: (Vec f, Num a) => f a -> f a

-- | Compute the right scalar product
--   
--   <pre>
--   &gt;&gt;&gt; V2 3 4 ^* 2
--   V2 6 8
--   </pre>
(^*) :: (Vec f, Num a) => f a -> a -> f a
infixl 7 ^*

-- | Compute the left scalar product
--   
--   <pre>
--   &gt;&gt;&gt; 2 *^ V2 3 4
--   V2 6 8
--   </pre>
(*^) :: (Vec f, Num a) => a -> f a -> f a
infixl 7 *^

-- | Compute division by a scalar on the right.
(^/) :: (Vec f, Fractional a) => f a -> a -> f a
infixl 7 ^/

-- | Produce a default basis for a vector space. If the dimensionality of
--   the vector space is not statically known, see <a>basisFor</a>.
basis :: (Vec t, Num a) => [t a]

-- | Produce a default basis for a vector space from which the argument is
--   drawn.
basisFor :: (Vec t, Num a) => t b -> [t a]

-- | Produce a diagonal (scale) matrix from a vector.
--   
--   <pre>
--   &gt;&gt;&gt; scaled (V2 2 3)
--   V2 (V2 2 0) (V2 0 3)
--   </pre>
scaled :: (Vec t, Num a) => t a -> t (t a)

-- | Outer (tensor) product of two vectors
outer :: (Vec f, Vec g, Num a) => f a -> g a -> f (g a)

-- | Create a unit vector.
--   
--   <pre>
--   &gt;&gt;&gt; unit _x :: V2 Int
--   V2 1 0
--   </pre>
unit :: (Vec t, Num a) => ASetter' (t a) a -> t a

-- | Compute the inner product of two vectors or (equivalently) convert a
--   vector <tt>f a</tt> into a covector <tt>f a -&gt; a</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; V2 1 2 `dot` V2 3 4
--   11
--   </pre>
dot :: (Vec f, Num a) => f a -> f a -> a

-- | Compute the squared norm. The name quadrance arises from Norman J.
--   Wildberger's rational trigonometry.
quadrance :: (Vec f, Num a) => f a -> a

-- | Compute the quadrance of the difference
qd :: (Vec f, Num a) => f a -> f a -> a

-- | Compute the distance between two vectors in a metric space
distance :: (Vec f, Floating a) => f a -> f a -> a

-- | Compute the norm of a vector in a metric space
norm :: (Vec f, Floating a) => f a -> a

-- | Convert a non-zero vector to unit vector.
signorm :: (Vec f, Floating a) => f a -> f a

-- | Normalize a <tt>Metric</tt> functor to have unit <a>norm</a>. This
--   function does not change the functor if its <a>norm</a> is 0 or 1.
normalize :: (Vec f, Floating a) => f a -> f a

-- | <tt>project u v</tt> computes the projection of <tt>v</tt> onto
--   <tt>u</tt>.
project :: (Vec v, Fractional a) => v a -> v a -> v a


-- | Adapted from <a>Linear.V1</a>
module Nonlinear.V1
newtype V1 a
V1 :: a -> V1 a
[v1x] :: V1 a -> a
class R1 t
_x :: R1 t => Lens' (t a) a
instance GHC.Base.Monad Nonlinear.V1.V1
instance GHC.Base.Applicative Nonlinear.V1.V1
instance Data.Functor.Classes.Ord1 Nonlinear.V1.V1
instance Data.Functor.Classes.Show1 Nonlinear.V1.V1
instance Data.Functor.Classes.Read1 Nonlinear.V1.V1
instance Data.Functor.Classes.Eq1 Nonlinear.V1.V1
instance GHC.Ix.Ix a => GHC.Ix.Ix (Nonlinear.V1.V1 a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Nonlinear.V1.V1 a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Nonlinear.V1.V1 a)
instance GHC.Float.Floating a => GHC.Float.Floating (Nonlinear.V1.V1 a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Nonlinear.V1.V1 a)
instance GHC.Num.Num a => GHC.Num.Num (Nonlinear.V1.V1 a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Nonlinear.V1.V1 a)
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (Nonlinear.V1.V1 a)
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Nonlinear.V1.V1 a)
instance Data.Data.Data a => Data.Data.Data (Nonlinear.V1.V1 a)
instance GHC.Generics.Generic1 Nonlinear.V1.V1
instance GHC.Generics.Generic (Nonlinear.V1.V1 a)
instance Data.Traversable.Traversable Nonlinear.V1.V1
instance Data.Foldable.Foldable Nonlinear.V1.V1
instance GHC.Base.Functor Nonlinear.V1.V1
instance GHC.Read.Read a => GHC.Read.Read (Nonlinear.V1.V1 a)
instance GHC.Show.Show a => GHC.Show.Show (Nonlinear.V1.V1 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Nonlinear.V1.V1 a)
instance Nonlinear.Vector.Vec Nonlinear.V1.V1
instance Nonlinear.V1.R1 Nonlinear.V1.V1


-- | Adapted from <a>Linear.V2</a>
module Nonlinear.V2
data V2 a
V2 :: !a -> !a -> V2 a
[v2x] :: V2 a -> !a
[v2y] :: V2 a -> !a

-- | the counter-clockwise perpendicular vector
--   
--   <pre>
--   &gt;&gt;&gt; perp $ V2 10 20
--   V2 (-20) 10
--   </pre>
perp :: Num a => V2 a -> V2 a
angle :: Floating a => a -> V2 a
unangle :: (Floating a, Ord a) => V2 a -> a

-- | The Z-component of the cross product of two vectors in the XY-plane.
--   
--   <pre>
--   &gt;&gt;&gt; crossZ (V2 1 0) (V2 0 1)
--   1
--   </pre>
crossZ :: Num a => V2 a -> V2 a -> a
class R1 t => R2 t
_y :: R2 t => Lens' (t a) a
_xy :: R2 t => Lens' (t a) (V2 a)

-- | <pre>
--   &gt;&gt;&gt; V2 1 2 ^. _yx
--   V2 2 1
--   </pre>
_yx :: R2 t => Lens' (t a) (V2 a)
instance Data.Data.Data a => Data.Data.Data (Nonlinear.V2.V2 a)
instance GHC.Generics.Generic1 Nonlinear.V2.V2
instance GHC.Generics.Generic (Nonlinear.V2.V2 a)
instance Data.Traversable.Traversable Nonlinear.V2.V2
instance Data.Foldable.Foldable Nonlinear.V2.V2
instance GHC.Base.Functor Nonlinear.V2.V2
instance GHC.Classes.Ord a => GHC.Classes.Ord (Nonlinear.V2.V2 a)
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (Nonlinear.V2.V2 a)
instance GHC.Read.Read a => GHC.Read.Read (Nonlinear.V2.V2 a)
instance GHC.Show.Show a => GHC.Show.Show (Nonlinear.V2.V2 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Nonlinear.V2.V2 a)
instance Nonlinear.Vector.Vec Nonlinear.V2.V2
instance Nonlinear.V2.R2 Nonlinear.V2.V2
instance GHC.Base.Applicative Nonlinear.V2.V2
instance GHC.Base.Monad Nonlinear.V2.V2
instance GHC.Base.Semigroup x => GHC.Base.Semigroup (Nonlinear.V2.V2 x)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Nonlinear.V2.V2 a)
instance GHC.Num.Num a => GHC.Num.Num (Nonlinear.V2.V2 a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Nonlinear.V2.V2 a)
instance GHC.Float.Floating a => GHC.Float.Floating (Nonlinear.V2.V2 a)
instance Data.Functor.Classes.Eq1 Nonlinear.V2.V2
instance Data.Functor.Classes.Ord1 Nonlinear.V2.V2
instance Data.Functor.Classes.Read1 Nonlinear.V2.V2
instance Data.Functor.Classes.Show1 Nonlinear.V2.V2
instance Nonlinear.V1.R1 Nonlinear.V2.V2
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Nonlinear.V2.V2 a)
instance GHC.Ix.Ix a => GHC.Ix.Ix (Nonlinear.V2.V2 a)


-- | Adapted from <a>Linear.V3</a>
module Nonlinear.V3
data V3 a
V3 :: !a -> !a -> !a -> V3 a
[v3x] :: V3 a -> !a
[v3y] :: V3 a -> !a
[v3z] :: V3 a -> !a

-- | cross product
cross :: Num a => V3 a -> V3 a -> V3 a

-- | scalar triple product
triple :: Num a => V3 a -> V3 a -> V3 a -> a
class R2 t => R3 t
_z :: R3 t => Lens' (t a) a
_xyz :: R3 t => Lens' (t a) (V3 a)
_xz :: R3 t => Lens' (t a) (V2 a)
_yz :: R3 t => Lens' (t a) (V2 a)
_zx :: R3 t => Lens' (t a) (V2 a)
_zy :: R3 t => Lens' (t a) (V2 a)
_xzy :: R3 t => Lens' (t a) (V3 a)
_yxz :: R3 t => Lens' (t a) (V3 a)
_yzx :: R3 t => Lens' (t a) (V3 a)
_zxy :: R3 t => Lens' (t a) (V3 a)
_zyx :: R3 t => Lens' (t a) (V3 a)
instance Data.Data.Data a => Data.Data.Data (Nonlinear.V3.V3 a)
instance GHC.Generics.Generic1 Nonlinear.V3.V3
instance GHC.Generics.Generic (Nonlinear.V3.V3 a)
instance Data.Traversable.Traversable Nonlinear.V3.V3
instance Data.Foldable.Foldable Nonlinear.V3.V3
instance GHC.Base.Functor Nonlinear.V3.V3
instance GHC.Classes.Ord a => GHC.Classes.Ord (Nonlinear.V3.V3 a)
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (Nonlinear.V3.V3 a)
instance GHC.Read.Read a => GHC.Read.Read (Nonlinear.V3.V3 a)
instance GHC.Show.Show a => GHC.Show.Show (Nonlinear.V3.V3 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Nonlinear.V3.V3 a)
instance Nonlinear.Vector.Vec Nonlinear.V3.V3
instance Nonlinear.V3.R3 Nonlinear.V3.V3
instance GHC.Base.Applicative Nonlinear.V3.V3
instance GHC.Base.Monad Nonlinear.V3.V3
instance GHC.Base.Semigroup x => GHC.Base.Semigroup (Nonlinear.V3.V3 x)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Nonlinear.V3.V3 a)
instance GHC.Num.Num a => GHC.Num.Num (Nonlinear.V3.V3 a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Nonlinear.V3.V3 a)
instance GHC.Float.Floating a => GHC.Float.Floating (Nonlinear.V3.V3 a)
instance Data.Functor.Classes.Eq1 Nonlinear.V3.V3
instance Data.Functor.Classes.Ord1 Nonlinear.V3.V3
instance Data.Functor.Classes.Read1 Nonlinear.V3.V3
instance Data.Functor.Classes.Show1 Nonlinear.V3.V3
instance Nonlinear.V1.R1 Nonlinear.V3.V3
instance Nonlinear.V2.R2 Nonlinear.V3.V3
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Nonlinear.V3.V3 a)
instance GHC.Ix.Ix a => GHC.Ix.Ix (Nonlinear.V3.V3 a)


-- | Adapted from <a>Linear.V4</a>
module Nonlinear.V4
data V4 a
V4 :: !a -> !a -> !a -> !a -> V4 a
[v4x] :: V4 a -> !a
[v4y] :: V4 a -> !a
[v4z] :: V4 a -> !a
[v4w] :: V4 a -> !a
class R3 t => R4 t
_w :: R4 t => Lens' (t a) a
_xyzw :: R4 t => Lens' (t a) (V4 a)
_xw :: R4 t => Lens' (t a) (V2 a)
_yw :: R4 t => Lens' (t a) (V2 a)
_zw :: R4 t => Lens' (t a) (V2 a)
_wx :: R4 t => Lens' (t a) (V2 a)
_wy :: R4 t => Lens' (t a) (V2 a)
_wz :: R4 t => Lens' (t a) (V2 a)
_xyw :: R4 t => Lens' (t a) (V3 a)
_xzw :: R4 t => Lens' (t a) (V3 a)
_xwy :: R4 t => Lens' (t a) (V3 a)
_xwz :: R4 t => Lens' (t a) (V3 a)
_yxw :: R4 t => Lens' (t a) (V3 a)
_yzw :: R4 t => Lens' (t a) (V3 a)
_ywx :: R4 t => Lens' (t a) (V3 a)
_ywz :: R4 t => Lens' (t a) (V3 a)
_zxw :: R4 t => Lens' (t a) (V3 a)
_zyw :: R4 t => Lens' (t a) (V3 a)
_zwx :: R4 t => Lens' (t a) (V3 a)
_zwy :: R4 t => Lens' (t a) (V3 a)
_wxy :: R4 t => Lens' (t a) (V3 a)
_wxz :: R4 t => Lens' (t a) (V3 a)
_wyx :: R4 t => Lens' (t a) (V3 a)
_wyz :: R4 t => Lens' (t a) (V3 a)
_wzx :: R4 t => Lens' (t a) (V3 a)
_wzy :: R4 t => Lens' (t a) (V3 a)
_xywz :: R4 t => Lens' (t a) (V4 a)
_xzyw :: R4 t => Lens' (t a) (V4 a)
_xzwy :: R4 t => Lens' (t a) (V4 a)
_xwyz :: R4 t => Lens' (t a) (V4 a)
_xwzy :: R4 t => Lens' (t a) (V4 a)
_yxzw :: R4 t => Lens' (t a) (V4 a)
_yxwz :: R4 t => Lens' (t a) (V4 a)
_yzxw :: R4 t => Lens' (t a) (V4 a)
_yzwx :: R4 t => Lens' (t a) (V4 a)
_ywxz :: R4 t => Lens' (t a) (V4 a)
_ywzx :: R4 t => Lens' (t a) (V4 a)
_zxyw :: R4 t => Lens' (t a) (V4 a)
_zxwy :: R4 t => Lens' (t a) (V4 a)
_zyxw :: R4 t => Lens' (t a) (V4 a)
_zywx :: R4 t => Lens' (t a) (V4 a)
_zwxy :: R4 t => Lens' (t a) (V4 a)
_zwyx :: R4 t => Lens' (t a) (V4 a)
_wxyz :: R4 t => Lens' (t a) (V4 a)
_wxzy :: R4 t => Lens' (t a) (V4 a)
_wyxz :: R4 t => Lens' (t a) (V4 a)
_wyzx :: R4 t => Lens' (t a) (V4 a)
_wzxy :: R4 t => Lens' (t a) (V4 a)
_wzyx :: R4 t => Lens' (t a) (V4 a)
instance Data.Data.Data a => Data.Data.Data (Nonlinear.V4.V4 a)
instance GHC.Generics.Generic1 Nonlinear.V4.V4
instance GHC.Generics.Generic (Nonlinear.V4.V4 a)
instance Data.Traversable.Traversable Nonlinear.V4.V4
instance Data.Foldable.Foldable Nonlinear.V4.V4
instance GHC.Base.Functor Nonlinear.V4.V4
instance GHC.Classes.Ord a => GHC.Classes.Ord (Nonlinear.V4.V4 a)
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (Nonlinear.V4.V4 a)
instance GHC.Read.Read a => GHC.Read.Read (Nonlinear.V4.V4 a)
instance GHC.Show.Show a => GHC.Show.Show (Nonlinear.V4.V4 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Nonlinear.V4.V4 a)
instance Nonlinear.Vector.Vec Nonlinear.V4.V4
instance Nonlinear.V4.R4 Nonlinear.V4.V4
instance GHC.Base.Applicative Nonlinear.V4.V4
instance GHC.Base.Monad Nonlinear.V4.V4
instance GHC.Base.Semigroup x => GHC.Base.Semigroup (Nonlinear.V4.V4 x)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Nonlinear.V4.V4 a)
instance GHC.Num.Num a => GHC.Num.Num (Nonlinear.V4.V4 a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Nonlinear.V4.V4 a)
instance GHC.Float.Floating a => GHC.Float.Floating (Nonlinear.V4.V4 a)
instance Data.Functor.Classes.Eq1 Nonlinear.V4.V4
instance Data.Functor.Classes.Ord1 Nonlinear.V4.V4
instance Data.Functor.Classes.Read1 Nonlinear.V4.V4
instance Data.Functor.Classes.Show1 Nonlinear.V4.V4
instance Nonlinear.V1.R1 Nonlinear.V4.V4
instance Nonlinear.V2.R2 Nonlinear.V4.V4
instance Nonlinear.V3.R3 Nonlinear.V4.V4
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Nonlinear.V4.V4 a)
instance GHC.Ix.Ix a => GHC.Ix.Ix (Nonlinear.V4.V4 a)

module Nonlinear.Quaternion

-- | Quaternions
data Quaternion a
Quaternion :: !a -> {-# UNPACK #-} !V3 a -> Quaternion a

-- | A vector space that includes the basis elements <a>_e</a> and
--   <a>_i</a>
class Complicated t
_e :: Complicated t => Lens' (t a) a
_i :: Complicated t => Lens' (t a) a

-- | A vector space that includes the basis elements <a>_e</a>, <a>_i</a>,
--   <a>_j</a> and <a>_k</a>
class Complicated t => Hamiltonian t
_j :: Hamiltonian t => Lens' (t a) a
_k :: Hamiltonian t => Lens' (t a) a
_ijk :: Hamiltonian t => Lens' (t a) (V3 a)

-- | Spherical linear interpolation between two quaternions.
slerp :: RealFloat a => Quaternion a -> Quaternion a -> a -> Quaternion a

-- | <a>asin</a> with a specified branch cut.
asinq :: RealFloat a => Quaternion a -> Quaternion a -> Quaternion a

-- | <a>acos</a> with a specified branch cut.
acosq :: RealFloat a => Quaternion a -> Quaternion a -> Quaternion a

-- | <a>atan</a> with a specified branch cut.
atanq :: RealFloat a => Quaternion a -> Quaternion a -> Quaternion a

-- | <a>asinh</a> with a specified branch cut.
asinhq :: RealFloat a => Quaternion a -> Quaternion a -> Quaternion a

-- | <a>acosh</a> with a specified branch cut.
acoshq :: RealFloat a => Quaternion a -> Quaternion a -> Quaternion a

-- | <a>atanh</a> with a specified branch cut.
atanhq :: RealFloat a => Quaternion a -> Quaternion a -> Quaternion a

-- | norm of the imaginary component
absi :: Floating a => Quaternion a -> a

-- | raise a <a>Quaternion</a> to a scalar power
pow :: RealFloat a => Quaternion a -> a -> Quaternion a

-- | Apply a rotation to a vector.
rotate :: RealFloat a => Quaternion a -> V3 a -> V3 a

-- | <tt><a>axisAngle</a> axis theta</tt> builds a <a>Quaternion</a>
--   representing a rotation of <tt>theta</tt> radians about <tt>axis</tt>.
axisAngle :: Floating a => V3 a -> a -> Quaternion a
instance Data.Traversable.Traversable Nonlinear.Quaternion.Quaternion
instance Data.Foldable.Foldable Nonlinear.Quaternion.Quaternion
instance GHC.Base.Functor Nonlinear.Quaternion.Quaternion
instance GHC.Generics.Generic1 Nonlinear.Quaternion.Quaternion
instance GHC.Generics.Generic (Nonlinear.Quaternion.Quaternion a)
instance Data.Data.Data a => Data.Data.Data (Nonlinear.Quaternion.Quaternion a)
instance GHC.Show.Show a => GHC.Show.Show (Nonlinear.Quaternion.Quaternion a)
instance GHC.Read.Read a => GHC.Read.Read (Nonlinear.Quaternion.Quaternion a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Nonlinear.Quaternion.Quaternion a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Nonlinear.Quaternion.Quaternion a)
instance Nonlinear.Quaternion.Hamiltonian Nonlinear.Quaternion.Quaternion
instance Nonlinear.Quaternion.Complicated Data.Complex.Complex
instance Nonlinear.Quaternion.Complicated Nonlinear.Quaternion.Quaternion
instance GHC.Base.Applicative Nonlinear.Quaternion.Quaternion
instance GHC.Base.Monad Nonlinear.Quaternion.Quaternion
instance Nonlinear.Vector.Vec Nonlinear.Quaternion.Quaternion
instance GHC.Ix.Ix a => GHC.Ix.Ix (Nonlinear.Quaternion.Quaternion a)
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Nonlinear.Quaternion.Quaternion a)
instance GHC.Float.RealFloat a => GHC.Num.Num (Nonlinear.Quaternion.Quaternion a)
instance GHC.Float.RealFloat a => GHC.Real.Fractional (Nonlinear.Quaternion.Quaternion a)
instance GHC.Float.RealFloat a => GHC.Float.Floating (Nonlinear.Quaternion.Quaternion a)
instance Control.Monad.Zip.MonadZip Nonlinear.Quaternion.Quaternion
instance Control.Monad.Fix.MonadFix Nonlinear.Quaternion.Quaternion
instance Data.Functor.Classes.Eq1 Nonlinear.Quaternion.Quaternion
instance Data.Functor.Classes.Ord1 Nonlinear.Quaternion.Quaternion
instance Data.Functor.Classes.Show1 Nonlinear.Quaternion.Quaternion
instance Data.Functor.Classes.Read1 Nonlinear.Quaternion.Quaternion
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Nonlinear.Quaternion.Quaternion a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Nonlinear.Quaternion.Quaternion a)
instance Nonlinear.V1.R1 Nonlinear.Quaternion.Quaternion
instance Nonlinear.V2.R2 Nonlinear.Quaternion.Quaternion
instance Nonlinear.V3.R3 Nonlinear.Quaternion.Quaternion
instance Nonlinear.V4.R4 Nonlinear.Quaternion.Quaternion


-- | Adapted from <a>Linear.Matrix</a>
module Nonlinear.Matrix

-- | Matrix product
--   
--   <pre>
--   &gt;&gt;&gt; V2 (V3 1 2 3) (V3 4 5 6) !*! V3 (V2 1 2) (V2 3 4) (V2 4 5)
--   V2 (V2 19 25) (V2 43 58)
--   </pre>
(!*!) :: (Vec m, Vec t, Vec n, Num a) => m (t a) -> t (n a) -> m (n a)
infixl 7 !*!

-- | Matrix * column vector
--   
--   <pre>
--   &gt;&gt;&gt; V2 (V3 1 2 3) (V3 4 5 6) !* V3 7 8 9
--   V2 50 122
--   </pre>
(!*) :: (Vec m, Vec r, Num a) => m (r a) -> r a -> m a
infixl 7 !*

-- | Row vector * matrix
--   
--   <pre>
--   &gt;&gt;&gt; V2 1 2 *! V2 (V3 3 4 5) (V3 6 7 8)
--   V3 15 18 21
--   </pre>
(*!) :: (Vec f, Vec t, Num a, Num (f a)) => t a -> t (f a) -> f a
infixl 7 *!

-- | Matrix-scalar product
--   
--   <pre>
--   &gt;&gt;&gt; V2 (V2 1 2) (V2 3 4) !!* 5
--   V2 (V2 5 10) (V2 15 20)
--   </pre>
(!!*) :: (Vec m, Vec r, Num a) => m (r a) -> a -> m (r a)
infixl 7 !!*

-- | Scalar-matrix product
--   
--   <pre>
--   &gt;&gt;&gt; 5 *!! V2 (V2 1 2) (V2 3 4)
--   V2 (V2 5 10) (V2 15 20)
--   </pre>
(*!!) :: (Vec m, Vec r, Num a) => a -> m (r a) -> m (r a)
infixl 7 *!!

-- | Matrix-scalar division
(!!/) :: (Vec r, Vec m, Fractional (r a), Fractional a) => m (r a) -> a -> m (r a)
infixl 7 !!/

-- | This is more restrictive than linear's <tt>LensLike (Context a b) s t
--   a b -&gt; Lens (f s) (f t) (f a) (f b)</tt>, but in return we get a
--   much simpler implementation which should suffice in 99% of cases.
column :: Vec v => Lens' a b -> Lens' (v a) (v b)
diagonal :: Vec v => v (v a) -> v a
trace :: (Vec v, Num a) => v (v a) -> a

-- | A 2x2 matrix with row-major representation
type M22 a = V2 (V2 a)

-- | A 2x3 matrix with row-major representation
type M23 a = V2 (V3 a)

-- | A 2x4 matrix with row-major representation
type M24 a = V2 (V4 a)

-- | A 3x2 matrix with row-major representation
type M32 a = V3 (V2 a)

-- | A 3x3 matrix with row-major representation
type M33 a = V3 (V3 a)

-- | A 3x4 matrix with row-major representation
type M34 a = V3 (V4 a)

-- | A 4x2 matrix with row-major representation
type M42 a = V4 (V2 a)

-- | A 4x3 matrix with row-major representation
type M43 a = V4 (V3 a)

-- | A 4x4 matrix with row-major representation
type M44 a = V4 (V4 a)

-- | 2x2 matrix determinant.
--   
--   <pre>
--   &gt;&gt;&gt; det22 (V2 (V2 a b) (V2 c d))
--   a * d - b * c
--   </pre>
det22 :: Num a => M22 a -> a

-- | 3x3 matrix determinant.
--   
--   <pre>
--   &gt;&gt;&gt; det33 (V3 (V3 a b c) (V3 d e f) (V3 g h i))
--   a * (e * i - f * h) - d * (b * i - c * h) + g * (b * f - c * e)
--   </pre>
det33 :: Num a => M33 a -> a

-- | 4x4 matrix determinant.
det44 :: Num a => M44 a -> a

-- | 2x2 matrix inverse.
--   
--   <pre>
--   &gt;&gt;&gt; inv22 $ V2 (V2 1 2) (V2 3 4)
--   V2 (V2 (-2.0) 1.0) (V2 1.5 (-0.5))
--   </pre>
inv22 :: Fractional a => M22 a -> M22 a

-- | 3x3 matrix inverse.
--   
--   <pre>
--   &gt;&gt;&gt; inv33 $ V3 (V3 1 2 4) (V3 4 2 2) (V3 1 1 1)
--   V3 (V3 0.0 0.5 (-1.0)) (V3 (-0.5) (-0.75) 3.5) (V3 0.5 0.25 (-1.5))
--   </pre>
inv33 :: Fractional a => M33 a -> M33 a

-- | 4x4 matrix inverse.
inv44 :: Fractional a => M44 a -> M44 a

-- | The identity matrix for any dimension vector.
--   
--   <pre>
--   &gt;&gt;&gt; identity :: M44 Int
--   V4 (V4 1 0 0 0) (V4 0 1 0 0) (V4 0 0 1 0) (V4 0 0 0 1)
--   
--   &gt;&gt;&gt; identity :: V3 (V3 Int)
--   V3 (V3 1 0 0) (V3 0 1 0) (V3 0 0 1)
--   </pre>
identity :: (Vec v, Num a) => v (v a)

-- | <a>transpose</a> is just an alias for <tt>distribute</tt>
--   
--   <pre>
--   transpose (V3 (V2 1 2) (V2 3 4) (V2 5 6))
--   </pre>
--   
--   V2 (V3 1 3 5) (V3 2 4 6)
transpose :: (Vec f, Vec g) => f (g a) -> g (f a)

-- | Build a rotation matrix from a unit <a>Quaternion</a>.
fromQuaternion :: Num a => Quaternion a -> M33 a

-- | Extract a 2x2 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m22 :: (Vec t, R2 t, R2 v) => Lens' (t (v a)) (M22 a)

-- | Extract a 2x3 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m23 :: (Vec t, R2 t, R3 v) => Lens' (t (v a)) (M23 a)

-- | Extract a 2x4 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m24 :: (Vec t, R2 t, R4 v) => Lens' (t (v a)) (M24 a)

-- | Extract a 3x2 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m32 :: (Vec t, R3 t, R2 v) => Lens' (t (v a)) (M32 a)

-- | Extract a 3x3 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m33 :: (Vec t, R3 t, R3 v) => Lens' (t (v a)) (M33 a)

-- | Extract a 3x4 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m34 :: (Vec t, R3 t, R4 v) => Lens' (t (v a)) (M34 a)

-- | Extract a 4x2 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m42 :: (Vec t, R4 t, R2 v) => Lens' (t (v a)) (M42 a)

-- | Extract a 4x3 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m43 :: (Vec t, R4 t, R3 v) => Lens' (t (v a)) (M43 a)

-- | Extract a 4x4 matrix from a matrix of higher dimensions by dropping
--   excess rows and columns.
_m44 :: (Vec t, R4 t, R4 v) => Lens' (t (v a)) (M44 a)


-- | Functions for working with 3-dimensional homogeneous coordinates. This
--   includes common projection matrices: e.g. perspective/orthographic
--   transformation matrices.
--   
--   Analytically derived inverses are also supplied, because they can be
--   much more accurate in practice than computing them through general
--   purpose means
--   
--   Adapted from <a>Linear.Projection</a>
module Nonlinear.Projective.Hom3

-- | Convert from a 4x3 matrix to a 4x4 matrix, extending it with the <tt>[
--   0 0 0 1 ]</tt> column vector
m43_to_m44 :: Num a => M43 a -> M44 a

-- | Convert a 3-dimensional affine vector into a 4-dimensional homogeneous
--   vector, i.e. sets the <tt>w</tt> coordinate to 0.
vector :: Num a => V3 a -> V4 a

-- | Convert a 3-dimensional affine point into a 4-dimensional homogeneous
--   vector, i.e. sets the <tt>w</tt> coordinate to 1.
point :: Num a => V3 a -> V4 a

-- | Convert 4-dimensional projective coordinates to a 3-dimensional point.
--   This operation may be denoted, <tt>euclidean [x:y:z:w] = (x/w, y/w,
--   z/w)</tt> where the projective, homogeneous, coordinate
--   <tt>[x:y:z:w]</tt> is one of many associated with a single point
--   <tt>(x/w, y/w, z/w)</tt>.
normalizePoint :: Fractional a => V4 a -> V3 a

-- | Convert a 3x3 matrix to a 4x4 matrix extending it with 0's in the new
--   row and column.
m33_to_m44 :: Num a => M33 a -> M44 a

-- | Extract the translation vector (first three entries of the last
--   column) from a 3x4 or 4x4 matrix.
translation :: (Vec t, R3 t, R4 v) => Lens' (t (v a)) (V3 a)

-- | Build a transformation matrix from a rotation matrix and a translation
--   vector.
mkTransformationMat :: Num a => M33 a -> V3 a -> M44 a

-- | Build a transformation matrix from a rotation expressed as a
--   <a>Quaternion</a> and a translation vector.
mkTransformation :: Num a => Quaternion a -> V3 a -> M44 a

-- | Build a look at view matrix
lookAt :: Floating a => V3 a -> V3 a -> V3 a -> M44 a

-- | Build a matrix for a symmetric perspective-view frustum
perspective :: Floating a => a -> a -> a -> a -> M44 a

-- | Build an inverse perspective matrix
inversePerspective :: Floating a => a -> a -> a -> a -> M44 a

-- | Build a perspective matrix per the classic <tt>glFrustum</tt>
--   arguments.
frustum :: Floating a => a -> a -> a -> a -> a -> a -> M44 a
inverseFrustum :: Floating a => a -> a -> a -> a -> a -> a -> M44 a

-- | Build a matrix for a symmetric perspective-view frustum with a far
--   plane at infinite
infinitePerspective :: Floating a => a -> a -> a -> M44 a
inverseInfinitePerspective :: Floating a => a -> a -> a -> M44 a

-- | Build an orthographic perspective matrix from 6 clipping planes. This
--   matrix takes the region delimited by these planes and maps it to
--   normalized device coordinates between [-1,1]
--   
--   This call is designed to mimic the parameters to the OpenGL
--   <tt>glOrtho</tt> call, so it has a slightly strange convention:
--   Notably: the near and far planes are negated.
--   
--   Consequently:
--   
--   <pre>
--   <a>ortho</a> l r b t n f !* <a>V4</a> l b (-n) 1 = <a>V4</a> (-1) (-1) (-1) 1
--   <a>ortho</a> l r b t n f !* <a>V4</a> r t (-f) 1 = <a>V4</a> 1 1 1 1
--   </pre>
--   
--   Examples:
--   
--   <pre>
--   &gt;&gt;&gt; ortho 1 2 3 4 5 6 !* V4 1 3 (-5) 1
--   V4 (-1.0) (-1.0) (-1.0) 1.0
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ortho 1 2 3 4 5 6 !* V4 2 4 (-6) 1
--   V4 1.0 1.0 1.0 1.0
--   </pre>
ortho :: Fractional a => a -> a -> a -> a -> a -> a -> M44 a

-- | Build an inverse orthographic perspective matrix from 6 clipping
--   planes
inverseOrtho :: Fractional a => a -> a -> a -> a -> a -> a -> M44 a


-- | Functions for working with 2-dimensional homogeneous coordinates.
module Nonlinear.Projective.Hom2

-- | Convert a 2-dimensional affine vector into a 3-dimensional homogeneous
--   vector, i.e. sets the <tt>w</tt> coordinate to 0.
vector :: Num a => V2 a -> V3 a

-- | Convert a 2-dimensional affine point into a 3-dimensional homogeneous
--   vector, i.e. sets the <tt>w</tt> coordinate to 1.
point :: Num a => V2 a -> V3 a

-- | Convert 3-dimensional projective coordinates to a 2-dimensional point.
--   This operation may be denoted, <tt>euclidean [x:y:w] = (x/w, y/w)</tt>
--   where the projective, homogeneous, coordinate <tt>[x:y:z]</tt> is one
--   of many associated with a single point <tt>(x/w, y/w)</tt>.
normalizePoint :: Fractional a => V3 a -> V2 a
mkTransformation :: Num a => M22 a -> V2 a -> M33 a

-- | translate along two axes
translation :: Num a => V2 a -> M33 a

-- | rotate a radiant angle
rotateRad :: Floating a => a -> M33 a

-- | Convert a 2x2 matrix to a 3x3 matrix extending it with 0's in the new
--   row and column.
m22_to_m33 :: Num a => M22 a -> M33 a

module Nonlinear