Geometric Algebra Types

.devcontainer/devcontainer.json

@@ -0,0 +1,20 @@
+{
+	"name": "GitHub Codespaces (Haskell)",
+	"image": "davidgontrum/haskellcodespaces",
+	"settings": {
+		"terminal.integrated.shell.linux": "/bin/bash",
+	},
+	"remoteUser": "codespace",
+	"overrideCommand": false,
+	"workspaceMount": "source=${localWorkspaceFolder},target=/home/codespace/workspace,type=bind,consistency=cached",
+	"workspaceFolder": "/home/codespace/workspace",
+	"mounts": [ "source=/var/run/docker.sock,target=/var/run/docker-host.sock,type=bind" ],
+	"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
+
+	"extensions": [
+		"haskell.haskell",
+		"k--kato.intellij-idea-keybindings",
+		"GitHub.vscode-pull-request-github",
+		"MS-vsliveshare.vsliveshare"
+	]
+}

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

@@ -11,7 +11,7 @@ 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(..), (+++))
 import Language.Drasil.Display (Symbol(Label, Concat))
@@ -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 undefined, unnamedParam undefined, 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 undefined] [], -- 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")
+  undefined (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")
+  undefined (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 @@
 -- | 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.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, Clif)) -- TODO: remove Matrix entirely
 
 import Control.Lens ((^.))
 import Data.List (intersperse, isPrefixOf, transpose)
@@ -66,7 +66,7 @@
 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
 
@@ -83,7 +83,7 @@
 
 -- | Gets the dimension of a 'Space'.
 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 +98,12 @@
         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 gr d s) ss = 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 gr0 d0 (ClifS gr1 d1 s)) sss = undefined -- TODO: fill this in
 strList2DAsExpr _ _ = error "strLists2DAsExprs called on non-2D-vector space"

code/drasil-data/lib/Data/Drasil/Quantities/Physics.hs

@@ -44,7 +44,8 @@ acceleration, angularAccel, angularDisplacement, angularVelocity, chgInVelocity,
   yVel, momentum, moment, moment2D, fOfGravity, positionVec, tension, angularFrequency, 
   period, frequency, chgMomentum :: UnitalChunk
 
-acceleration           = uc CP.acceleration           (Concat [vec lA, label "(", lT, label ")"]) (Vect Real) accelU
+-- TODO: what should the type here be?
+acceleration           = uc CP.acceleration           (Concat [vec lA, label "(", lT, label ")"]) undefined   accelU
 angularAccel           = uc CP.angAccel               lAlpha                                      Real        angAccelU
 angularDisplacement    = uc CP.angDisp                lTheta                                      Real        radian
 angularFrequency       = uc CP.angFreq                cOmega                                      Real        second

code/drasil-example/glassbr/lib/Drasil/GlassBR/ModuleDefs.hs

@@ -4,7 +4,7 @@
 
 module Drasil.GlassBR.ModuleDefs (allMods, implVars, interpY, interpZ) where
 
-import Language.Drasil (QuantityDict, Space(..), implVar, nounPhraseSP,
+import Language.Drasil (QuantityDict, Space(..), vect3D, implVar, nounPhraseSP,
   label, sub, HasSymbol(..), HasUID, Symbol)
 import Language.Drasil.Display (Symbol(..))
 import Language.Drasil.ShortHands
@@ -64,25 +64,25 @@ y = var "y" "y-coordinate to interpolate at"  lY Real
 z = var "z" "z-coordinate to interpolate at"  lZ Real
 
 zVector = var "zVector" "list of z values" 
-  (sub lZ (label "vector")) (Vect Real)               
+  (sub lZ (label "vector")) (vect3D Real)              
 yMatrix = var "yMatrix" "lists of y values at different z values" 
-  (sub lY (label "matrix")) (Vect $ Vect Real)        
+  (sub lY (label "matrix")) (vect3D $ vect3D Real)        
 xMatrix = var "xMatrix" "lists of x values at different z values" 
-  (sub lX (label "matrix")) (Vect $ Vect Real)        
+  (sub lX (label "matrix")) (vect3D $ vect3D Real)        
 arr     = var "arr"     "array in which value should be found" 
-  (label "arr")             (Vect Real)  --FIXME: temporary variable for findCT?
+  (label "arr")              (vect3D Real)  --FIXME: temporary variable for findCT?
 x_z_1   = var "x_z_1"   "list of x values at a specific z value"    
-  (sub lX (sub lZ one))      (Vect Real)
+  (sub lX (sub lZ one))      (vect3D Real)
 y_z_1   = var "y_z_1"   "list of y values at a specific z value"    
-  (sub lY (sub lZ one))      (Vect Real)   
+  (sub lY (sub lZ one))      (vect3D Real)   
 x_z_2   = var "x_z_2"   "list of x values at a specific z value"    
-  (sub lX (sub lZ two))      (Vect Real)
+  (sub lX (sub lZ two))      (vect3D Real)
 y_z_2   = var "y_z_2"   "list of y values at a specific z value"   
-  (sub lY (sub lZ two))      (Vect Real)
+  (sub lY (sub lZ two))      (vect3D Real)
 mat     = var "mat"     "matrix from which column will be extracted"     
-  (label "mat")             (Vect $ Vect Real)
+  (label "mat")             (vect3D $ vect3D Real)
 col     = var "col"     "extracted column"    
-  (label "col")             (Vect Real)               
+  (label "col")             (vect3D Real)               
 filename = var "filename" "name of file with x y and z data" 
   (label "filename")        String
 
@@ -152,7 +152,7 @@ findCT = funcDef "find"
 
 extractColumnCT :: Func
 extractColumnCT = funcDef "extractColumn" "Extracts a column from a 2D matrix" 
-  [mat, j] (Vect Real) (Just "column of the given matrix at the given index")
+  [mat, j] (vect3D Real) (Just "column of the given matrix at the given index") -- TODO: is this correct?
   [
     fDecDef col (matrix [[]]),
     --

code/drasil-example/swhs/lib/Drasil/SWHS/Unitals.hs

@@ -415,7 +415,7 @@ outputs = [tempW, tempPCM, watE, pcmE]
 tempW = cuc' "tempW"
   (nounPhraseSP "temperature of the water")
   "the average kinetic energy of the particles within the water" 
-  (sub (eqSymb temp) lWater) centigrade (Vect Real)
+  (sub (eqSymb temp) lWater) centigrade (vect undefined Real) -- TODO: dimension of vector?
   [physRange $ Bounded (Inc, sy tempInit) (Inc, sy tempC)] (exactDbl 0)
 
 -- Constraint 19