Safe Haskell	Trustworthy
Language	Haskell2010

Math.Matrix.QuasiQuoter

Contents

Orphan instances

Description

This module provides QuasiQuoter syntactic sugar for matrices. based on GHC's Language.Haskell.TH quasi quoters.

To use these you should use: {-# LANGUAGE QuasiQuotes #-}

Or corresponding compiler option "-XQuasiQuotes".

The syntax is:

[mat3x4|1 2 3 4;3 4 5 6;5 6 7 8|] :: (Vector3 :*: Vector4) Integer

[double2x2|3.4 5.6;6.7 8.8|] :: (Vector2 :*: Vector2) Double

The semicolons can be replaced with new line character to produce the matrix layout in the code, e.g.:

 [mat4x4|1 1 1 1
         2 2 2 2
         3 3 3 3
         4 4 4 4|]

The code supports matrices up to 4x4 matrices. For larger matrices, you should provide a vector type, and use e.g.

mat7x3 = parseMat (const () :: Vec 7 (Vec 3 Integer) -> ())

dbl7x2 = parseDbl (const () :: Vec 13 (Vec 2 Double) -> ())

Synopsis

notQuote :: b -> Q a
quoter :: (String -> Q Exp) -> QuasiQuoter
intmat :: QuasiQuoter
quoteExpr :: String -> Q Exp
mat1x1 :: QuasiQuoter
mat2x1 :: QuasiQuoter
mat3x1 :: QuasiQuoter
mat4x1 :: QuasiQuoter
mat1x2 :: QuasiQuoter
mat2x2 :: QuasiQuoter
mat3x2 :: QuasiQuoter
mat4x2 :: QuasiQuoter
mat1x3 :: QuasiQuoter
mat2x3 :: QuasiQuoter
mat3x3 :: QuasiQuoter
mat4x3 :: QuasiQuoter
mat1x4 :: QuasiQuoter
mat2x4 :: QuasiQuoter
mat3x4 :: QuasiQuoter
mat4x4 :: QuasiQuoter
double1x1 :: QuasiQuoter
double2x1 :: QuasiQuoter
double3x1 :: QuasiQuoter
double4x1 :: QuasiQuoter
double1x2 :: QuasiQuoter
double2x2 :: QuasiQuoter
double3x2 :: QuasiQuoter
double4x2 :: QuasiQuoter
double1x3 :: QuasiQuoter
double2x3 :: QuasiQuoter
double3x3 :: QuasiQuoter
double4x3 :: QuasiQuoter
double1x4 :: QuasiQuoter
double2x4 :: QuasiQuoter
double3x4 :: QuasiQuoter
double4x4 :: QuasiQuoter
parseMat :: (CoordinateSpace (Scalar (f (g a))), CoordinateSpace (f (g a)), Lift (f (g a)), Scalar (Scalar (f (g a))) ~ Integer) => (f (g a) -> ()) -> String -> Q Exp
parseDbl :: (CoordinateSpace (Scalar (f (g a))), CoordinateSpace (f (g a)), Lift (f (g a)), Scalar (Scalar (f (g a))) ~ Double) => (f (g a) -> ()) -> String -> Q Exp
parse1x4mat :: String -> Q Exp
parse2x4mat :: String -> Q Exp
parse3x4mat :: String -> Q Exp
parse4x4mat :: String -> Q Exp
parse1x3mat :: String -> Q Exp
parse2x3mat :: String -> Q Exp
parse3x3mat :: String -> Q Exp
parse4x3mat :: String -> Q Exp
parse1x2mat :: String -> Q Exp
parse2x2mat :: String -> Q Exp
parse3x2mat :: String -> Q Exp
parse4x2mat :: String -> Q Exp
parse1x1mat :: String -> Q Exp
parse2x1mat :: String -> Q Exp
parse3x1mat :: String -> Q Exp
parse4x1mat :: String -> Q Exp
parse1x4dbl :: String -> Q Exp
parse2x4dbl :: String -> Q Exp
parse3x4dbl :: String -> Q Exp
parse4x4dbl :: String -> Q Exp
parse1x3dbl :: String -> Q Exp
parse2x3dbl :: String -> Q Exp
parse3x3dbl :: String -> Q Exp
parse4x3dbl :: String -> Q Exp
parse1x2dbl :: String -> Q Exp
parse2x2dbl :: String -> Q Exp
parse3x2dbl :: String -> Q Exp
parse4x2dbl :: String -> Q Exp
parse1x1dbl :: String -> Q Exp
parse2x1dbl :: String -> Q Exp
parse3x1dbl :: String -> Q Exp
parse4x1dbl :: String -> Q Exp
parseStringMatrix :: MonadFail m => Text -> m ((List :*: List) Text)
stringLitP :: MonadFail m => Token -> m Text
parseDoubleMatrix :: MonadFail m => Text -> m ((List :*: List) Double)
floatLitP :: MonadFail m => Token -> m Double
parseNumberMatrix :: MonadFail m => Text -> m ((List :*: List) Integer)
numberP :: MonadFail m => Token -> m Integer
parseToMatrix :: MonadFail m => (Token -> ParseM a) -> Text -> m ((List :*: List) a)
parseMatrix :: (Token -> ParseM a) -> ParseM ((List :*: List) a)

Documentation

notQuote :: b -> Q a Source #

quoter :: (String -> Q Exp) -> QuasiQuoter Source #

intmat :: QuasiQuoter Source #

quoteExpr :: String -> Q Exp Source #

mat1x1 :: QuasiQuoter Source #