Language.Paraiso.Tensor

A tensor algebra library. Main ingredients are :

Vec and :~ are data constructors for rank-1 tensor. This is essentially a touple of objects of the same type.

Vector is a class for rank-1 tensor.

Axis is an object for accessing the tensor components.

Documentation

data n :~ a

data constructor for constructing n+1-dimensional tensor from n-dimensional tensor.

Constructors

(n a) :~ a

Instances

Traversable n => Functor (:~ n)

(Applicative n, Traversable n) => Applicative (:~ n)

Traversable n => Foldable (:~ n)

Traversable n => Traversable (:~ n)

Vector v => Vector (:~ v)

(C a, VectorRing v a, C (v a)) => VectorRing (:~ v) a

(Eq a, Eq (n a)) => Eq (:~ n a)

(Ord a, Ord (n a)) => Ord (:~ n a)

(Read a, Read (n a)) => Read (:~ n a)

(Show a, Show (n a)) => Show (:~ n a)

(Vector v, C a) => C (:~ v a)

data Vec a

data constructor for 0-dimensional tensor.

Constructors

Vec

Instances

Functor Vec

Applicative Vec

Foldable Vec

Traversable Vec

Vector Vec

C a => VectorRing Vec a

Eq a => Eq (Vec a)

Ord a => Ord (Vec a)

Read a => Read (Vec a)

Show a => Show (Vec a)

C a => C (Vec a)

Vector whose components are additive is also additive.

newtype Axis v

An coordinate Axis , labeled by an integer. Axis also carries v, the container type for its corresponding vector. Therefore, An axis of one type can access only vectors of a fixed dimension, but of arbitrary type.

Constructors

Axis

Fields

axisIndex :: Int

Instances

Eq (Axis v)

Ord (Axis v)

Read (Axis v)

Show (Axis v)

(!) :: Vector v => v a -> Axis v -> a

a component operator.

class Traversable v => Vector v where

An object that allows component-wise access.

Methods

componentF

Arguments

:: Failure StringException f

=> Axis v

the axis of the component you want

-> v a

the target vector

-> f a

the component, obtained within a Failure monad

Get a component within f, a context which allows Failure.

component :: Axis v -> v a -> a

Get a component. This computation may result in a runtime error, though, as long as the Axis is generated from library functions such as compose, there will be no error.

dimension :: v a -> Int

The dimension of the vector.

compose :: (Axis v -> a) -> v a

Create a Vector from a function that maps axis to components.

Instances

Vector Vec

Vector v => Vector (:~ v)

class (Vector v, C a) => VectorRing v a where

VectorRing is a Vector whose components belongs to C, thus providing unit vectors.

Methods

unitVectorF :: Failure StringException f => Axis v -> f (v a)

A vector where Axisth component is unity but others are zero.

unitVector :: Axis v -> v a

pure but unsafe version means of obtaining a unitVector

Instances

C a => VectorRing Vec a

(C a, VectorRing v a, C (v a)) => VectorRing (:~ v) a

contract :: (Vector v, C a) => (Axis v -> a) -> a

Tensor contraction. Create a Vector from a function that maps axis to component, then sums over the axis and returns a

type Vec0 = Vec

Type synonyms

type Vec1 = :~ Vec0

type Vec2 = :~ Vec1

type Vec3 = :~ Vec2

type Vec4 = :~ Vec3