| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Math.Matrix.Interface
Contents
Description
These should match standard definitions of vector spaces. Used for reference: K. Chandrasekhara Rao: Functional Analysis. also see Warner: Modern algebra.
Synopsis
- newtype (f :*: g) a = Matrix {
- cells :: f (g a)
- data Vector1 a = Vector1 {
- vector_element :: !a
- data Vector2 s = Vector2 {}
- data Vector3 s = Vector3 {}
- data Vector4 s = Vector4 {}
- matrix :: (Functor m, Functor n) => (a -> b -> c) -> m a -> n b -> (m :*: n) c
- inverse_matrix :: (Contravariant m, Contravariant n) => (g a -> c -> b) -> m (n c) -> n b -> (m :*: g) a
- left_inverse_matrix :: (Contravariant m, Functor n) => (g a -> c -> b) -> m (n b) -> n c -> (m :*: g) a
- right_inverse_matrix :: (Functor m, Contravariant n) => (t -> a -> b) -> m t -> n b -> (m :*: n) a
- inverse_fix :: Contravariant p => (a -> a) -> p a
- inverse_fix2 :: Contravariant p => (a -> b) -> (b -> a) -> p a
- matrix_compose :: (Functor m, Functor n, Category cat) => m (cat b c) -> n (cat a b) -> (m :*: n) (cat a c)
- tensor_product :: (Num a, Functor m, Functor n) => m a -> n a -> (m :*: n) a
- tensor_product_lin :: (Linearizable arr (:*:) f g a, Num a, Functor f, Functor g) => f a -> g a -> arr (f a) (g a)
- bilinear_impl :: (VectorSpace (g c), Scalar (g c) ~ c, Indexable f c, Indexable g c, Integral c, VectorSpace ((f :*: g) c)) => (f c -> f c -> g c) -> f c -> f c -> (f :*: g) c
- applicativeMatrix :: (Applicative f, Functor m, Functor n) => f (a -> b -> c) -> (m :*: f) a -> (n :*: f) b -> (m :*: n) (f c)
- (>*<) :: (Applicative f, Functor m, Functor n) => f (a -> b -> c) -> ((m :*: f) a, (n :*: f) b) -> (m :*: n) (f c)
- class Num (Scalar v) => VectorSpace v where
- class VectorSpace v => DecomposableVectorSpace v cofree | v -> cofree where
- type VectorSpaceOver v a = (VectorSpace v, Scalar v ~ a)
- type PrimitiveSpace v = (v ~ Scalar v, VectorSpace v)
- type ComplexVectorSpace v a = VectorSpaceOver v (Complex a)
- type Linear a b = (VectorSpace a, VectorSpace b, Scalar a ~ Scalar b)
- type LinearInnerProductSpace a b = (Linear a b, InnerProductSpace a, InnerProductSpace b)
- type SupportsMatrixMultiplication f g h a = (VectorSpace (f a), VectorSpace (h a), InnerProductSpace (g a), Scalar (f a) ~ a, Scalar (h a) ~ a, Scalar (g a) ~ a, Num a, ConjugateSymmetric a, Functor f, Transposable g h a)
- type LinearIso f g a = (LinearTransform f g a, LinearTransform g f a)
- class VectorSpace v => BilinearVectorSpace v where
- class VectorSpace m => InnerProductSpace m where
- outer :: (InnerProductSpace m, Scalar m ~ Scalar v, VectorSpace v) => m -> v -> m -> v
- class VectorSpace m => LieAlgebra m where
- (%<>%) :: m -> m -> m
- class VectorSpace s => MetricSpace s where
- class VectorSpace m => NormedSpace m where
- norm :: m -> Scalar m
- norm_squared :: m -> Scalar m
- matrix_norm :: (Functor f, NormedSpace (g a), NormedSpace (f (Scalar (g a)))) => (f :*: g) a -> Scalar (f (Scalar (g a)))
- class CompleteSpace m
- class ConjugateSymmetric m where
- conj :: m -> m
- class (Scalar (m a) ~ Scalar (n a), Functor m, Functor n) => LinearTransform m n a where
- data Lin b c where
- class (Functor m, Functor n, Scalar (m a) ~ Scalar (n a)) => Transposable m n a where
- transpose_impl :: (m :*: n) a -> (n :*: m) a
- transpose :: (Transposable g f a, Linearizable arr (:*:) f g a, Linearizable arr (:*:) g f a) => arr (g a) (f a) -> arr (f a) (g a)
- indexable_transpose :: (Functor n, Indexable m a) => (n :*: m) a -> (m :*: n) a
- update_column :: Applicative h => (a -> f b -> g c) -> h a -> (h :*: f) b -> (h :*: g) c
- update_row :: (a -> f (g b) -> f' (g' b')) -> a -> (f :*: g) b -> (f' :*: g') b'
- class UpdateableMatrixDimension f where
- write_row :: Applicative h => h a -> f ((f :*: h) a -> (f :*: h) a)
- write_column :: Applicative h => h a -> f ((h :*: f) a -> (h :*: f) a)
- solve_matrix :: (Traceable m b, Fractional b, UpdateableMatrixDimension m) => (m :*: m) b -> m b -> m b
- (<!-!>) :: (m a -> a) -> (a -> m a) -> Index m a
- runIndex :: Index m a -> m a -> a
- appIndex :: Applicative f => f (Index m a) -> f (m a) -> f a
- type Index m a = m a :==: I a
- class (Applicative m, Num a) => Indexable m a where
- diagonal_projections :: m (Index m a)
- basis_vector :: Index m a -> m a
- index_project :: Index m a -> m a -> a
- indexable_indices :: m a
- class (Num a, Indexable m a, Transposable m m a) => Diagonalizable m a where
- identity_impl :: m Integer -> (m :*: m) a
- identity :: (m :*: m) a
- diagonal_impl :: (m :*: m) a -> m a
- diagonal_matrix_impl :: m a -> (m :*: m) a
- basis :: Diagonalizable m a => m (m a)
- coefficients :: (Foldable m, Applicative m, VectorSpace v) => m (Scalar v) -> m v -> v
- bilinear_map :: (VectorSpace a, Foldable m, Foldable n, Diagonalizable m b, Diagonalizable n c) => (m b -> n c -> a) -> m (Scalar a) -> n (Scalar a) -> a
- linear_map_ :: (Foldable m, Diagonalizable m a, VectorSpace b) => (m a -> b) -> m (Scalar b) -> b
- linear_map' :: (b ~ Scalar (n b), Foldable m, Diagonalizable m a, VectorSpace (n b)) => (m a -> n b) -> m b -> n b
- linear_identity :: (Linearizable arr (:*:) m m a, LinearTransform m m a, Diagonalizable m a) => arr (m a) (m a)
- diagonal :: (Linearizable arr (:*:) m m a, Diagonalizable m a) => arr (m a) (m a) -> m a
- class (Functor m, Functor n) => ProjectionSpace (m :: * -> *) (n :: * -> *) where
- data (m \\\ n) a
- project_first :: m a -> n a
- project_second :: m a -> (m \\\ n) a
- join_vector :: n a -> (m \\\ n) a -> m a
- class CodiagonalMatrix m a where
- data Codiagonal m a
- type m \\ a
- codiagonal_impl :: (m :*: m) a -> Codiagonal m a
- (|\|) :: m a -> Codiagonal m a -> (m :*: m) a
- down_project :: Codiagonal m a -> m \\ a
- right_project :: Codiagonal m a -> m \\ a
- class Category arr => Linearizable arr prod f g a | arr -> prod where
- fromLinear :: arr (f a) (g a) -> prod f g a
- linear :: prod f g a -> arr (f a) (g a)
- class Diagonalizable m a => Traceable m a where
- trace_impl :: (m :*: m) a -> a
- determinant_impl :: (m :*: m) a -> a
- vector_dimension :: m a -> a
- class (Category arr, Traceable m a) => LinearTraceable arr m a where
- determinant :: arr (m a) (m a) -> a
- trace :: arr (m a) (m a) -> a
- class Traceable m a => Invertible m a where
- cofactor_impl :: (m :*: m) a -> (m :*: m) a
- adjucate_impl :: (m :*: m) a -> (m :*: m) a
- inverse_impl :: (m :*: m) a -> (m :*: m) a
- class LinearTraceable arr m a => LinearInvertible arr m a where
- dual_basis_impl :: Invertible m a => (m :*: m) a -> (m :*: m) a
- dual_basis :: (Invertible m a, Linearizable arr (:*:) m m a) => arr (m a) (m a) -> arr (m a) (m a)
- class Functor m => EigenDecomposable m a where
- eigenvalues :: (m :*: m) a -> m a
- class EigenDecomposable m a => EigenVectorable m a where
- eigenvectors :: (m :*: m) a -> (m :*: m) a
- class (Applicative m, Applicative n) => AppendableVector m n where
- class AppendableVector m n => SplittableVector m n where
- class Conditional a where
- fromBoolean :: Bool -> a
- class StandardBasis m where
- unit_vectors :: [m]
- class VectorSpace v => CoordinateSpace v where
- type Coordinate v
- index :: Coordinate v -> v -> Scalar v
- listVector :: [Scalar v] -> v
- dimension_size :: v -> Int
- coordinates :: v -> [Coordinate v]
- class (Num (Scalar v), VectorSpace v) => NumSpace v
- class (Fractional (Scalar v), NumSpace v) => FractionalSpace v
- class VectorSpace v => FiniteDimensional v d i arr where
- class HasIdentityLinear v arr where
- mat_identity :: (Num a, ConjugateSymmetric a) => arr (v a) (v a)
- class VectorSpace v => Dualizable v d where
- class VectorSpace v => VectorDerivative v d arr | d -> arr, v arr -> d where
- divergence :: arr v v -> d v
- grad :: d v -> arr v v
- directional_derivative :: v -> d v -> d v
- laplace :: d v -> d v
- normalized_directional_derivative :: (VectorDerivative v d arr, NormedSpace v, Fractional (Scalar v)) => v -> d v -> d v
- class VectorCrossProduct v arr where
- curl :: arr v v -> arr v v
- class VectorLaplacian v arr where
- vector_laplace :: arr v v -> arr v v
- class Functor f => ProjectionDual f d a where
- projection_dual :: f (d (f a))
- matrixM :: (Traversable f, Traversable g, Monad m) => (a -> b -> m c) -> f a -> g b -> m ((f :*: g) c)
- matrixMatrix :: (Functor m, Functor n, Functor m', Functor n') => (a -> b -> c) -> (m :*: m') a -> (n :*: n') b -> ((m :*: n) :*: (m' :*: n')) c
- newtype Basis m = Basis [m]
- (%-) :: VectorSpace v => v -> v -> v
- (%/) :: (Fractional (Scalar v), VectorSpace v) => v -> Scalar v -> v
- innerproductspace_cos_angle :: (InnerProductSpace m, Floating (Scalar m)) => m -> m -> Scalar m
- normed_lie_algebra_sin_angle :: (LieAlgebra m, NormedSpace m, Floating (Scalar m)) => m -> m -> Scalar m
- angle :: (InnerProductSpace m, Floating (Scalar m)) => m -> m -> Scalar m
- i_vec :: StandardBasis v => v
- j_vec :: StandardBasis v => v
- k_vec :: StandardBasis v => v
- l_vec :: StandardBasis v => v
- innerproductspace_norm :: (Floating (Scalar m), InnerProductSpace m) => m -> Scalar m
- innerproductspace_norm_squared :: (Floating (Scalar m), InnerProductSpace m) => m -> Scalar m
- vsum :: (Foldable t, VectorSpace a) => t a -> a
- index_unit :: StandardBasis v => Int -> v
- projection :: (Fractional (Scalar v), VectorSpace v, InnerProductSpace v) => v -> v -> v
- normalize :: (Fractional (Scalar a), NormedSpace a) => a -> a
- vector_length :: (Floating (Scalar m), InnerProductSpace m) => m -> Scalar m
- divide :: (Fractional (Scalar v), VectorSpace v) => v -> Scalar v -> v
- vaverage :: (Num v, Fractional (Scalar v), VectorSpace v) => [v] -> v
- toScalarList :: (StandardBasis m, InnerProductSpace m) => m -> [Scalar m]
- fromScalarList :: (VectorSpace a, StandardBasis a) => [Scalar a] -> a
- toListCS :: CoordinateSpace v => v -> [Scalar v]
- toListCS2 :: (CoordinateSpace m, CoordinateSpace (Scalar m)) => m -> [[Scalar (Scalar m)]]
- coordinates2 :: (CoordinateSpace m, CoordinateSpace (Scalar m)) => m -> [[(Coordinate m, Coordinate (Scalar m))]]
- basis_of :: StandardBasis m => Basis m
- listMatrix :: (CoordinateSpace n, CoordinateSpace (Scalar n)) => [[Scalar (Scalar n)]] -> n
- (%*%) :: SupportsMatrixMultiplication f g h a => (f :*: g) a -> (g :*: h) a -> (f :*: h) (Scalar (g a))
- (%**%) :: (SupportsMatrixMultiplication f g h a, Linearizable arr (:*:) f h a, Linearizable arr (:*:) f g a, Linearizable arr (:*:) g h a) => arr (f a) (g a) -> arr (g a) (h a) -> arr (f a) (h a)
- type MatrixNorm arr h m a = (LinearTraceable arr m (Scalar (h a)), InnerProductSpace (h a), ConjugateSymmetric a, Transposable h m a)
- (%^%) :: (SupportsMatrixMultiplication f f f a, Diagonalizable f (f a), Diagonalizable f a) => (f :*: f) a -> Integer -> (f :*: f) a
- (|><|) :: (Functor m, Functor n, InnerProductSpace a) => m a -> n a -> (m :*: n) (Scalar a)
- identityCS :: (CoordinateSpace m, CoordinateSpace (Scalar m), Num (Scalar (Scalar m))) => (Int, Int) -> m
- (%.%) :: (Num (Scalar m), CoordinateSpace m) => m -> m -> Scalar m
- basis_coordinates :: InnerProductSpace v => Basis v -> v -> [Scalar v]
- coordinateSpaceFunctionMatrix :: (CoordinateSpace m, StandardBasis v) => (v -> Scalar m) -> m
- functionMatrix :: Diagonalizable f b => (f b -> g b) -> (f :*: g) b
- convex_combination :: (VectorSpace v, Fractional (Scalar v), Foldable t, Applicative t) => t (Scalar v) -> t v -> v
- vec2_cast :: (a :~: b) -> (a :~: b) -> a :~: b
- hilbertSpace :: (Num m, NormedSpace m) => m -> m -> Scalar m
- lie_adjoint :: LieAlgebra v => v -> Endo v
- diagonal_projections_list :: Monoid a => [Index List a]
- is_on_unit_circle :: (NormedSpace v, Eq (Scalar v)) => v -> Bool
- is_inside_unit_circle :: (NormedSpace v, Ord (Scalar v)) => v -> Bool
- left_unitor :: (I :*: f) a -> f a
- right_unitor :: Functor f => (f :*: I) a -> f a
- associator :: Functor f => ((f :*: g) :*: h) a -> (f :*: (g :*: h)) a
- unassociator :: Functor f => (f :*: (g :*: h)) a -> ((f :*: g) :*: h) a
- diagonal_projections_complex :: Num a => Complex (Index Complex a)
- (<!>) :: (Functor f, Functor g) => (g :*: f) a -> (g c -> b, f a -> c) -> b
- reduceI :: (I :*: I) a -> I a
- sum_coordinates :: (Foldable t, Num a) => t a -> a
- join_matrix :: (Monad g, Monad f, forall b. Transposable g f b) => (f :*: g) ((f :*: g) a) -> (f :*: g) a
Documentation
newtype (f :*: g) a infixr 5 Source #
The primary data type for matrices.
Note that indices are represented in the functors,
If you want to use numeric indices, use Simple.
This can be viewed as a bicategory with one object (a).
https://ncatlab.org/nlab/show/bicategory
or as a monoidal category https://ncatlab.org/nlab/show/monoidal+category
or as a matrix over a base field a https://ncatlab.org/nlab/show/matrix
or as a tensor product of functors f and g https://ncatlab.org/nlab/show/tensor+product
or as a composition of functors f and g
Instances
Constructors
| Vector1 | |
Fields
| |
Instances
Instances
Three element vector
Instances
Instances
matrix :: (Functor m, Functor n) => (a -> b -> c) -> m a -> n b -> (m :*: n) c Source #
This method of matrix construction is especially nice. This is the functoriality of the tensor product.
inverse_matrix :: (Contravariant m, Contravariant n) => (g a -> c -> b) -> m (n c) -> n b -> (m :*: g) a Source #
left_inverse_matrix :: (Contravariant m, Functor n) => (g a -> c -> b) -> m (n b) -> n c -> (m :*: g) a Source #
right_inverse_matrix :: (Functor m, Contravariant n) => (t -> a -> b) -> m t -> n b -> (m :*: n) a Source #
inverse_fix :: Contravariant p => (a -> a) -> p a Source #
inverse_fix2 :: Contravariant p => (a -> b) -> (b -> a) -> p a Source #
matrix_compose :: (Functor m, Functor n, Category cat) => m (cat b c) -> n (cat a b) -> (m :*: n) (cat a c) Source #
tensor_product_lin :: (Linearizable arr (:*:) f g a, Num a, Functor f, Functor g) => f a -> g a -> arr (f a) (g a) Source #
bilinear_impl :: (VectorSpace (g c), Scalar (g c) ~ c, Indexable f c, Indexable g c, Integral c, VectorSpace ((f :*: g) c)) => (f c -> f c -> g c) -> f c -> f c -> (f :*: g) c Source #
https://en.wikipedia.org/wiki/Tensor_product
bilinearity : \[f (a + b,c) = f(a, c) + f(b, c)\] \[f (k b, c) = k f(b, c)\] \[f (a, b + c) = f(a, b) + f(a,c)\] \[f (a, k c) = k f(a, c)\] https://en.wikipedia.org/wiki/Bilinear_map
applicativeMatrix :: (Applicative f, Functor m, Functor n) => f (a -> b -> c) -> (m :*: f) a -> (n :*: f) b -> (m :*: n) (f c) Source #
(>*<) :: (Applicative f, Functor m, Functor n) => f (a -> b -> c) -> ((m :*: f) a, (n :*: f) b) -> (m :*: n) (f c) Source #
class Num (Scalar v) => VectorSpace v where Source #
Instances
class VectorSpace v => DecomposableVectorSpace v cofree | v -> cofree where Source #
cofree is right adjoint to Scalar
Minimal complete definition
Instances
| Num a => DecomposableVectorSpace (Vector1 a) ((->) OneD) Source # | |
| Num a => DecomposableVectorSpace (Vector2 a) ((->) TwoD) Source # | |
| Num a => DecomposableVectorSpace (Vector3 a) ((->) ThreeD) Source # | |
| Num a => DecomposableVectorSpace (Vector4 a) ((->) FourD) Source # | |
| Num a => DecomposableVectorSpace (Stream a) ((->) Integer) Source # | |
type VectorSpaceOver v a = (VectorSpace v, Scalar v ~ a) Source #
type PrimitiveSpace v = (v ~ Scalar v, VectorSpace v) Source #
type ComplexVectorSpace v a = VectorSpaceOver v (Complex a) Source #
type Linear a b = (VectorSpace a, VectorSpace b, Scalar a ~ Scalar b) Source #
type LinearInnerProductSpace a b = (Linear a b, InnerProductSpace a, InnerProductSpace b) Source #
type SupportsMatrixMultiplication f g h a = (VectorSpace (f a), VectorSpace (h a), InnerProductSpace (g a), Scalar (f a) ~ a, Scalar (h a) ~ a, Scalar (g a) ~ a, Num a, ConjugateSymmetric a, Functor f, Transposable g h a) Source #
type LinearIso f g a = (LinearTransform f g a, LinearTransform g f a) Source #
class VectorSpace v => BilinearVectorSpace v where Source #
class VectorSpace m => InnerProductSpace m where Source #
Instances
outer :: (InnerProductSpace m, Scalar m ~ Scalar v, VectorSpace v) => m -> v -> m -> v Source #
class VectorSpace m => LieAlgebra m where Source #
Instances
| Num a => LieAlgebra (Endo a) Source # | |
| Floating a => LieAlgebra (Product a) Source # | |
| Num a => LieAlgebra (Vector3 a) Source # | |
| (v ~ Scalar (f v), VectorSpace (f v), DualNum f v) => LieAlgebra (Dual (f v)) Source # | |
| Num a => LieAlgebra (Quaternion a) Source # | |
Defined in Math.Matrix.Quaternion | |
| (LieAlgebra a, LieAlgebra b, Scalar a ~ Scalar b) => LieAlgebra (a, b) Source # | |
Defined in Math.Matrix.Interface | |
| (VectorSpace a, Num a) => LieAlgebra (a -> a) Source # | |
Defined in Math.Matrix.Interface | |
| (Integral row, Universe row, SupportsMatrixMultiplication ((->) row) ((->) row) ((->) row) a) => LieAlgebra ((row :&: row) a) Source # | |
| (LieAlgebra v, LieAlgebra w, LieAlgebra u, Scalar v ~ Scalar w, Scalar w ~ Scalar u) => LieAlgebra (v, w, u) Source # | |
Defined in Math.Matrix.Interface | |
| (Num a, ConjugateSymmetric a) => LieAlgebra ((Vector3 :*: Vector3) a) Source # | |
| (Num a, ConjugateSymmetric a) => LieAlgebra ((Vector4 :*: Vector4) a) Source # | |
class VectorSpace s => MetricSpace s where Source #
Instances
| MetricSpace R Source # | |
| MetricSpace Integer Source # | |
| MetricSpace Int Source # | |
| RealFloat a => MetricSpace (Complex a) Source # | |
| MetricSpace (Ratio Integer) Source # | |
| MetricSpace (Stream R) Source # | |
| MetricSpace (Closure Stream R) Source # | |
class VectorSpace m => NormedSpace m where Source #
norm_squared is an optimization that often avoids computing square root
Minimal complete definition
Instances
matrix_norm :: (Functor f, NormedSpace (g a), NormedSpace (f (Scalar (g a)))) => (f :*: g) a -> Scalar (f (Scalar (g a))) Source #
This computes norm of each row, then computes the norm of the resulting column vector.
class CompleteSpace m Source #
Instances
| CompleteSpace R Source # | |
Defined in Math.Number.R | |
class ConjugateSymmetric m where Source #
Instances
class (Scalar (m a) ~ Scalar (n a), Functor m, Functor n) => LinearTransform m n a where Source #
Methods
Arguments
| :: n a | |
| -> (m :*: n) a | |
| -> m a | vector times matrix |
Arguments
| :: (m :*: n) a | |
| -> m a | |
| -> n a | matrix times vector |
Instances
class (Functor m, Functor n, Scalar (m a) ~ Scalar (n a)) => Transposable m n a where Source #
Methods
transpose_impl :: (m :*: n) a -> (n :*: m) a Source #
Instances
transpose :: (Transposable g f a, Linearizable arr (:*:) f g a, Linearizable arr (:*:) g f a) => arr (g a) (f a) -> arr (f a) (g a) Source #
update_column :: Applicative h => (a -> f b -> g c) -> h a -> (h :*: f) b -> (h :*: g) c Source #
update_row :: (a -> f (g b) -> f' (g' b')) -> a -> (f :*: g) b -> (f' :*: g') b' Source #
class UpdateableMatrixDimension f where Source #
Example use:
write_column (Vector3 3 4 5) `ycoord3` identity3 == [[1,3,0],[0,4,0],[0,5,1]]
Methods
write_row :: Applicative h => h a -> f ((f :*: h) a -> (f :*: h) a) Source #
write_column :: Applicative h => h a -> f ((h :*: f) a -> (h :*: f) a) Source #
Instances
| UpdateableMatrixDimension Vector2 Source # | |
Defined in Math.Matrix.Vector2 | |
| UpdateableMatrixDimension Vector3 Source # | |
Defined in Math.Matrix.Vector3 | |
| UpdateableMatrixDimension Vector4 Source # | |
Defined in Math.Matrix.Vector4 | |
| Eq ind => UpdateableMatrixDimension ((->) ind) Source # | |
Defined in Math.Matrix.Simple Methods write_row :: Applicative h => h a -> ind -> (((->) ind :*: h) a -> ((->) ind :*: h) a) Source # write_column :: Applicative h => h a -> ind -> ((h :*: (->) ind) a -> (h :*: (->) ind) a) Source # | |
solve_matrix :: (Traceable m b, Fractional b, UpdateableMatrixDimension m) => (m :*: m) b -> m b -> m b Source #
Cramer's rule https://en.wikipedia.org/wiki/Cramer%27s_rule.
Solves \({\mathbf x}\) from matrix equation \(A{\mathbf x} = {\mathbf b}\), where \(A\) is first parameter and \({\mathbf b}\) is second parameter. Returns vector \({\mathbf x}\). Satisfies requirements:
a <<*> solve_matrix a b == b
\[{\mathbf x}_i = {{\det(A[A_{ki} := {\mathbf b}_k])} \over {\det(A)}}\]
appIndex :: Applicative f => f (Index m a) -> f (m a) -> f a Source #
class (Applicative m, Num a) => Indexable m a where Source #
Minimal complete definition
Methods
diagonal_projections :: m (Index m a) Source #
basis_vector :: Index m a -> m a Source #
index_project :: Index m a -> m a -> a Source #
indexable_indices :: m a Source #
Instances
class (Num a, Indexable m a, Transposable m m a) => Diagonalizable m a where Source #
Minimal complete definition
Methods
identity_impl :: m Integer -> (m :*: m) a Source #
argument to identity_impl is dimension of the matrix
identity :: (m :*: m) a Source #
diagonal_impl :: (m :*: m) a -> m a Source #
diagonal_matrix_impl :: m a -> (m :*: m) a Source #
Instances
| Num a => Diagonalizable Complex a Source # | diagonalizable instance for complex numbers. diagonal ((a+bi)+i(c+di)) = (a-d) + i(b+c) |
| Num a => Diagonalizable Vector1 a Source # | |
| Num a => Diagonalizable Vector2 a Source # | |
| Num a => Diagonalizable Vector3 a Source # | |
| Num a => Diagonalizable Vector4 a Source # | |
| Num a => Diagonalizable Stream a Source # | square matrix implementation for streams. |
| (Num a, Eq dim, Integral dim) => Diagonalizable ((->) dim) a Source # | |
Defined in Math.Matrix.Simple | |
basis :: Diagonalizable m a => m (m a) Source #
coefficients :: (Foldable m, Applicative m, VectorSpace v) => m (Scalar v) -> m v -> v Source #
bilinear_map :: (VectorSpace a, Foldable m, Foldable n, Diagonalizable m b, Diagonalizable n c) => (m b -> n c -> a) -> m (Scalar a) -> n (Scalar a) -> a Source #
linear_map_ :: (Foldable m, Diagonalizable m a, VectorSpace b) => (m a -> b) -> m (Scalar b) -> b Source #
linear_map' :: (b ~ Scalar (n b), Foldable m, Diagonalizable m a, VectorSpace (n b)) => (m a -> n b) -> m b -> n b Source #
linear_identity :: (Linearizable arr (:*:) m m a, LinearTransform m m a, Diagonalizable m a) => arr (m a) (m a) Source #
diagonal :: (Linearizable arr (:*:) m m a, Diagonalizable m a) => arr (m a) (m a) -> m a Source #
class (Functor m, Functor n) => ProjectionSpace (m :: * -> *) (n :: * -> *) where Source #
Methods
project_first :: m a -> n a Source #
project_second :: m a -> (m \\\ n) a Source #
join_vector :: n a -> (m \\\ n) a -> m a Source #
class CodiagonalMatrix m a where Source #
CodiagonalMatrix represents a matrix that can be split along the diagonal. The Codiagonal type represents a matrix without its diagonal. The ProjectionVector type represents a vector down from first element of diagonal when the diagonal is removed. This vector often has less elements than the original vector. Similarly for vector right from the first element of diagonal.
Methods
codiagonal_impl :: (m :*: m) a -> Codiagonal m a Source #
(|\|) :: m a -> Codiagonal m a -> (m :*: m) a Source #
down_project :: Codiagonal m a -> m \\ a Source #
right_project :: Codiagonal m a -> m \\ a Source #
Instances
class Category arr => Linearizable arr prod f g a | arr -> prod where Source #
NOTICE: Linearizable instances for matrices that have similar dimensions are special.
Methods
fromLinear :: arr (f a) (g a) -> prod f g a Source #
Instances
class Diagonalizable m a => Traceable m a where Source #
Minimal complete definition
Methods
trace_impl :: (m :*: m) a -> a Source #
determinant_impl :: (m :*: m) a -> a Source #
vector_dimension :: m a -> a Source #
Instances
| Num a => Traceable Vector1 a Source # | |
Defined in Math.Matrix.Vector1 | |
| Num a => Traceable Vector2 a Source # | |
Defined in Math.Matrix.Vector2 | |
| Num a => Traceable Vector3 a Source # | |
Defined in Math.Matrix.Vector3 | |
| Num a => Traceable Vector4 a Source # | |
Defined in Math.Matrix.Vector4 | |
| (Eq dim, Num dim, Integral dim, Universe dim, CoFactorDimension dim, ConjugateSymmetric a, Num a) => Traceable ((->) dim) a Source # | |
Defined in Math.Matrix.Simple Methods trace_impl :: ((->) dim :*: (->) dim) a -> a Source # determinant_impl :: ((->) dim :*: (->) dim) a -> a Source # vector_dimension :: (dim -> a) -> a Source # | |
class (Category arr, Traceable m a) => LinearTraceable arr m a where Source #
Minimal complete definition
Nothing
Methods
determinant :: arr (m a) (m a) -> a Source #
default determinant :: Linearizable arr (:*:) m m a => arr (m a) (m a) -> a Source #
trace :: arr (m a) (m a) -> a Source #
default trace :: Linearizable arr (:*:) m m a => arr (m a) (m a) -> a Source #
Instances
| (ConjugateSymmetric a, Num a) => LinearTraceable LinearMap Vector2 a Source # | |
class Traceable m a => Invertible m a where Source #
http://en.wikipedia.org/wiki/Adjugate \({\mathsf{cofactor}}(A) = |A|(A^{-1})^{\top}\) https://en.wikipedia.org/wiki/Cross_product
Methods
cofactor_impl :: (m :*: m) a -> (m :*: m) a Source #
adjucate_impl :: (m :*: m) a -> (m :*: m) a Source #
inverse_impl :: (m :*: m) a -> (m :*: m) a Source #
Instances
| Fractional a => Invertible Vector2 a Source # | |
| Fractional a => Invertible Vector3 a Source # | |
| Fractional a => Invertible Vector4 a Source # | |
class LinearTraceable arr m a => LinearInvertible arr m a where Source #
Minimal complete definition
Nothing
Methods
cofactor :: arr (m a) (m a) -> arr (m a) (m a) Source #
default cofactor :: (Invertible m a, Linearizable arr (:*:) m m a) => arr (m a) (m a) -> arr (m a) (m a) Source #
adjucate :: arr (m a) (m a) -> arr (m a) (m a) Source #
default adjucate :: (Invertible m a, Linearizable arr (:*:) m m a) => arr (m a) (m a) -> arr (m a) (m a) Source #
inverse :: arr (m a) (m a) -> arr (m a) (m a) Source #
default inverse :: (Invertible m a, Linearizable arr (:*:) m m a) => arr (m a) (m a) -> arr (m a) (m a) Source #
Instances
| (ConjugateSymmetric a, Fractional a) => LinearInvertible LinearMap Vector2 a Source # | |
Defined in Math.Matrix.Linear | |
dual_basis_impl :: Invertible m a => (m :*: m) a -> (m :*: m) a Source #
this computes \[f(A) = (A^{-1})^{\top}\] it's used to compute dual basis for a set of basis vectors.
dual_basis :: (Invertible m a, Linearizable arr (:*:) m m a) => arr (m a) (m a) -> arr (m a) (m a) Source #
class Functor m => EigenDecomposable m a where Source #
Methods
eigenvalues :: (m :*: m) a -> m a Source #
Instances
| Floating a => EigenDecomposable Vector2 a Source # | |
Defined in Math.Matrix.Vector2 | |
| (Floating a, Ord a, ConjugateSymmetric a) => EigenDecomposable Vector3 a Source # | |
Defined in Math.Matrix.Vector3 | |
class EigenDecomposable m a => EigenVectorable m a where Source #
Methods
eigenvectors :: (m :*: m) a -> (m :*: m) a Source #
class (Applicative m, Applicative n) => AppendableVector m n where Source #
Instances
class AppendableVector m n => SplittableVector m n where Source #
class Conditional a where Source #
Iverson bracket: http://en.wikipedia.org/wiki/Iverson_bracket
Methods
fromBoolean :: Bool -> a Source #
Instances
| Conditional Integer Source # | |
Defined in Math.Matrix.Interface Methods fromBoolean :: Bool -> Integer Source # | |
| Conditional Float Source # | |
Defined in Math.Matrix.Interface Methods fromBoolean :: Bool -> Float Source # | |
| Conditional Int Source # | |
Defined in Math.Matrix.Interface Methods fromBoolean :: Bool -> Int Source # | |
class StandardBasis m where Source #
Methods
unit_vectors :: [m] Source #
Instances
class VectorSpace v => CoordinateSpace v where Source #
Associated Types
type Coordinate v Source #
Methods
index :: Coordinate v -> v -> Scalar v Source #
listVector :: [Scalar v] -> v Source #
dimension_size :: v -> Int Source #
coordinates :: v -> [Coordinate v] Source #
Instances
class (Fractional (Scalar v), NumSpace v) => FractionalSpace v Source #
vector space with fractional scalars
class VectorSpace v => FiniteDimensional v d i arr where Source #
class HasIdentityLinear v arr where Source #
Methods
mat_identity :: (Num a, ConjugateSymmetric a) => arr (v a) (v a) Source #
Instances
| HasIdentityLinear Vector1 LinearMap Source # | |
Defined in Math.Matrix.Linear Methods mat_identity :: (Num a, ConjugateSymmetric a) => LinearMap (Vector1 a) (Vector1 a) Source # | |
| HasIdentityLinear Vector2 LinearMap Source # | |
Defined in Math.Matrix.Linear Methods mat_identity :: (Num a, ConjugateSymmetric a) => LinearMap (Vector2 a) (Vector2 a) Source # | |
| HasIdentityLinear Vector3 LinearMap Source # | |
Defined in Math.Matrix.Linear Methods mat_identity :: (Num a, ConjugateSymmetric a) => LinearMap (Vector3 a) (Vector3 a) Source # | |
| HasIdentityLinear Vector4 LinearMap Source # | |
Defined in Math.Matrix.Linear Methods mat_identity :: (Num a, ConjugateSymmetric a) => LinearMap (Vector4 a) (Vector4 a) Source # | |
class VectorSpace v => Dualizable v d where Source #
Instances
| (ConjugateSymmetric a, Num a) => Dualizable (Vector1 a) Dual Source # | |
| (Num a, ConjugateSymmetric a) => Dualizable (Vector2 a) Dual Source # | |
| (ConjugateSymmetric a, Num a) => Dualizable (Vector3 a) Dual Source # | |
| (ConjugateSymmetric a, Num a) => Dualizable (Vector4 a) Dual Source # | |
| (Integral a, Universe a, Num b, ConjugateSymmetric b) => Dualizable (a -> b) Dual Source # | |
class VectorSpace v => VectorDerivative v d arr | d -> arr, v arr -> d where Source #
https://en.wikipedia.org/wiki/Laplace_operator https://en.wikipedia.org/wiki/Divergence https://en.wikipedia.org/wiki/Gradient https://en.wikipedia.org/wiki/Directional_derivative Notice: for directional derivative, the direction is not automatically normalized, since that needs NormedSpace
Minimal complete definition
Methods
divergence :: arr v v -> d v Source #
grad :: d v -> arr v v Source #
directional_derivative :: v -> d v -> d v Source #
Instances
| (ConjugateSymmetric a, Num a, Closed a) => VectorDerivative (Vector1 a) Dual LinearMap Source # | |
Defined in Math.Matrix.Linear | |
| (ConjugateSymmetric a, Infinitesimal Stream a, Closed a) => VectorDerivative (Vector2 a) Dual LinearMap Source # | |
Defined in Math.Matrix.Linear | |
| (Closed a, Num a, ConjugateSymmetric a) => VectorDerivative (Vector3 a) Dual LinearMap Source # | |
Defined in Math.Matrix.Linear | |
| (Num a, Closed a, ConjugateSymmetric a, LinearTransform Vector4 Vector1 a) => VectorDerivative (Vector4 a) Dual LinearMap Source # | |
Defined in Math.Matrix.LinearOperations | |
| (b ~ Scalar a, Scalar (a -> b) ~ b, Integral a, VectorSpace b, ConjugateSymmetric b, Closed b, Infinitesimal Stream b, Eq a, Universe a) => VectorDerivative (a -> b) Dual LinearMap Source # | |
normalized_directional_derivative :: (VectorDerivative v d arr, NormedSpace v, Fractional (Scalar v)) => v -> d v -> d v Source #
version of directional derivative that normalizes the direction: https://mathworld.wolfram.com/DirectionalDerivative.html
class VectorCrossProduct v arr where Source #
Instances
| (ConjugateSymmetric a, Infinitesimal Stream a, VectorSpace a, Closed a) => VectorCrossProduct (Vector2 a :: Type) LinearMap Source # | |
| (Closed a, Num a, ConjugateSymmetric a) => VectorCrossProduct (Vector3 a :: Type) LinearMap Source # | |
class VectorLaplacian v arr where Source #
Methods
vector_laplace :: arr v v -> arr v v Source #
Instances
| (Infinitesimal Stream a, Closed a) => VectorLaplacian (Vector2 a :: Type) LinearMap Source # | |
Defined in Math.Matrix.Linear | |
| (Closed a, Num a, ConjugateSymmetric a) => VectorLaplacian (Vector3 a :: Type) LinearMap Source # | |
Defined in Math.Matrix.Linear | |
| (Closed a, ConjugateSymmetric a, LinearTransform Vector4 Vector1 a) => VectorLaplacian (Vector4 a :: Type) LinearMap Source # | |
Defined in Math.Matrix.LinearOperations | |
class Functor f => ProjectionDual f d a where Source #
Methods
projection_dual :: f (d (f a)) Source #
Instances
| (ConjugateSymmetric a, Num a) => ProjectionDual Vector1 Dual a Source # | |
Defined in Math.Matrix.Linear | |
| (ConjugateSymmetric a, Num a) => ProjectionDual Vector2 Dual a Source # | |
Defined in Math.Matrix.Linear | |
| (Num a, ConjugateSymmetric a) => ProjectionDual Vector3 Dual a Source # | |
Defined in Math.Matrix.Linear | |
| (Num a, ConjugateSymmetric a) => ProjectionDual Vector4 Dual a Source # | |
Defined in Math.Matrix.LinearOperations | |
matrixM :: (Traversable f, Traversable g, Monad m) => (a -> b -> m c) -> f a -> g b -> m ((f :*: g) c) Source #
matrixMatrix :: (Functor m, Functor n, Functor m', Functor n') => (a -> b -> c) -> (m :*: m') a -> (n :*: n') b -> ((m :*: n) :*: (m' :*: n')) c Source #
Constructors
| Basis [m] |
Instances
| Show v => Show (Basis v) Source # | |
| VectorSpace k => VectorSpace (Basis k) Source # | |
| type Scalar (Basis k) Source # | |
Defined in Math.Matrix.Interface | |
(%-) :: VectorSpace v => v -> v -> v infixl 6 Source #
(%/) :: (Fractional (Scalar v), VectorSpace v) => v -> Scalar v -> v Source #
innerproductspace_cos_angle :: (InnerProductSpace m, Floating (Scalar m)) => m -> m -> Scalar m Source #
normed_lie_algebra_sin_angle :: (LieAlgebra m, NormedSpace m, Floating (Scalar m)) => m -> m -> Scalar m Source #
i_vec :: StandardBasis v => v Source #
j_vec :: StandardBasis v => v Source #
k_vec :: StandardBasis v => v Source #
l_vec :: StandardBasis v => v Source #
innerproductspace_norm :: (Floating (Scalar m), InnerProductSpace m) => m -> Scalar m Source #
innerproductspace_norm_squared :: (Floating (Scalar m), InnerProductSpace m) => m -> Scalar m Source #
vsum :: (Foldable t, VectorSpace a) => t a -> a Source #
index_unit :: StandardBasis v => Int -> v Source #
projection :: (Fractional (Scalar v), VectorSpace v, InnerProductSpace v) => v -> v -> v Source #
normalize :: (Fractional (Scalar a), NormedSpace a) => a -> a Source #
vector_length :: (Floating (Scalar m), InnerProductSpace m) => m -> Scalar m Source #
divide :: (Fractional (Scalar v), VectorSpace v) => v -> Scalar v -> v Source #
vaverage :: (Num v, Fractional (Scalar v), VectorSpace v) => [v] -> v Source #
toScalarList :: (StandardBasis m, InnerProductSpace m) => m -> [Scalar m] Source #
fromScalarList :: (VectorSpace a, StandardBasis a) => [Scalar a] -> a Source #
toListCS :: CoordinateSpace v => v -> [Scalar v] Source #
toListCS2 :: (CoordinateSpace m, CoordinateSpace (Scalar m)) => m -> [[Scalar (Scalar m)]] Source #
coordinates2 :: (CoordinateSpace m, CoordinateSpace (Scalar m)) => m -> [[(Coordinate m, Coordinate (Scalar m))]] Source #
basis_of :: StandardBasis m => Basis m Source #
listMatrix :: (CoordinateSpace n, CoordinateSpace (Scalar n)) => [[Scalar (Scalar n)]] -> n Source #
(%*%) :: SupportsMatrixMultiplication f g h a => (f :*: g) a -> (g :*: h) a -> (f :*: h) (Scalar (g a)) Source #
generalized implementation of matrix multiplication see http://en.wikipedia.org/wiki/Matrix_multiplication
(%**%) :: (SupportsMatrixMultiplication f g h a, Linearizable arr (:*:) f h a, Linearizable arr (:*:) f g a, Linearizable arr (:*:) g h a) => arr (f a) (g a) -> arr (g a) (h a) -> arr (f a) (h a) Source #
type MatrixNorm arr h m a = (LinearTraceable arr m (Scalar (h a)), InnerProductSpace (h a), ConjugateSymmetric a, Transposable h m a) Source #
In this version, we must assume VectorSpaceOver (h a) a constraint, but the result type is nicer.
(%^%) :: (SupportsMatrixMultiplication f f f a, Diagonalizable f (f a), Diagonalizable f a) => (f :*: f) a -> Integer -> (f :*: f) a Source #
(|><|) :: (Functor m, Functor n, InnerProductSpace a) => m a -> n a -> (m :*: n) (Scalar a) Source #
identityCS :: (CoordinateSpace m, CoordinateSpace (Scalar m), Num (Scalar (Scalar m))) => (Int, Int) -> m Source #
basis_coordinates :: InnerProductSpace v => Basis v -> v -> [Scalar v] Source #
coordinateSpaceFunctionMatrix :: (CoordinateSpace m, StandardBasis v) => (v -> Scalar m) -> m Source #
functionMatrix :: Diagonalizable f b => (f b -> g b) -> (f :*: g) b Source #
This is the linearity condition:
convex_combination :: (VectorSpace v, Fractional (Scalar v), Foldable t, Applicative t) => t (Scalar v) -> t v -> v Source #
https://en.wikipedia.org/wiki/Convex_combination This computes \[f([a_0,a_1,...,a_n], [{\mathbf b}_0,{\mathbf b}_1,...,{\mathbf b}_n]) = {{\sum_{j=0}^n{a_j{\mathbf b}_j}} \over \sum_{i=0}^n{a_i}}\]
hilbertSpace :: (Num m, NormedSpace m) => m -> m -> Scalar m Source #
lie_adjoint :: LieAlgebra v => v -> Endo v Source #
is_on_unit_circle :: (NormedSpace v, Eq (Scalar v)) => v -> Bool Source #
is_inside_unit_circle :: (NormedSpace v, Ord (Scalar v)) => v -> Bool Source #
left_unitor :: (I :*: f) a -> f a Source #
sum_coordinates :: (Foldable t, Num a) => t a -> a Source #
join_matrix :: (Monad g, Monad f, forall b. Transposable g f b) => (f :*: g) ((f :*: g) a) -> (f :*: g) a Source #