Geometric Algebra Types

code/drasil-code/lib/Data/Drasil/ExternalLibraries/ODELibraries.hs

@@ -11,9 +11,9 @@ module Data.Drasil.ExternalLibraries.ODELibraries (
 ) where
 
 import Language.Drasil (HasSymbol(symbol), HasUID(uid), MayHaveUnit(getUnit),
-  QuantityDict, HasSpace(typ), Space (Actor, Natural, Real, Void, Boolean, String, Array, Vect), implVar,
+  QuantityDict, HasSpace(typ), Space (Actor, Natural, Real, Void, Boolean, String, Array, ClifS), implVar,
   implVarUID, implVarUID', qw, compoundPhrase, nounPhrase, nounPhraseSP, label,
-  sub, Idea(getA), NamedIdea(term), Stage(..), (+++))
+  sub, Idea(getA), NamedIdea(term), Stage(..), (+++), vectNDS)
 import Language.Drasil.Display (Symbol(Label, Concat))
 
 import Language.Drasil.Code (Lang(..), ExternalLibrary, Step, Argument,
@@ -443,15 +443,15 @@ odeint = externalLib [
       customObjArg [] "Class representing an ODE system" ode odeCtor
         (customClass [constructorInfo odeCtor [] [],
           methodInfoNoReturn odeOp "function representation of ODE system"
-            [unnamedParam (Vect Real), unnamedParam (Vect Real), lockedParam t]
+            [unnamedParam (vectNDS "n" Real), unnamedParam (vectNDS "n" Real), lockedParam t] -- TODO: what do we put here? We need specific dimensions now.
             [assignArrayIndex]]),
       -- Need to declare variable holding initial value because odeint will update this variable at each step
       preDefinedArg odeintCurrVals,
       inlineArg Real, inlineArg Real, inlineArg Real,
       customObjArg []
         "Class for populating a list during an ODE solution process"
         pop popCtor (customClass [
-          constructorInfo popCtor [unnamedParam (Vect Real)] [],
+          constructorInfo popCtor [unnamedParam (vectNDS "n" Real)] [], -- TODO: Same as above TODO
           methodInfoNoReturn popOp
             "appends solution point for current ODE solution step"
             [lockedParam y, lockedParam t] [appendCurrSol (sy y)]])]]
@@ -496,7 +496,7 @@ odeintCurrVals, rk, stepper, pop :: CodeVarChunk
 odeintCurrVals = quantvar $ implVar "currVals_odeint" (nounPhrase
   "vector holding ODE solution values for the current step"
   "vectors holding ODE solution values for the current step")
-  (Vect Real) (label "currVals")
+  (vectNDS "n" Real) (label "currVals") -- TODO: Same as above, what do we fill in here?
 rk = quantvar $ implVar "rk_odeint" (nounPhrase
   "stepper for solving ODE system using Runge-Kutta-Dopri5 method"
   "steppers for solving ODE system using Runge-Kutta-Dopri5 method")
@@ -555,7 +555,7 @@ t = quantvar $ implVar "t_ode" (nounPhrase
 y = quantvar $ implVar "y_ode" (nounPhrase
   "current dependent variable value in ODE solution"
   "current dependent variable value in ODE solution")
-  (Vect Real) (label "y")
+  (vectNDS "n" Real) (label "y") -- TODO: Same as above - what dimension do we use here?
 
 -- | ODE object constructor.
 odeCtor :: CodeFuncChunk
@@ -599,8 +599,8 @@ modifiedODESyst sufx info = map replaceDepVar (odeSyst info)
     replaceDepVar (Matrix es)             = Matrix $ map (map replaceDepVar) es
     replaceDepVar (UnaryOp u e)           = UnaryOp u $ replaceDepVar e
     replaceDepVar (UnaryOpB u e)          = UnaryOpB u $ replaceDepVar e
-    replaceDepVar (UnaryOpVV u e)         = UnaryOpVV u $ replaceDepVar e
-    replaceDepVar (UnaryOpVN u e)         = UnaryOpVN u $ replaceDepVar e
+    replaceDepVar (UnaryOpCC u e)         = UnaryOpCC u $ replaceDepVar e
+    replaceDepVar (UnaryOpCN u e)         = UnaryOpCN u $ replaceDepVar e
     replaceDepVar (ArithBinaryOp b e1 e2) = ArithBinaryOp b
       (replaceDepVar e1) (replaceDepVar e2)
     replaceDepVar (BoolBinaryOp b e1 e2)  = BoolBinaryOp b
@@ -611,9 +611,9 @@ modifiedODESyst sufx info = map replaceDepVar (odeSyst info)
       (replaceDepVar e1) (replaceDepVar e2)
     replaceDepVar (OrdBinaryOp b e1 e2)   = OrdBinaryOp b
       (replaceDepVar e1) (replaceDepVar e2)
-    replaceDepVar (VVNBinaryOp b e1 e2)   = VVNBinaryOp b
+    replaceDepVar (CCNBinaryOp b e1 e2)   = CCNBinaryOp b
       (replaceDepVar e1) (replaceDepVar e2)
-    replaceDepVar (VVVBinaryOp b e1 e2)   = VVVBinaryOp b
+    replaceDepVar (CCCBinaryOp b e1 e2)   = CCCBinaryOp b
       (replaceDepVar e1) (replaceDepVar e2)
     replaceDepVar (Operator ao dd e)      = Operator ao dd $ replaceDepVar e
     replaceDepVar e = e

code/drasil-code/lib/Language/Drasil/Chunk/Parameter.hs

@@ -37,11 +37,11 @@ instance Eq          ParameterChunk where c1 == c2 = (c1 ^. uid) == (c2 ^. uid)
 -- | Finds the units of the 'CodeChunk' used to make the 'ParameterChunk'.
 instance MayHaveUnit ParameterChunk where getUnit = getUnit . view pcc
 
--- | Automatically chooses 'PassBy' based on 'Space' ('Vect'ors and 'Actor's passed by reference).
+-- | Automatically chooses 'PassBy' based on 'Space' ('Clif's and 'Actor's passed by reference).
 pcAuto :: (CodeIdea c) => c -> ParameterChunk
 pcAuto c = PC cdch (choosePB $ cdch ^. typ)
   where cdch = codeChunk c
-        choosePB (Vect _) = Ref
+        choosePB (ClifS _ _) = Ref
         choosePB (Actor _) = Ref
         choosePB _ = Val
 

code/drasil-code/lib/Language/Drasil/Code/Code.hs

@@ -23,7 +23,7 @@ spaceToCodeType S.Rational       = [Double, Float]
 spaceToCodeType S.Boolean        = [Boolean]
 spaceToCodeType S.Char           = [Char]
 spaceToCodeType S.String         = [String]
-spaceToCodeType (S.Vect s)       = map List (spaceToCodeType s)
+spaceToCodeType (S.ClifS _ s)  = map List (spaceToCodeType s)
 spaceToCodeType (S.Matrix _ _ s) = map (List . List) (spaceToCodeType s)
 spaceToCodeType (S.Set s)        = map List (spaceToCodeType s)
 spaceToCodeType (S.Array s)      = map Array (spaceToCodeType s)

code/drasil-code/lib/Language/Drasil/Code/Imperative/Import.hs

@@ -15,8 +15,8 @@ import Language.Drasil.CodeExpr (sy, ($<), ($>), ($<=), ($>=), ($&&), in')
 import qualified Language.Drasil.CodeExpr.Development as S (CodeExpr(..))
 import Language.Drasil.CodeExpr.Development (CodeExpr(..), ArithBinOp(..),
   AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..), BoolBinOp(..), EqBinOp(..),
-  LABinOp(..), OrdBinOp(..), UFunc(..), UFuncB(..), UFuncVV(..), UFuncVN(..),
-  VVNBinOp(..), VVVBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..))
+  LABinOp(..), OrdBinOp(..), UFunc(..), UFuncB(..), UFuncCC(..), UFuncCN(..),
+  CCNBinOp(..), CCCBinOp(..), NCCBinOp(..), ESSBinOp(..), ESBBinOp(..))
 import Language.Drasil.Code.Imperative.Comments (getComment)
 import Language.Drasil.Code.Imperative.ConceptMatch (conceptToGOOL)
 import Language.Drasil.Code.Imperative.GenerateGOOL (auxClass, fApp, fAppProc,
@@ -337,8 +337,8 @@ convExpr (Field o f) = do
   return $ valueOf v
 convExpr (UnaryOp o u)    = fmap (unop o) (convExpr u)
 convExpr (UnaryOpB o u)   = fmap (unopB o) (convExpr u)
-convExpr (UnaryOpVV o u)  = fmap (unopVV o) (convExpr u)
-convExpr (UnaryOpVN o u)  = fmap (unopVN o) (convExpr u)
+convExpr (UnaryOpCC o u)  = fmap (unopCC o) (convExpr u)
+convExpr (UnaryOpCN o u)  = fmap (unopCN o) (convExpr u)
 convExpr (ArithBinaryOp Frac (Lit (Int a)) (Lit (Int b))) = do -- hack to deal with integer division
   sm <- spaceCodeType Rational
   let getLiteral Double = litDouble (fromIntegral a) #/ litDouble (fromIntegral b)
@@ -350,9 +350,9 @@ convExpr (BoolBinaryOp o a b)  = liftM2 (boolBfunc o) (convExpr a) (convExpr b)
 convExpr (LABinaryOp o a b)    = liftM2 (laBfunc o) (convExpr a) (convExpr b)
 convExpr (EqBinaryOp o a b)    = liftM2 (eqBfunc o) (convExpr a) (convExpr b)
 convExpr (OrdBinaryOp o a b)   = liftM2 (ordBfunc o) (convExpr a) (convExpr b)
-convExpr (VVVBinaryOp o a b)   = liftM2 (vecVecVecBfunc o) (convExpr a) (convExpr b)
-convExpr (VVNBinaryOp o a b)   = liftM2 (vecVecNumBfunc o) (convExpr a) (convExpr b)
-convExpr (NVVBinaryOp o a b)   = liftM2 (numVecVecBfunc o) (convExpr a) (convExpr b)
+convExpr (CCCBinaryOp o a b)   = liftM2 (clfClfClfBfunc o) (convExpr a) (convExpr b)
+convExpr (CCNBinaryOp o a b)   = liftM2 (clfClfNumBfunc o) (convExpr a) (convExpr b)
+convExpr (NCCBinaryOp o a b)   = liftM2 (numClfClfBfunc o) (convExpr a) (convExpr b)
 convExpr (ESSBinaryOp o a b)   = liftM2 (elementSetSetBfunc o) (convExpr a) (convExpr b)
 convExpr (ESBBinaryOp o a b)   = liftM2 (elementSetBoolBfunc o) (convExpr a) (convExpr b)
 convExpr (Case c l)            = doit l -- FIXME this is sub-optimal
@@ -447,13 +447,13 @@ unopB :: (SharedProg r) => UFuncB -> (SValue r -> SValue r)
 unopB Not = (?!)
 
 -- | Similar to 'unop', but for vectors.
-unopVN :: (SharedProg r) => UFuncVN -> (SValue r -> SValue r)
-unopVN Dim = listSize
-unopVN Norm = error "unop: Norm not implemented" -- TODO
+unopCN :: (SharedProg r) => UFuncCN -> (SValue r -> SValue r)
+unopCN Dim = listSize
+unopCN Norm = error "unop: Norm not implemented" -- TODO
 
 -- | Similar to 'unop', but for vectors.
-unopVV :: (SharedProg r) => UFuncVV -> (SValue r -> SValue r)
-unopVV NegV = error "unop: Negation on Vectors not implemented" -- TODO
+unopCC :: (SharedProg r) => UFuncCC -> (SValue r -> SValue r)
+unopCC NegC = error "unop: Negation on Clifs not implemented" -- TODO
 
 -- Maps an 'ArithBinOp' to it's corresponding GOOL binary function.
 arithBfunc :: (SharedProg r) => ArithBinOp -> (SValue r -> SValue r -> SValue r)
@@ -483,19 +483,19 @@ ordBfunc Lt  = (?<)
 ordBfunc LEq = (?<=)
 ordBfunc GEq = (?>=)
 
--- Maps a 'VVVBinOp' to it's corresponding GOOL binary function.
-vecVecVecBfunc :: VVVBinOp -> (SValue r -> SValue r -> SValue r)
-vecVecVecBfunc Cross = error "bfunc: Cross not implemented"
-vecVecVecBfunc VAdd = error "bfunc: Vector addition not implemented"
-vecVecVecBfunc VSub = error "bfunc: Vector subtraction not implemented"
+-- Maps a 'CCCBinOp' to it's corresponding GOOL binary function.
+clfClfClfBfunc :: CCCBinOp -> (SValue r -> SValue r -> SValue r)
+clfClfClfBfunc Cross = error "bfunc: Cross not implemented"
+clfClfClfBfunc CAdd = error "bfunc: Clif addition not implemented"
+clfClfClfBfunc CSub = error "bfunc: Clif subtraction not implemented"
 
--- Maps a 'VVNBinOp' to it's corresponding GOOL binary function.
-vecVecNumBfunc :: VVNBinOp -> (SValue r -> SValue r -> SValue r)
-vecVecNumBfunc Dot = error "convExpr DotProduct"
+-- Maps a 'CCNBinOp' to it's corresponding GOOL binary function.
+clfClfNumBfunc :: CCNBinOp -> (SValue r -> SValue r -> SValue r)
+clfClfNumBfunc Dot = error "convExpr DotProduct"
 
--- Maps a 'NVVBinOp' to it's corresponding GOOL binary function.
-numVecVecBfunc :: NVVBinOp -> (SValue r -> SValue r -> SValue r)
-numVecVecBfunc Scale = error "convExpr Scaling of Vectors"
+-- Maps a 'NCCBinOp' to it's corresponding GOOL binary function.
+numClfClfBfunc :: NCCBinOp -> (SValue r -> SValue r -> SValue r)
+numClfClfBfunc Scale = error "convExpr Scaling of Vectors"
 
 -- Maps a 'ESSBinOp' to its corresponding GOOL binary function.
 elementSetSetBfunc :: (SharedProg r) => ESSBinOp -> (SValue r -> SValue r -> SValue r)
@@ -1038,8 +1038,8 @@ convExprProc (Message {}) = error "convExprProc: Procedural renderers do not sup
 convExprProc (Field _ _) = error "convExprProc: Procedural renderers do not support object field access"
 convExprProc (UnaryOp o u)    = fmap (unop o) (convExprProc u)
 convExprProc (UnaryOpB o u)   = fmap (unopB o) (convExprProc u)
-convExprProc (UnaryOpVV o u)  = fmap (unopVV o) (convExprProc u)
-convExprProc (UnaryOpVN o u)  = fmap (unopVN o) (convExprProc u)
+convExprProc (UnaryOpCC o u)  = fmap (unopCC o) (convExprProc u)
+convExprProc (UnaryOpCN o u)  = fmap (unopCN o) (convExprProc u)
 convExprProc (ArithBinaryOp Frac (Lit (Int a)) (Lit (Int b))) = do -- hack to deal with integer division
   sm <- spaceCodeType Rational
   let getLiteral Double = litDouble (fromIntegral a) #/ litDouble (fromIntegral b)
@@ -1051,9 +1051,9 @@ convExprProc (BoolBinaryOp o a b)  = liftM2 (boolBfunc o) (convExprProc a) (conv
 convExprProc (LABinaryOp o a b)    = liftM2 (laBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (EqBinaryOp o a b)    = liftM2 (eqBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (OrdBinaryOp o a b)   = liftM2 (ordBfunc o) (convExprProc a) (convExprProc b)
-convExprProc (VVVBinaryOp o a b)   = liftM2 (vecVecVecBfunc o) (convExprProc a) (convExprProc b)
-convExprProc (VVNBinaryOp o a b)   = liftM2 (vecVecNumBfunc o) (convExprProc a) (convExprProc b)
-convExprProc (NVVBinaryOp o a b)   = liftM2 (numVecVecBfunc o) (convExprProc a) (convExprProc b)
+convExprProc (CCCBinaryOp o a b)   = liftM2 (clfClfClfBfunc o) (convExprProc a) (convExprProc b)
+convExprProc (CCNBinaryOp o a b)   = liftM2 (clfClfNumBfunc o) (convExprProc a) (convExprProc b)
+convExprProc (NCCBinaryOp o a b)   = liftM2 (numClfClfBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (ESSBinaryOp o a b)   = liftM2 (elementSetSetBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (ESBBinaryOp o a b)   = liftM2 (elementSetBoolBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (Case c l)            = doit l -- FIXME this is sub-optimal

code/drasil-code/lib/Language/Drasil/Code/Imperative/ReadInput.hs

@@ -7,7 +7,7 @@ import Language.Drasil hiding (Data, Matrix, CodeVarChunk)
 import Language.Drasil.Code.DataDesc (DataDesc'(..), Data'(..), DataItem'(..),
   Delimiter, dataDesc, junk, list, singleton')
 import Language.Drasil.Chunk.Code (CodeVarChunk)
-import Language.Drasil.Expr.Development (Expr(Matrix))
+import Language.Drasil.Expr.Development (Expr(Matrix)) -- TODO: remove Matrix entirely
 
 import Control.Lens ((^.))
 import Data.List (intersperse, isPrefixOf, transpose)
@@ -66,7 +66,7 @@ readWithDataDesc fp ddsc = do
 sampleInputDD :: [CodeVarChunk] -> DataDesc'
 sampleInputDD ds = dataDesc (junk : intersperse junk (map toData ds)) "\n"
   where toData d = toData' (d ^. typ) d
-        toData' t@(Vect _) d = list d
+        toData' t@(ClifS _ _) d = list d
           (take (getDimension t) ([", ", "; "] ++ iterate (':':) ":"))
         toData' _ d = singleton' d
 
@@ -82,8 +82,9 @@ strAsExpr String   s = str s
 strAsExpr _        _ = error "strAsExpr should only be numeric space or string"
 
 -- | Gets the dimension of a 'Space'.
+-- TODO: investigate getting rid of the need for this
 getDimension :: Space -> Int
-getDimension (Vect t) = 1 + getDimension t
+getDimension (ClifS _ s) = 1 + getDimension s -- TODO: Does this make sense? Maybe we're overloading the term "dimension" now.
 getDimension _ = 0
 
 -- | Splits a string at the first (and only the first) occurrence of a delimiter.
@@ -98,12 +99,12 @@ splitAtFirst = splitAtFirst' []
         dropDelim [] s = s
         dropDelim _ [] = error "impossible"
 
--- | Converts a list of 'String's to a Matrix 'Expr' of a given 'Space'.
+-- | Converts a list of 'String's to a Clif 'Expr' of a given 'Space'.
 strListAsExpr :: Space -> [String] -> Expr
-strListAsExpr (Vect t) ss = Matrix [map (strAsExpr t) ss]
+strListAsExpr (ClifS _ _) _ = undefined -- TODO: fill this in
 strListAsExpr _ _ = error "strListsAsExpr called on non-vector space"
 
--- | Converts a 2D list of 'String's to a Matrix 'Expr' of a given 'Space'.
+-- | Converts a 2D list of 'String's to a Clif 'Expr' of a given 'Space'.
 strList2DAsExpr :: Space -> [[String]] -> Expr
-strList2DAsExpr (Vect (Vect t)) sss = Matrix $ map (map (strAsExpr t)) sss
+strList2DAsExpr (ClifS _ (ClifS _ _)) _ = undefined -- TODO: fill this in
 strList2DAsExpr _ _ = error "strLists2DAsExprs called on non-2D-vector space"