Data.Vect.Double.Base

Documentation

class AbelianGroup g where

Methods

(&+) :: g -> g -> g

(&-) :: g -> g -> g

neg :: g -> g

zero :: g

Instances

AbelianGroup Mat4

AbelianGroup Mat3

AbelianGroup Mat2

AbelianGroup Vec4

AbelianGroup Vec3

AbelianGroup Vec2

AbelianGroup Quaternion

vecSum :: AbelianGroup g => [g] -> g

class MultSemiGroup r where

Methods

(.*.) :: r -> r -> r

one :: r

Instances

MultSemiGroup Proj4

MultSemiGroup Proj3

MultSemiGroup Ortho4

MultSemiGroup Ortho3

MultSemiGroup Ortho2

MultSemiGroup Mat4

MultSemiGroup Mat3

MultSemiGroup Mat2

MultSemiGroup UnitQuaternion

MultSemiGroup Quaternion

class (AbelianGroup r, MultSemiGroup r) => Ring r

Instances

Ring Mat4

Ring Mat3

Ring Mat2

semigroupProduct :: MultSemiGroup r => [r] -> r

class LeftModule r m where

Methods

lmul :: r -> m -> m

(*.) :: r -> m -> m

Instances

LeftModule Mat4 Vec4

LeftModule Mat3 Vec3

LeftModule Mat2 Vec2

LeftModule UnitQuaternion Vec3

class RightModule m r where

Methods

rmul :: m -> r -> m

(.*) :: m -> r -> m

Instances

RightModule Vec4 Mat4

RightModule Vec3 Mat3

RightModule Vec2 Mat2

class AbelianGroup v => Vector v where

Methods

mapVec :: (Double -> Double) -> v -> v

scalarMul :: Double -> v -> v

(*&) :: Double -> v -> v

(&*) :: v -> Double -> v

Instances

Vector Mat4

Vector Mat3

Vector Mat2

Vector Vec4

Vector Vec3

Vector Vec2

Vector Quaternion

class DotProd v where

Methods

(&.) :: v -> v -> Double

norm :: v -> Double

normsqr :: v -> Double

len :: v -> Double

lensqr :: v -> Double

dotprod :: v -> v -> Double

Instances

DotProd Normal4

DotProd Normal3

DotProd Normal2

DotProd Vec4

DotProd Vec3

DotProd Vec2

DotProd UnitQuaternion

DotProd Quaternion

class CrossProd v where

Cross product

Methods

crossprod :: v -> v -> v

(&^) :: v -> v -> v

Instances

CrossProd Normal3

CrossProd Vec3

normalize :: (Vector v, DotProd v) => v -> v

distance :: (Vector v, DotProd v) => v -> v -> Double

angle :: (Vector v, DotProd v) => v -> v -> Double

the angle between two vectors

angle' :: (Vector v, UnitVector v u, DotProd v) => u -> u -> Double

the angle between two unit vectors

class (Vector v, DotProd v) => UnitVector v u | v -> u, u -> v where

Methods

mkNormal

Arguments

:: v

-> u

normalizes the input

toNormalUnsafe

Arguments

:: v

-> u

does not normalize the input!

fromNormal :: u -> v

fromNormalRadius :: Double -> u -> v

Instances

UnitVector Vec4 Normal4

UnitVector Vec3 Normal3

UnitVector Vec2 Normal2

UnitVector Quaternion UnitQuaternion

class Pointwise v where

Pointwise multiplication

Methods

pointwise :: v -> v -> v

(&!) :: v -> v -> v

Instances

Pointwise Mat4

Pointwise Mat3

Pointwise Mat2

Pointwise Vec4

Pointwise Vec3

Pointwise Vec2

class Extend u v where

conversion between vectors (and matrices) of different dimensions

Methods

extendZero

Arguments

:: u

-> v

example: extendZero (Vec2 5 6) = Vec4 5 6 0 0

extendWith

Arguments

:: Double

-> u

-> v

example: extendWith 1 (Vec2 5 6) = Vec4 5 6 1 1

trim

Arguments

:: v

-> u

example: trim (Vec4 5 6 7 8) = Vec2 5 6

Instances

Extend Mat3 Mat4

Extend Mat2 Mat4

Extend Mat2 Mat3

Extend Vec3 Vec4

Extend Vec2 Vec4

Extend Vec2 Vec3

class HasCoordinates v x | v -> x where

Methods

_1 :: v -> x

_2 :: v -> x

_3 :: v -> x

_4 :: v -> x

Instances

HasCoordinates Mat4 Vec4

HasCoordinates Mat3 Vec3

HasCoordinates Mat2 Vec2

HasCoordinates Vec4 Double

HasCoordinates Vec3 Double

HasCoordinates Vec2 Double

class Dimension a where

Methods

dim :: a -> Int

Instances

Dimension Ortho4

Dimension Ortho3

Dimension Ortho2

Dimension Normal4

Dimension Normal3

Dimension Normal2

Dimension Mat4

Dimension Mat3

Dimension Mat2

Dimension Vec4

Dimension Vec3

Dimension Vec2

class Matrix m where

Methods

transpose :: m -> m

inverse :: m -> m

idmtx :: m

Instances

Matrix Proj4

Matrix Proj3

Matrix Ortho4

Matrix Ortho3

Matrix Ortho2

Matrix Mat4

Matrix Mat3

Matrix Mat2

class Tensor t v | t -> v where

Outer product (could be unified with Diagonal?)

Methods

outer :: v -> v -> t

Instances

Tensor Mat4 Vec4

Tensor Mat3 Vec3

Tensor Mat2 Vec2

class Diagonal s t | t -> s where

makes a diagonal matrix from a vector

Methods

diag :: s -> t

Instances

Diagonal Vec4 Mat4

Diagonal Vec3 Mat3

Diagonal Vec2 Mat2

class Determinant m where

Methods

det :: m -> Double

Instances

Determinant Ortho4

Determinant Ortho3

Determinant Ortho2

Determinant Mat4

Determinant Mat3

Determinant Mat2

Determinant (Vec2, Vec2)

Determinant (Vec3, Vec3, Vec3)

class Matrix m => Orthogonal m o | m -> o, o -> m where

Methods

fromOrtho :: o -> m

toOrthoUnsafe :: m -> o

Instances

Orthogonal Mat4 Ortho4

Orthogonal Mat3 Ortho3

Orthogonal Mat2 Ortho2

class (Vector v, Orthogonal n o, Diagonal v n) => Projective v n o m p | m -> p, p -> m, p -> o, o -> p, p -> n, n -> p, p -> v, v -> p, n -> o, n -> v, v -> n where

"Projective" matrices have the following form: the top left corner is an any matrix, the bottom right corner is 1, and the top-right column is zero. These describe the affine orthogonal transformation of the space one dimension less.

Methods

fromProjective :: p -> m

toProjectiveUnsafe :: m -> p

orthogonal :: o -> p

linear :: n -> p

translation :: v -> p

scaling :: v -> p

Instances

Projective Vec3 Mat3 Ortho3 Mat4 Proj4

Projective Vec2 Mat2 Ortho2 Mat3 Proj3

class (AbelianGroup m, Matrix m) => MatrixNorms m where

Methods

frobeniusNorm

Arguments

:: m

-> Double

the frobenius norm (= euclidean norm in the space of matrices)

matrixDistance

Arguments

:: m

-> m

-> Double

euclidean distance in the space of matrices

operatorNorm

Arguments

:: m

-> Double

(euclidean) operator norm (not implemented yet)

Instances

MatrixNorms Mat4

MatrixNorms Mat3

MatrixNorms Mat2

data Vec2

Constructors

Vec2 !Double !Double

Instances

Eq Vec2

Fractional Vec2

Num Vec2

Read Vec2

Show Vec2

Storable Vec2

Random Vec2

Dimension Vec2

Pointwise Vec2

DotProd Vec2

Vector Vec2

AbelianGroup Vec2

Interpolate Vec2

Tensor Mat2 Vec2

Diagonal Vec2 Mat2

Extend Vec2 Vec4

Extend Vec2 Vec3

HasCoordinates Mat2 Vec2

HasCoordinates Vec2 Double

UnitVector Vec2 Normal2

RightModule Vec2 Mat2

LeftModule Mat2 Vec2

Projective Vec2 Mat2 Ortho2 Mat3 Proj3

Determinant (Vec2, Vec2)

GramSchmidt (Vec2, Vec2)

data Vec3

Constructors

Vec3 !Double !Double !Double

Instances

Eq Vec3

Fractional Vec3

Num Vec3

Read Vec3

Show Vec3

Storable Vec3

Random Vec3

Dimension Vec3

Pointwise Vec3

CrossProd Vec3

DotProd Vec3

Vector Vec3

AbelianGroup Vec3

Interpolate Vec3

Tensor Mat3 Vec3

Diagonal Vec3 Mat3

Extend Vec3 Vec4

Extend Vec2 Vec3

HasCoordinates Mat3 Vec3

HasCoordinates Vec3 Double

UnitVector Vec3 Normal3

RightModule Vec3 Mat3

LeftModule Mat3 Vec3

LeftModule UnitQuaternion Vec3

Projective Vec3 Mat3 Ortho3 Mat4 Proj4

GramSchmidt (Vec3, Vec3)

Determinant (Vec3, Vec3, Vec3)

GramSchmidt (Vec3, Vec3, Vec3)

data Vec4

Constructors

Vec4 !Double !Double !Double !Double

Instances

Eq Vec4

Fractional Vec4

Num Vec4

Read Vec4

Show Vec4

Storable Vec4

Random Vec4

Dimension Vec4

Pointwise Vec4

DotProd Vec4

Vector Vec4

AbelianGroup Vec4

Interpolate Vec4

Tensor Mat4 Vec4

Diagonal Vec4 Mat4

Extend Vec3 Vec4

Extend Vec2 Vec4

HasCoordinates Mat4 Vec4

HasCoordinates Vec4 Double

UnitVector Vec4 Normal4

RightModule Vec4 Mat4

LeftModule Mat4 Vec4

GramSchmidt (Vec4, Vec4)

GramSchmidt (Vec4, Vec4, Vec4)

GramSchmidt (Vec4, Vec4, Vec4, Vec4)

data Mat2

The components are row vectors

Constructors

Mat2 !Vec2 !Vec2

Instances

Eq Mat2

Fractional Mat2

Num Mat2

Read Mat2

Show Mat2

Storable Mat2

Random Mat2

Dimension Mat2

Determinant Mat2

MatrixNorms Mat2

Matrix Mat2

Pointwise Mat2

Vector Mat2

Ring Mat2

MultSemiGroup Mat2

AbelianGroup Mat2

Tensor Mat2 Vec2

Orthogonal Mat2 Ortho2

Diagonal Vec2 Mat2

Extend Mat2 Mat4

Extend Mat2 Mat3

HasCoordinates Mat2 Vec2

RightModule Vec2 Mat2

LeftModule Mat2 Vec2

Projective Vec2 Mat2 Ortho2 Mat3 Proj3

data Mat3

Constructors

Mat3 !Vec3 !Vec3 !Vec3

Instances

Eq Mat3

Fractional Mat3

Num Mat3

Read Mat3

Show Mat3

Storable Mat3

Random Mat3

Dimension Mat3

Determinant Mat3

MatrixNorms Mat3

Matrix Mat3

Pointwise Mat3

Vector Mat3

Ring Mat3

MultSemiGroup Mat3

AbelianGroup Mat3

Tensor Mat3 Vec3

Orthogonal Mat3 Ortho3

Diagonal Vec3 Mat3

Extend Mat3 Mat4

Extend Mat2 Mat3

HasCoordinates Mat3 Vec3

RightModule Vec3 Mat3

LeftModule Mat3 Vec3

Projective Vec3 Mat3 Ortho3 Mat4 Proj4

Projective Vec2 Mat2 Ortho2 Mat3 Proj3

data Mat4

Constructors

Mat4 !Vec4 !Vec4 !Vec4 !Vec4

Instances

Eq Mat4

Fractional Mat4

Num Mat4

Read Mat4

Show Mat4

Storable Mat4

Random Mat4

Dimension Mat4

Determinant Mat4

MatrixNorms Mat4

Matrix Mat4

Pointwise Mat4

Vector Mat4

Ring Mat4

MultSemiGroup Mat4

AbelianGroup Mat4

Tensor Mat4 Vec4

Orthogonal Mat4 Ortho4

Diagonal Vec4 Mat4

Extend Mat3 Mat4

Extend Mat2 Mat4

HasCoordinates Mat4 Vec4

RightModule Vec4 Mat4

LeftModule Mat4 Vec4

Projective Vec3 Mat3 Ortho3 Mat4 Proj4

data Ortho2

Orthogonal matrices.

Note: the Random instances generates orthogonal matrices with determinant 1 (that is, orientation-preserving orthogonal transformations)!

Instances

Read Ortho2

Show Ortho2

Storable Ortho2

Random Ortho2

Dimension Ortho2

Determinant Ortho2

Matrix Ortho2

MultSemiGroup Ortho2

Orthogonal Mat2 Ortho2

Projective Vec2 Mat2 Ortho2 Mat3 Proj3

data Ortho3

Instances

Read Ortho3

Show Ortho3

Storable Ortho3

Random Ortho3

Dimension Ortho3

Determinant Ortho3

Matrix Ortho3

MultSemiGroup Ortho3

Orthogonal Mat3 Ortho3

Projective Vec3 Mat3 Ortho3 Mat4 Proj4

data Ortho4

Instances

Read Ortho4

Show Ortho4

Storable Ortho4

Random Ortho4

Dimension Ortho4

Determinant Ortho4

Matrix Ortho4

MultSemiGroup Ortho4

Orthogonal Mat4 Ortho4

data Normal2

The assumption when dealing with these is always that they are of unit length. Also, interpolation works differently.

Instances

Read Normal2

Show Normal2

Storable Normal2

Random Normal2

Dimension Normal2

DotProd Normal2

Interpolate Normal2

UnitVector Vec2 Normal2

GramSchmidt (Normal2, Normal2)

data Normal3

Instances

Read Normal3

Show Normal3

Storable Normal3

Random Normal3

Dimension Normal3

CrossProd Normal3

DotProd Normal3

Interpolate Normal3

UnitVector Vec3 Normal3

GramSchmidt (Normal3, Normal3)

GramSchmidt (Normal3, Normal3, Normal3)

data Normal4

Instances

Read Normal4

Show Normal4

Storable Normal4

Random Normal4

Dimension Normal4

DotProd Normal4

Interpolate Normal4

UnitVector Vec4 Normal4

GramSchmidt (Normal4, Normal4)

GramSchmidt (Normal4, Normal4, Normal4)

GramSchmidt (Normal4, Normal4, Normal4, Normal4)

data Proj3

Projective matrices, encoding affine transformations in dimension one less.

Instances

Read Proj3

Show Proj3

Storable Proj3

Matrix Proj3

MultSemiGroup Proj3

Projective Vec2 Mat2 Ortho2 Mat3 Proj3

data Proj4

Instances

Read Proj4

Show Proj4

Storable Proj4

Matrix Proj4

MultSemiGroup Proj4

Projective Vec3 Mat3 Ortho3 Mat4 Proj4

mkVec2 :: (Double, Double) -> Vec2

mkVec3 :: (Double, Double, Double) -> Vec3

mkVec4 :: (Double, Double, Double, Double) -> Vec4

project :: (Vector v, DotProd v) => v -> v -> v

project' :: (Vector v, UnitVector v u, DotProd v) => v -> u -> v

Projects the first vector down to the hyperplane orthogonal to the second (unit) vector

projectUnsafe :: (Vector v, DotProd v) => v -> v -> v

Direction (second argument) is assumed to be a unit vector!

flipNormal :: UnitVector v n => n -> n

Since unit vectors are not a group, we need a separate function.

householder :: (Vector v, UnitVector v u, Matrix m, Vector m, Tensor m v) => u -> m

Householder matrix, see http://en.wikipedia.org/wiki/Householder_transformation. In plain words, it is the reflection to the hyperplane orthogonal to the input vector.

householderOrtho :: (Vector v, UnitVector v u, Matrix m, Vector m, Tensor m v, Orthogonal m o) => u -> o