Safe Haskell | None |
---|

- class Vec3 v where
- data Matrix v
- origin :: v
- fromXYZ :: (Double, Double, Double) -> v
- toXYZ :: v -> (Double, Double, Double)
- zipWith :: (Double -> Double -> Double) -> v -> v -> v
- (<+>) :: v -> v -> v
- (<->) :: v -> v -> v
- (><) :: v -> v -> v
- (.^) :: v -> Double -> v
- (.*) :: v -> v -> Double
- norm :: v -> Double
- normalize :: v -> v
- distance :: v -> v -> Double
- invert :: v -> v
- fromRows :: (v, v, v) -> Matrix v
- toRows :: Matrix v -> (v, v, v)
- dotM :: v -> v -> Matrix v -> Double
- mxv :: Matrix v -> v -> v
- diag :: Double -> Matrix v
- vxv :: v -> v -> Matrix v
- addM :: Matrix v -> Matrix v -> Matrix v

- data UVec3 = UVec3 !Double !Double !Double
- data SVec3 = SVec3 !CDouble !CDouble !CDouble
- newtype TUVec3 = TUVec3 (Double, Double, Double)

# Documentation

Three-dimensional vector, with an associated matrix type.

Origin point `(0, 0, 0)`

.

fromXYZ :: (Double, Double, Double) -> vSource

Construct a new vector from components.

toXYZ :: v -> (Double, Double, Double)Source

Deconstruct a vector into components.

zipWith :: (Double -> Double -> Double) -> v -> v -> vSource

Zip two vectors elementwise.

Add two vectors.

Subtract two vectors.

Cross product.

(.^) :: v -> Double -> vSource

Scale a vector.

(.*) :: v -> v -> DoubleSource

Dot product.

Euclidean norm of a vector.

Produce unit vector with the same direction as the original one.

distance :: v -> v -> DoubleSource

Distance between two points.

Invert the direction of a vector.

fromRows :: (v, v, v) -> Matrix vSource

Construct a new matrix from rows.

toRows :: Matrix v -> (v, v, v)Source

Deconstruct a matrix into rows.

dotM :: v -> v -> Matrix v -> DoubleSource

Generic vector dot product.

Multiply the transpose of the first vector by the given matrix, then multiply the result by the second vector.

[ a11 a12 a13 ] [ v2x ] [ ] [ ] [ v1x v1y v1z ] . [ a21 a22 a23 ] . [ v2y ] = s [ ] [ ] [ a31 a32 a33 ] [ v2z ]

mxv :: Matrix v -> v -> vSource

Multiply a matrix and a vector.

[ a11 a12 a13 ] [ v2x ] [ rx ] [ ] [ ] [ ] [ a21 a22 a23 ] . [ v2y ] = [ ry ] [ ] [ ] [ ] [ a31 a32 a33 ] [ v2z ] [ rz ]

diag :: Double -> Matrix vSource

Build a diagonal matrix from a number `d`

.

[ d 0 0 ] [ ] [ 0 d 0 ] [ ] [ 0 0 d ]

vxv :: v -> v -> Matrix vSource

Transpose a vector and multiply it by another vector, producing a matrix.

[ v1x ] [ r11 r12 r13 ] [ ] [ ] [ v1y ] . [ v2x v2y v2z ] = [ r21 r22 r23 ] [ ] [ ] [ v1z ] [ r31 r32 r33 ]

addM :: Matrix v -> Matrix v -> Matrix vSource

Add two matrices.

`Vec3`

implementation with `Unbox`

instance
based on a single contiguous array storage scheme, suitable for use
with Data.Vector.Unboxed.

`Unbox`

instance provides the required index transformations.

interface: [d1 x y z ; d2 x y z ...], length = N = M / 3 | | | | | | storage: [ d1x d2y d2z ; d2x d2y d2z ...], length = M

Thanks to dense packing scheme the performance of this
implementation should generally be on par with `Storable`

-based
`SVec3`

.

`Vec3`

implementation with `Storable`

instance,
suitable for use with Data.Vector.Storable.

`Vec3`

implementation with `Unbox`

instance
based on tuples, suitable for use with Data.Vector.Unboxed.

This represents 3-vector as a triple of doubles, using the default Unbox instance for tuples as provided by Data.Vector.Unboxed, which wraps a vector of tuples as a tuple of vectors.

interface: [d1 (x, y, z); d2 (x, y, z) ...], length = N | | | | | | storage(x): [d1x-+ | | ; d2x-+ | | ...], length = N storage(y): [d1y----+ | ; d2y----+ | ...], length = N storage(z): [d1z-------+ ; d2z-------+ ...], length = N