cifl-math-library-1.1.1.0: Math libraries
Safe HaskellSafe
LanguageHaskell2010

Math.Matrix.Vector3

Synopsis

Documentation

i3 :: Num a => Vector3 a Source #

j3 :: Num a => Vector3 a Source #

k3 :: Num a => Vector3 a Source #

vec3 :: (a, a, a) -> Vector3 a Source #

finite3 :: Vector3 a -> Vec 3 a Source #

destructvec3 :: Vector3 a -> (a, a, a) Source #

setx3 :: s -> Vector3 s -> Vector3 s Source #

sety3 :: s -> Vector3 s -> Vector3 s Source #

setz3 :: s -> Vector3 s -> Vector3 s Source #

update_row3 :: g a -> Vector3 ((Vector3 :*: g) a -> (Vector3 :*: g) a) Source #

update_column3 v is a vector of all update operations that replace one row with v

update_column3 :: Applicative f => f a -> Vector3 ((f :*: Vector3) a -> (f :*: Vector3) a) Source #

update_column3 v is a vector of all update operations that replace one column with v example use: update_column3 (Vector3 3 4 5) ycoord3 identity3 == [[1,3,0],[0,4,0],[0,5,1]].

dx3_endo :: Num a => a -> Endo (Vector3 a) Source #

dy3_endo :: Num a => a -> Endo (Vector3 a) Source #

dz3_endo :: Num a => a -> Endo (Vector3 a) Source #

dx3 :: Num a => a -> Vector3 a -> Vector3 a Source #

dy3 :: Num a => a -> Vector3 a -> Vector3 a Source #

dz3 :: Num a => a -> Vector3 a -> Vector3 a Source #

op_dot :: Num b => Vector3 (a -> b) -> a -> b Source #

cube_norm3 :: Floating a => Vector3 a -> a Source #

cube root of a sum of cubes.

nth_norm3 :: Floating a => a -> Vector3 a -> a Source #

nth root of a sum of nth powers

mapBasis :: Num a => (Vector3 a -> Vector3 a) -> Vector3 a -> Vector3 a Source #

trace3 :: Num a => Matrix3 a -> a Source #

vector3 :: [a] -> Vector3 a Source #

cross_product3 :: Num a => (Vector2 :*: Vector3) a -> Vector3 a Source #

cross_product3 computes the three dimensional vector that is orthogonal to both rows of the 2x3 vector.

xid :: Num a => Vector3 a Source #

yid :: Num a => Vector3 a Source #

zid :: Num a => Vector3 a Source #

dot3 :: (Num a, ConjugateSymmetric a) => Vector3 a -> Vector3 a -> a Source #

right_multiply3_gen :: (VectorSpace (f a), ConjugateSymmetric a, Scalar (f a) ~ a) => (Vector3 :*: f) a -> Vector3 a -> f a Source #

outer3 :: (a -> b -> c) -> Vector3 a -> Vector3 b -> Matrix3 c Source #

zipWithV3 :: (a -> b -> c) -> Vector3 a -> Vector3 b -> Vector3 c Source #

eigenvalue3 :: (Floating a, Ord a, ConjugateSymmetric a) => (Vector3 :*: Vector3) a -> Vector3 a Source #

https://en.wikipedia.org/wiki/Eigenvalue_algorithm based on algorithm by Smith, Oliver K.: Eigenvalues of symmetric 3x3 matrix, 1961, Communications of the ACM., doi:10.1145/355578.366316 The algorithm works reasonably when the matrix is real and symmetric.

cycle3 :: StreamBuilder str => Vector3 a -> str a Source #

Orphan instances

MonadZip Vector3 Source # 
Instance details

Methods

mzip :: Vector3 a -> Vector3 b -> Vector3 (a, b) #

mzipWith :: (a -> b -> c) -> Vector3 a -> Vector3 b -> Vector3 c #

munzip :: Vector3 (a, b) -> (Vector3 a, Vector3 b) #

Foldable Vector3 Source # 
Instance details

Methods

fold :: Monoid m => Vector3 m -> m #

foldMap :: Monoid m => (a -> m) -> Vector3 a -> m #

foldMap' :: Monoid m => (a -> m) -> Vector3 a -> m #

foldr :: (a -> b -> b) -> b -> Vector3 a -> b #

foldr' :: (a -> b -> b) -> b -> Vector3 a -> b #

foldl :: (b -> a -> b) -> b -> Vector3 a -> b #

foldl' :: (b -> a -> b) -> b -> Vector3 a -> b #

foldr1 :: (a -> a -> a) -> Vector3 a -> a #

foldl1 :: (a -> a -> a) -> Vector3 a -> a #

toList :: Vector3 a -> [a] #

null :: Vector3 a -> Bool #

length :: Vector3 a -> Int #

elem :: Eq a => a -> Vector3 a -> Bool #

maximum :: Ord a => Vector3 a -> a #

minimum :: Ord a => Vector3 a -> a #

sum :: Num a => Vector3 a -> a #

product :: Num a => Vector3 a -> a #

Traversable Vector3 Source # 
Instance details

Methods

traverse :: Applicative f => (a -> f b) -> Vector3 a -> f (Vector3 b) #

sequenceA :: Applicative f => Vector3 (f a) -> f (Vector3 a) #

mapM :: Monad m => (a -> m b) -> Vector3 a -> m (Vector3 b) #

sequence :: Monad m => Vector3 (m a) -> m (Vector3 a) #

Applicative Vector3 Source # 
Instance details

Methods

pure :: a -> Vector3 a #

(<*>) :: Vector3 (a -> b) -> Vector3 a -> Vector3 b #

liftA2 :: (a -> b -> c) -> Vector3 a -> Vector3 b -> Vector3 c #

(*>) :: Vector3 a -> Vector3 b -> Vector3 b #

(<*) :: Vector3 a -> Vector3 b -> Vector3 a #

Functor Vector3 Source # 
Instance details

Methods

fmap :: (a -> b) -> Vector3 a -> Vector3 b #

(<$) :: a -> Vector3 b -> Vector3 a #

Monad Vector3 Source # 
Instance details

Methods

(>>=) :: Vector3 a -> (a -> Vector3 b) -> Vector3 b #

(>>) :: Vector3 a -> Vector3 b -> Vector3 b #

return :: a -> Vector3 a #

UpdateableMatrixDimension Vector3 Source # 
Instance details

Methods

write_row :: Applicative h => h a -> Vector3 ((Vector3 :*: h) a -> (Vector3 :*: h) a) Source #

write_column :: Applicative h => h a -> Vector3 ((h :*: Vector3) a -> (h :*: Vector3) a) Source #

CircularComonad Vector3 Source # 
Instance details

Methods

rotate :: Vector3 a -> Vector3 a Source #

Coapplicative Vector3 Source # 
Instance details

Methods

coeval :: Vector3 a -> a Source #

colambda :: (Vector3 a -> Vector3 b) -> Vector3 (a -> b) Source #

Comonad Vector3 Source # 
Instance details

Methods

extract :: Vector3 a -> a Source #

duplicate :: Vector3 a -> Vector3 (Vector3 a) Source #

extend :: (Vector3 a -> b) -> Vector3 a -> Vector3 b Source #

(=>>) :: Vector3 a -> (Vector3 a -> b) -> Vector3 b Source #

(.>>) :: Vector3 a -> b -> Vector3 b Source #

FiniteComonad Vector3 Source # 
Instance details

PpShowF Vector3 Source # 
Instance details

Methods

ppf :: PpShow a => Vector3 a -> Doc Source #

PpShowVerticalF Vector3 Source # 
Instance details

Methods

ppf_vertical :: PpShow a => Vector3 a -> Doc Source #

Unfoldable Vector3 Source # 
Instance details

Methods

unfoldF :: forall (m :: Type -> Type) s a. Monad m => StateT s m a -> StateT s m (Vector3 a) Source #

AppendableVector Vector1 Vector2 Source # 
Instance details

Associated Types

type Vector1 :+: Vector2 :: Type -> Type Source #

Methods

(||>>) :: Vector1 a -> Vector2 a -> (Vector1 :+: Vector2) a Source #

AppendableVector Vector2 Vector1 Source # 
Instance details

Associated Types

type Vector2 :+: Vector1 :: Type -> Type Source #

Methods

(||>>) :: Vector2 a -> Vector1 a -> (Vector2 :+: Vector1) a Source #

CodiagonalMatrix Vector3 a Source # 
Instance details

Associated Types

data Codiagonal Vector3 a Source #

type Vector3 \\ a Source #

Num a => Diagonalizable Vector3 a Source # 
Instance details

(Floating a, Ord a, ConjugateSymmetric a) => EigenDecomposable Vector3 a Source # 
Instance details

Num a => Indexable Vector3 a Source # 
Instance details

Fractional a => Invertible Vector3 a Source # 
Instance details

ProjectionSpace Vector3 Vector1 Source # 
Instance details

Associated Types

data (Vector3 \\\ Vector1) a Source #

ProjectionSpace Vector3 Vector2 Source # 
Instance details

Associated Types

data (Vector3 \\\ Vector2) a Source #

SplittableVector Vector1 Vector2 Source # 
Instance details

Methods

vsplit :: (Vector1 :+: Vector2) a -> (Vector1 a, Vector2 a) Source #

SplittableVector Vector2 Vector1 Source # 
Instance details

Methods

vsplit :: (Vector2 :+: Vector1) a -> (Vector2 a, Vector1 a) Source #

Num a => Traceable Vector3 a Source # 
Instance details

(Num a, ConjugateSymmetric a) => LinearTransform Vector1 Vector3 a Source # 
Instance details

(Num a, ConjugateSymmetric a) => LinearTransform Vector2 Vector3 a Source # 
Instance details

(Num a, ConjugateSymmetric a) => LinearTransform Vector3 Vector1 a Source # 
Instance details

(Num a, ConjugateSymmetric a) => LinearTransform Vector3 Vector2 a Source # 
Instance details

(Num a, ConjugateSymmetric a) => LinearTransform Vector3 Vector3 a Source # 
Instance details

Transposable Vector1 Vector3 a Source # 
Instance details

Transposable Vector2 Vector3 a Source # 
Instance details

Transposable Vector3 Vector1 a Source # 
Instance details

Transposable Vector3 Vector2 a Source # 
Instance details

Transposable Vector3 Vector3 a Source # 
Instance details

Transposable Stream Vector3 a Source # 
Instance details

(Monad str, Limiting str a) => Limiting str (Vector3 a) Source # 
Instance details

Associated Types

data Closure str (Vector3 a) Source #

Methods

limit :: str (Vector3 a) -> Closure str (Vector3 a) Source #

approximations :: Closure str (Vector3 a) -> str (Vector3 a) Source #

Transposable Vector3 ((->) row) a Source # 
Instance details

Methods

transpose_impl :: (Vector3 :*: (->) row) a -> ((->) row :*: Vector3) a Source #

Data a => Data (Vector3 a) Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector3 a -> c (Vector3 a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector3 a) #

toConstr :: Vector3 a -> Constr #

dataTypeOf :: Vector3 a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector3 a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector3 a)) #

gmapT :: (forall b. Data b => b -> b) -> Vector3 a -> Vector3 a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector3 a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector3 a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector3 a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector3 a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector3 a -> m (Vector3 a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector3 a -> m (Vector3 a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector3 a -> m (Vector3 a) #

Applicative (Codiagonal Vector3) Source # 
Instance details

Functor (Codiagonal Vector3) Source # 
Instance details

Methods

fmap :: (a -> b) -> Codiagonal Vector3 a -> Codiagonal Vector3 b #

(<$) :: a -> Codiagonal Vector3 b -> Codiagonal Vector3 a #

Num s => Monoid (Vector3 s) Source # 
Instance details

Methods

mempty :: Vector3 s #

mappend :: Vector3 s -> Vector3 s -> Vector3 s #

mconcat :: [Vector3 s] -> Vector3 s #

Num s => Semigroup (Vector3 s) Source # 
Instance details

Methods

(<>) :: Vector3 s -> Vector3 s -> Vector3 s #

sconcat :: NonEmpty (Vector3 s) -> Vector3 s #

stimes :: Integral b => b -> Vector3 s -> Vector3 s #

Generic a => Generic (Vector3 a) Source # 
Instance details

Associated Types

type Rep (Vector3 a) :: Type -> Type #

Methods

from :: Vector3 a -> Rep (Vector3 a) x #

to :: Rep (Vector3 a) x -> Vector3 a #

Num a => Num (Vector3 a) Source # 
Instance details

Methods

(+) :: Vector3 a -> Vector3 a -> Vector3 a #

(-) :: Vector3 a -> Vector3 a -> Vector3 a #

(*) :: Vector3 a -> Vector3 a -> Vector3 a #

negate :: Vector3 a -> Vector3 a #

abs :: Vector3 a -> Vector3 a #

signum :: Vector3 a -> Vector3 a #

fromInteger :: Integer -> Vector3 a #

Read a => Read (Vector3 a) Source # 
Instance details

Show a => Show (Vector3 a) Source # 
Instance details

Methods

showsPrec :: Int -> Vector3 a -> ShowS #

show :: Vector3 a -> String #

showList :: [Vector3 a] -> ShowS #

Binary s => Binary (Vector3 s) Source # 
Instance details

Methods

put :: Vector3 s -> Put #

get :: Get (Vector3 s) #

putList :: [Vector3 s] -> Put #

ConjugateSymmetric a => ConjugateSymmetric (Vector3 a) Source # 
Instance details

Methods

conj :: Vector3 a -> Vector3 a Source #

Num a => CoordinateSpace (Vector3 a) Source # 
Instance details

Associated Types

type Coordinate (Vector3 a) Source #

(ConjugateSymmetric a, Num a) => InnerProductSpace (Vector3 a) Source # 
Instance details

Methods

(%.) :: Vector3 a -> Vector3 a -> Scalar (Vector3 a) Source #

Num a => LieAlgebra (Vector3 a) Source #

https://en.wikipedia.org/wiki/Lie_algebra

Instance details

Methods

(%<>%) :: Vector3 a -> Vector3 a -> Vector3 a Source #

(Floating a, ConjugateSymmetric a) => NormedSpace (Vector3 a) Source # 
Instance details

Num a => StandardBasis (Vector3 a) Source # 
Instance details

Num a => VectorSpace (Vector3 a) Source # 
Instance details

Associated Types

type Scalar (Vector3 a) Source #

Num s => Group (Vector3 s) Source # 
Instance details

Methods

ginvert :: Vector3 s -> Vector3 s Source #

ShowPrecision s => ShowPrecision (Vector3 s) Source # 
Instance details

MedianAlgebra s => MedianAlgebra (Vector3 s) Source # 
Instance details

Methods

med :: Vector3 s -> Vector3 s -> Vector3 s -> Vector3 s Source #

PpShow a => PpShow (Vector3 a) Source # 
Instance details

Methods

pp :: Vector3 a -> Doc Source #

Universe a => Universe (Vector3 a) Source # 
Instance details

Visitor (Vector3 a) Source # 
Instance details

Associated Types

data Fold (Vector3 a) :: Type -> Type Source #

Methods

visit :: Fold (Vector3 a) a0 -> Vector3 a -> a0 Source #

Eq a => Eq (Vector3 a) Source # 
Instance details

Methods

(==) :: Vector3 a -> Vector3 a -> Bool #

(/=) :: Vector3 a -> Vector3 a -> Bool #

Ord a => Ord (Vector3 a) Source # 
Instance details

Methods

compare :: Vector3 a -> Vector3 a -> Ordering #

(<) :: Vector3 a -> Vector3 a -> Bool #

(<=) :: Vector3 a -> Vector3 a -> Bool #

(>) :: Vector3 a -> Vector3 a -> Bool #

(>=) :: Vector3 a -> Vector3 a -> Bool #

max :: Vector3 a -> Vector3 a -> Vector3 a #

min :: Vector3 a -> Vector3 a -> Vector3 a #

Applicative (Vector3 \\\ Vector1) Source # 
Instance details

Methods

pure :: a -> (Vector3 \\\ Vector1) a #

(<*>) :: (Vector3 \\\ Vector1) (a -> b) -> (Vector3 \\\ Vector1) a -> (Vector3 \\\ Vector1) b #

liftA2 :: (a -> b -> c) -> (Vector3 \\\ Vector1) a -> (Vector3 \\\ Vector1) b -> (Vector3 \\\ Vector1) c #

(*>) :: (Vector3 \\\ Vector1) a -> (Vector3 \\\ Vector1) b -> (Vector3 \\\ Vector1) b #

(<*) :: (Vector3 \\\ Vector1) a -> (Vector3 \\\ Vector1) b -> (Vector3 \\\ Vector1) a #

Applicative (Vector3 \\\ Vector2) Source # 
Instance details

Methods

pure :: a -> (Vector3 \\\ Vector2) a #

(<*>) :: (Vector3 \\\ Vector2) (a -> b) -> (Vector3 \\\ Vector2) a -> (Vector3 \\\ Vector2) b #

liftA2 :: (a -> b -> c) -> (Vector3 \\\ Vector2) a -> (Vector3 \\\ Vector2) b -> (Vector3 \\\ Vector2) c #

(*>) :: (Vector3 \\\ Vector2) a -> (Vector3 \\\ Vector2) b -> (Vector3 \\\ Vector2) b #

(<*) :: (Vector3 \\\ Vector2) a -> (Vector3 \\\ Vector2) b -> (Vector3 \\\ Vector2) a #

Functor (Vector3 \\\ Vector1) Source # 
Instance details

Methods

fmap :: (a -> b) -> (Vector3 \\\ Vector1) a -> (Vector3 \\\ Vector1) b #

(<$) :: a -> (Vector3 \\\ Vector1) b -> (Vector3 \\\ Vector1) a #

Functor (Vector3 \\\ Vector2) Source # 
Instance details

Methods

fmap :: (a -> b) -> (Vector3 \\\ Vector2) a -> (Vector3 \\\ Vector2) b #

(<$) :: a -> (Vector3 \\\ Vector2) b -> (Vector3 \\\ Vector2) a #

Show a => Show (Codiagonal Vector3 a) Source # 
Instance details

(Show a, Monad str, Limiting str a) => Show (Closure str (Vector3 a)) Source # 
Instance details

Methods

showsPrec :: Int -> Closure str (Vector3 a) -> ShowS #

show :: Closure str (Vector3 a) -> String #

showList :: [Closure str (Vector3 a)] -> ShowS #

(Monad str, PpShow a, Limiting str a) => PpShow (Closure str (Vector3 a)) Source # 
Instance details

Methods

pp :: Closure str (Vector3 a) -> Doc Source #

ProjectionSpace (Vector3 \\\ Vector1) Vector1 Source # 
Instance details

Associated Types

data ((Vector3 \\\ Vector1) \\\ Vector1) a Source #

Show a => Show ((Vector3 \\\ Vector1) a) Source # 
Instance details

Show a => Show ((Vector3 \\\ Vector2) a) Source # 
Instance details

Transposable ((->) row) Vector3 a Source # 
Instance details

Methods

transpose_impl :: ((->) row :*: Vector3) a -> (Vector3 :*: (->) row) a Source #

(Num a, ConjugateSymmetric a) => Monoid ((Vector3 :*: Vector3) a) Source #

see "Lawvere,Rosebrugh: Sets for mathematics", pg. 167.

Instance details

(ConjugateSymmetric a, Num a) => Semigroup ((Vector3 :*: Vector3) a) Source #

see "Lawvere,Rosebrugh: Sets for mathematics", pg. 167.

Instance details

(Num a, ConjugateSymmetric a) => Num ((Vector3 :*: Vector3) a) Source # 
Instance details

(Fractional a, ConjugateSymmetric a) => Fractional ((Vector3 :*: Vector3) a) Source # 
Instance details

Show (f a) => Show ((Vector3 :*: f) a) Source # 
Instance details

Methods

showsPrec :: Int -> (Vector3 :*: f) a -> ShowS #

show :: (Vector3 :*: f) a -> String #

showList :: [(Vector3 :*: f) a] -> ShowS #

(ConjugateSymmetric a, Num a) => ConjugateSymmetric ((Vector3 :*: Vector3) a) Source #

https://en.wikipedia.org/wiki/Conjugate_transpose

Instance details

(Floating a, ConjugateSymmetric a) => InnerProductSpace ((Vector3 :*: Vector3) a) Source # 
Instance details

(Floating a, ConjugateSymmetric a) => NormedSpace ((Vector3 :*: Vector3) a) Source # 
Instance details

Num a => VectorSpace ((Vector1 :*: Vector3) a) Source #

1 x 3 matrices:

Instance details

Associated Types

type Scalar ((Vector1 :*: Vector3) a) Source #

Num a => VectorSpace ((Vector2 :*: Vector3) a) Source #

2 x 3 matrices:

Instance details

Associated Types

type Scalar ((Vector2 :*: Vector3) a) Source #

Num a => VectorSpace ((Vector3 :*: Vector1) a) Source #

3 x 1 matrices:

Instance details

Associated Types

type Scalar ((Vector3 :*: Vector1) a) Source #

Num a => VectorSpace ((Vector3 :*: Vector2) a) Source #

3 x 2 matrices

Instance details

Associated Types

type Scalar ((Vector3 :*: Vector2) a) Source #

Num a => VectorSpace ((Vector3 :*: Vector3) a) Source #

3 x 3 matrices:

Instance details

Associated Types

type Scalar ((Vector3 :*: Vector3) a) Source #

(Fractional a, ConjugateSymmetric a) => Group ((Vector3 :*: Vector3) a) Source # 
Instance details