Vec-1.0.5: Fixed-length lists and low-dimensional linear algebra.

Data.Vec.Packed

Description

Packed vectors : use these whenever possible. The polymorphic vector type is represented at run-time by a linked list of boxed values. Specialized, or packed types, store the vector components sequentially in memory, in a single boxed value. Definitions for vector operations, given in terms of polymorphic vectors, can be (almost) automatically propagated to packed types using the functions `pack` and `unpack`. The compiler can then specialize the definition to the packed type and produce efficient code.

Packed vectors are related to their unpacked representations by way of an associated type. An instance of class `PackedVec v` declares that `v` has a packed representation, and the type of that is `Packed v`. The packed constructors are named `Vec`NT where N is 2, 3 or 4 and T is `I`, `F` or `D` for `Int`, `Float` or `Double`. So the expression `Vec3D x y z` constructs a packed 3-vector of Doubles, the type of which is ```Packed (Vec3 Double)```. The constructor name is also a synonym for the packed type name, i.e., `type Vec3D = Packed (Vec3 Double)`, so the packed type acts as if it had been declared `data Vec3D = Vec3D x y z`.

`Storable`, `Num`, `Fractional`, `Fold`, `Map`, and `ZipWith` instances are provided for packed vectors, so some operations do not require pack/unpack. For example, `dot` does not require pack/unpack because it is defined in terms of `zipWith` and `fold`. However `transpose`, `det`, `gaussElim` and most others are recursive (i.e., defined in terms of the same operation on lower-dimensional vectors), and so you'll still need to use pack/unpack with these. This goes for `multmm` as well because it uses `transpose`. Some functions, like `multmv`, do not need their arguments to be unpacked, but the result is a polymorphic vector `(:.)`, so you will need to pack it again. I admit that this is awkward, and I'm still looking for a better way.

There are also instances for `Access`, `Take`, `Drop`, `Last`, `Head`, `Tail` and `Snoc`. These come in handy for things like quaternions and homogenous coordinates.

Synopsis

# Documentation

class PackedVec v whereSource

PackedVec class : relates a vector type to its space-optimized representation.

Associated Types

data Packed v Source

The packed representation of `v`

Methods

pack :: v -> Packed vSource

unpack :: Packed v -> vSource

Instances

 PackedVec (Vec4 Bool) PackedVec (Vec4 Double) PackedVec (Vec4 Float) PackedVec (Vec4 Int) PackedVec (Vec4 CInt) PackedVec (Vec4 CFloat) PackedVec (Vec4 CDouble) PackedVec (Vec3 Bool) PackedVec (Vec3 Double) PackedVec (Vec3 Float) PackedVec (Vec3 Int) PackedVec (Vec3 CInt) PackedVec (Vec3 CFloat) PackedVec (Vec3 CDouble) PackedVec (Vec2 Bool) PackedVec (Vec2 Double) PackedVec (Vec2 Float) PackedVec (Vec2 Int) PackedVec (Vec2 CInt) PackedVec (Vec2 CFloat) PackedVec (Vec2 CDouble)

packMat :: (Map row (Packed row) mat packedMat, PackedVec row) => mat -> packedMatSource

Construct a semi-packed matrix, one whose rows are packed.

unpackMat :: (Map (Packed row) row packedMat mat, PackedVec row) => packedMat -> matSource