RSAGL.Math.AbstractVector

Provides generic typeclasses for common operations among many types: addition, subtraction, scalar multiplication, magnitude, and zero.

Documentation

class (AbstractZero v, AbstractAdd v v, AbstractSubtract v v, AbstractScale v) => AbstractVector v

A convenience class for many vector types.

Instances

AbstractVector Double

AbstractVector Float

AbstractVector RSdouble

AbstractVector RSfloat

AbstractVector Angle

AbstractVector Vector3D

AbstractVector a => AbstractVector [a]

HasResolution a => AbstractVector (Fixed a)

(AbstractVector a, AbstractVector b) => AbstractVector (a, b)

class AbstractZero a where

A data type that has an additive identity.

Methods

zero :: a

Instances

AbstractZero Double

AbstractZero Float

AbstractZero Integer

AbstractZero RSdouble

AbstractZero RSfloat

AbstractZero BoundAngle

AbstractZero Angle

AbstractZero Vector3D

AbstractZero Point3D

AbstractZero a => AbstractZero [a]

HasResolution a => AbstractZero (Fixed a)

(AbstractZero a, AbstractZero b) => AbstractZero (a, b)

class AbstractAdd p v | p -> v where

A data type that supports addition.

• a add zero = a

Methods

add :: p -> v -> p

Instances

AbstractAdd Double Double

AbstractAdd Float Float

AbstractAdd Integer Integer

AbstractAdd RSdouble RSdouble

AbstractAdd RSfloat RSfloat

AbstractAdd BoundAngle Angle

AbstractAdd Angle Angle

AbstractAdd Vector3D Vector3D

AbstractAdd Point3D Vector3D

AbstractAdd a b => AbstractAdd [a] [b]

HasResolution a => AbstractAdd (Fixed a) (Fixed a)

AbstractAdd a a' => AbstractAdd (x -> a) (x -> a')

(AbstractAdd a a', AbstractAdd b b') => AbstractAdd (a, b) (a', b')

class AbstractSubtract p v | p -> v where

A data type that supports subtraction.

• a sub a = zero

Methods

sub :: p -> p -> v

Instances

AbstractSubtract Double Double

AbstractSubtract Float Float

AbstractSubtract Integer Integer

AbstractSubtract RSdouble RSdouble

AbstractSubtract RSfloat RSfloat

AbstractSubtract BoundAngle Angle

AbstractSubtract Angle Angle

AbstractSubtract Vector3D Vector3D

AbstractSubtract Point3D Vector3D

AbstractSubtract a b => AbstractSubtract [a] [b]

HasResolution a => AbstractSubtract (Fixed a) (Fixed a)

AbstractSubtract a a' => AbstractSubtract (x -> a) (x -> a')

(AbstractSubtract a a', AbstractSubtract b b') => AbstractSubtract (a, b) (a', b')

class AbstractScale v where

A data type that supports scalar multiplication.

• scalarMultiply 0 a = zero

Methods

scalarMultiply :: RSdouble -> v -> v

Instances

AbstractScale Double

AbstractScale Float

AbstractScale RSdouble

AbstractScale RSfloat

AbstractScale Angle

AbstractScale Vector3D

AbstractScale a => AbstractScale [a]

HasResolution a => AbstractScale (Fixed a)

AbstractScale a => AbstractScale (x -> a)

(AbstractScale a, AbstractScale b) => AbstractScale (a, b)

class AbstractMagnitude v where

A data type that supports scalar magnitude.

• magnitude (scalarMultiply (recip $ magnitude a) a) = 1

Methods

magnitude :: v -> RSdouble

Instances

AbstractMagnitude Double

AbstractMagnitude Float

AbstractMagnitude Integer

AbstractMagnitude RSdouble

AbstractMagnitude RSfloat

AbstractMagnitude Angle

AbstractMagnitude Vector3D

AbstractMagnitude a => AbstractMagnitude [a]

HasResolution a => AbstractMagnitude (Fixed a)

(AbstractMagnitude a, AbstractMagnitude b) => AbstractMagnitude (a, b)

abstractScaleTo :: (AbstractScale v, AbstractMagnitude v) => RSdouble -> v -> v

Force a vector to the specified magnitude.

abstractSum :: (AbstractAdd p v, AbstractZero p) => [v] -> p

Sum of a list.

abstractAverage :: (AbstractAdd p v, AbstractSubtract p v, AbstractVector v, AbstractZero p) => [p] -> p

Average of a list.

abstractDistance :: (AbstractMagnitude v, AbstractSubtract p v) => p -> p -> RSdouble

Distance between two points, based on the magnitude of the difference.