-- Convention used below:
-- when 'name' and 'nameCT' both appear, 'name' is the Haskell function and
-- 'nameCT' is the "Code Template" that 'name' builds.

module Drasil.GlassBR.ModuleDefs (allMods, implVars, interpY, interpZ) where

import Drasil.Code.CodeExpr (CodeExpr, LiteralC(int))
import Language.Drasil (Space(..), nounPhraseSP,
  label, sub, HasSymbol(..), HasUID, Symbol, ExprC(..), DefinedQuantityDict, implVar)
import Language.Drasil.Display (Symbol(..))
import Language.Drasil.ShortHands
import Language.Drasil.Code (($:=), Func, FuncStmt(..), Mod, 
  asVC, funcDef, fDecDef, ffor, funcData, quantvar, 
  multiLine, packmod, repeated, singleLine)
import qualified Drasil.GlassBR.Unitals as U
import Language.Drasil.Printers


allMods :: [Mod]
allMods :: [Mod]
allMods = [Mod
readTableMod, Mod
interpMod]

-- It's a bit odd that this has to be explicitly built here...
implVars :: [DefinedQuantityDict]
implVars :: [DefinedQuantityDict]
implVars = [DefinedQuantityDict
v, DefinedQuantityDict
x_z_1, DefinedQuantityDict
y_z_1, DefinedQuantityDict
x_z_2, DefinedQuantityDict
y_z_2, DefinedQuantityDict
mat, DefinedQuantityDict
col,
  DefinedQuantityDict
i, DefinedQuantityDict
j, DefinedQuantityDict
k, DefinedQuantityDict
z, DefinedQuantityDict
zVector, DefinedQuantityDict
yMatrix, DefinedQuantityDict
xMatrix, DefinedQuantityDict
y, DefinedQuantityDict
arr, DefinedQuantityDict
filename,
  DefinedQuantityDict
y_2, DefinedQuantityDict
y_1, DefinedQuantityDict
x_2, DefinedQuantityDict
x_1, DefinedQuantityDict
x]

--from TSD.txt:

readTableMod :: Mod
readTableMod :: Mod
readTableMod = Name -> Name -> [Class] -> [Func] -> Mod
packmod Name
"ReadTable"
  Name
"Provides a function for reading glass ASTM data" [] [Func
readTable]

readTable :: Func
readTable :: Func
readTable = Name -> Name -> DataDesc -> Func
funcData Name
"read_table"
  Name
"Reads glass ASTM data from a file with the given file name"
  [ LinePattern -> Delim -> Data
singleLine ([DataItem] -> LinePattern
repeated [DefinedQuantityDict -> DataItem
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> DataItem
quantvar DefinedQuantityDict
zVector]) Delim
',',
    LinePattern -> Delim -> Data
multiLine ([DataItem] -> LinePattern
repeated ((DefinedQuantityDict -> DataItem)
-> [DefinedQuantityDict] -> [DataItem]
forall a b. (a -> b) -> [a] -> [b]
map DefinedQuantityDict -> DataItem
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> DataItem
quantvar [DefinedQuantityDict
xMatrix, DefinedQuantityDict
yMatrix])) Delim
','
  ]

-----

one, two :: Symbol
one :: Symbol
one = Int -> Symbol
Integ Int
1
two :: Symbol
two = Int -> Symbol
Integ Int
2

var :: String -> String -> String -> Symbol -> Space -> DefinedQuantityDict
var :: Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
nam Name
np Name
desc Symbol
sym Space
sp = Name -> NP -> Name -> Space -> Symbol -> DefinedQuantityDict
implVar Name
nam (Name -> NP
nounPhraseSP Name
np) Name
desc Space
sp Symbol
sym

y_2, y_1, x_2, x_1, x :: DefinedQuantityDict
y_1 :: DefinedQuantityDict
y_1  = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"y1" Name
"lower y-coordinate"
  Name
"the lower y-coordinate" (Symbol -> Symbol -> Symbol
sub Symbol
lY Symbol
one) Space
Real
y_2 :: DefinedQuantityDict
y_2  = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"y2" Name
"upper y-coordinate"
  Name
"the upper y-coordinate" (Symbol -> Symbol -> Symbol
sub Symbol
lY Symbol
two) Space
Real
x_1 :: DefinedQuantityDict
x_1  = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"x1" Name
"lower x-coordinate"
  Name
"the lower x-coordinate" (Symbol -> Symbol -> Symbol
sub Symbol
lX Symbol
one) Space
Real
x_2 :: DefinedQuantityDict
x_2  = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"x2" Name
"upper x-coordinate"
  Name
"the upper x-coordiante" (Symbol -> Symbol -> Symbol
sub Symbol
lX Symbol
two) Space
Real
x :: DefinedQuantityDict
x    = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"x"  Name
"x-coordinate to interpolate at"
  Name
"the x-coordinate to interpolate at" Symbol
lX Space
Real -- = params.wtnt from mainFun.py

v, x_z_1, y_z_1, x_z_2, y_z_2, mat, col,
  i, j, k, z, zVector, yMatrix, xMatrix, y, arr, filename :: DefinedQuantityDict
i :: DefinedQuantityDict
i = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"i" Name
"index" Name
"the index" Symbol
lI Space
Natural
j :: DefinedQuantityDict
j = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"j" Name
"index" Name
"the index" Symbol
lJ Space
Natural
k :: DefinedQuantityDict
k = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"k" Name
"index" Name
"the index" (Symbol -> Symbol -> Symbol
sub Symbol
lK Symbol
two) Space
Natural     
v :: DefinedQuantityDict
v = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"v" Name
"value whose index will be found"
  Name
"the value whose index will be found" Symbol
lV Space
Real
y :: DefinedQuantityDict
y = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"y" Name
"y-coordinate to interpolate at"
  Name
"the y-coordinate to interpolate at" Symbol
lY Space
Real
z :: DefinedQuantityDict
z = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"z" Name
"z-coordinate to interpolate at"
  Name
"the z-coordinate to interpolate at" Symbol
lZ Space
Real

zVector :: DefinedQuantityDict
zVector = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"zVector" Name
"list of z values" 
  Name
"the list of z values" (Symbol -> Symbol -> Symbol
sub Symbol
lZ (Name -> Symbol
label Name
"vector")) (Space -> Space
Vect Space
Real)               
yMatrix :: DefinedQuantityDict
yMatrix = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"yMatrix" Name
"lists of y values at different z values" 
  Name
"the lists of y values at different z values" (Symbol -> Symbol -> Symbol
sub Symbol
lY (Name -> Symbol
label Name
"matrix")) (Space -> Space
Vect (Space -> Space) -> Space -> Space
forall a b. (a -> b) -> a -> b
$ Space -> Space
Vect Space
Real)
xMatrix :: DefinedQuantityDict
xMatrix = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"xMatrix" Name
"lists of x values at different z values" 
  Name
"the lists of x values at different z values" (Symbol -> Symbol -> Symbol
sub Symbol
lX (Name -> Symbol
label Name
"matrix")) (Space -> Space
Vect (Space -> Space) -> Space -> Space
forall a b. (a -> b) -> a -> b
$ Space -> Space
Vect Space
Real)        
arr :: DefinedQuantityDict
arr     = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"arr" Name
"array in which value should be found"
  Name
"the array in which a value should be found" (Name -> Symbol
label Name
"arr") (Space -> Space
Vect Space
Real)  --FIXME: temporary variable for findCT?
x_z_1 :: DefinedQuantityDict
x_z_1   = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"x_z_1" Name
"list of x values at a specific z value"
  Name
"the list of x values at a specific z value" (Symbol -> Symbol -> Symbol
sub Symbol
lX (Symbol -> Symbol -> Symbol
sub Symbol
lZ Symbol
one)) (Space -> Space
Vect Space
Real)
y_z_1 :: DefinedQuantityDict
y_z_1   = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"y_z_1" Name
"list of y values at a specific z value"
  Name
"the list of y values at a specific z value" (Symbol -> Symbol -> Symbol
sub Symbol
lY (Symbol -> Symbol -> Symbol
sub Symbol
lZ Symbol
one)) (Space -> Space
Vect Space
Real)   
x_z_2 :: DefinedQuantityDict
x_z_2   = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"x_z_2" Name
"list of x values at a specific z value"
  Name
"the list of x values at a specific z value" (Symbol -> Symbol -> Symbol
sub Symbol
lX (Symbol -> Symbol -> Symbol
sub Symbol
lZ Symbol
two)) (Space -> Space
Vect Space
Real)
y_z_2 :: DefinedQuantityDict
y_z_2   = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"y_z_2" Name
"list of y values at a specific z value"
  Name
"the list of y values at a specific z value" (Symbol -> Symbol -> Symbol
sub Symbol
lY (Symbol -> Symbol -> Symbol
sub Symbol
lZ Symbol
two)) (Space -> Space
Vect Space
Real)
mat :: DefinedQuantityDict
mat     = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"mat" Name
"matrix from which column will be extracted"
  Name
"the matrix from which columns will be extracted" (Name -> Symbol
label Name
"mat") (Space -> Space
Vect (Space -> Space) -> Space -> Space
forall a b. (a -> b) -> a -> b
$ Space -> Space
Vect Space
Real)
col :: DefinedQuantityDict
col     = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"col" Name
"extracted column"
  Name
"the extracted column" (Name -> Symbol
label Name
"col") (Space -> Space
Vect Space
Real)
filename :: DefinedQuantityDict
filename = Name -> Name -> Name -> Symbol -> Space -> DefinedQuantityDict
var Name
"filename" Name
"name of file with x y and z data"
  Name
"the name of the file with x, y, and z data" (Name -> Symbol
label Name
"filename") Space
String

------------------------------------------------------------------------------------------
--
-- Some semantic functions

-- Given two points (x1,y1) and (x2,y2), return the slope of the line going through them
slope :: (CodeExpr, CodeExpr) -> (CodeExpr, CodeExpr) -> CodeExpr
slope :: (CodeExpr, CodeExpr) -> (CodeExpr, CodeExpr) -> CodeExpr
slope (CodeExpr
x1, CodeExpr
y1) (CodeExpr
x2, CodeExpr
y2) = (CodeExpr
y2 CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$- CodeExpr
y1) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$/ (CodeExpr
x2 CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$- CodeExpr
x1)

-- Given two points (x1,y1) and (x2,y2), and an x ordinate, return
-- extrapoled y on the straight line in between
onLine :: (CodeExpr, CodeExpr) -> (CodeExpr, CodeExpr) -> CodeExpr -> CodeExpr
onLine :: (CodeExpr, CodeExpr)
-> (CodeExpr, CodeExpr) -> CodeExpr -> CodeExpr
onLine p1 :: (CodeExpr, CodeExpr)
p1@(CodeExpr
x1, CodeExpr
y1) (CodeExpr, CodeExpr)
p2 CodeExpr
x_ = (CodeExpr
m CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$* (CodeExpr
x_ CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$- CodeExpr
x1)) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$+ CodeExpr
y1
                 where m :: CodeExpr
m = (CodeExpr, CodeExpr) -> (CodeExpr, CodeExpr) -> CodeExpr
slope (CodeExpr, CodeExpr)
p1 (CodeExpr, CodeExpr)
p2

------------------------------------------------------------------------------------------
-- Code Template helper functions

vLook :: (HasSymbol a, HasSymbol i, HasUID a, HasUID i) => a -> i -> CodeExpr -> CodeExpr
vLook :: forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook a
a i
i_ CodeExpr
p = CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
idx (a -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy a
a) (i -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy i
i_ CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$+ CodeExpr
p)

aLook :: (HasSymbol a, HasSymbol i, HasSymbol j, HasUID a, HasUID i, HasUID j) =>
  a -> i -> j -> CodeExpr
aLook :: forall a i j.
(HasSymbol a, HasSymbol i, HasSymbol j, HasUID a, HasUID i,
 HasUID j) =>
a -> i -> j -> CodeExpr
aLook a
a i
i_ j
j_ = CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
idx (CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
idx (a -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy a
a) (i -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy i
i_)) (j -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy j
j_)

getCol :: (HasSymbol a, HasSymbol i, HasUID a, HasUID i) => a -> i -> CodeExpr -> CodeExpr
getCol :: forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol a
a_ i
i_ CodeExpr
p = DefinedQuantityDict -> [CodeExpr] -> CodeExpr
forall f. (HasUID f, HasSymbol f) => f -> [CodeExpr] -> CodeExpr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply (Func -> DefinedQuantityDict
asVC Func
extractColumnCT) [a -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy a
a_, i -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy i
i_ CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$+ CodeExpr
p]

call :: Func -> [DefinedQuantityDict] -> FuncStmt
call :: Func -> [DefinedQuantityDict] -> FuncStmt
call Func
f [DefinedQuantityDict]
l = CodeExpr -> FuncStmt
FVal (CodeExpr -> FuncStmt) -> CodeExpr -> FuncStmt
forall a b. (a -> b) -> a -> b
$ DefinedQuantityDict -> [CodeExpr] -> CodeExpr
forall f. (HasUID f, HasSymbol f) => f -> [CodeExpr] -> CodeExpr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply (Func -> DefinedQuantityDict
asVC Func
f) ([CodeExpr] -> CodeExpr) -> [CodeExpr] -> CodeExpr
forall a b. (a -> b) -> a -> b
$ (DefinedQuantityDict -> CodeExpr)
-> [DefinedQuantityDict] -> [CodeExpr]
forall a b. (a -> b) -> [a] -> [b]
map DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy [DefinedQuantityDict]
l

find :: (HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) => zv -> z -> CodeExpr
find :: forall zv z.
(HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) =>
zv -> z -> CodeExpr
find zv
zv z
z_ = DefinedQuantityDict -> [CodeExpr] -> CodeExpr
forall f. (HasUID f, HasSymbol f) => f -> [CodeExpr] -> CodeExpr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply (Func -> DefinedQuantityDict
asVC Func
findCT) [zv -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy zv
zv, z -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy z
z_]

linInterp :: [CodeExpr] -> CodeExpr
linInterp :: [CodeExpr] -> CodeExpr
linInterp = DefinedQuantityDict -> [CodeExpr] -> CodeExpr
forall f. (HasUID f, HasSymbol f) => f -> [CodeExpr] -> CodeExpr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply (Func -> DefinedQuantityDict
asVC Func
linInterpCT)

interpOver :: (HasUID ptx, HasUID pty, HasUID ind, HasUID vv,
  HasSymbol ptx, HasSymbol pty, HasSymbol ind, HasSymbol vv) =>
  ptx -> pty -> ind -> vv -> [CodeExpr]
interpOver :: forall ptx pty ind vv.
(HasUID ptx, HasUID pty, HasUID ind, HasUID vv, HasSymbol ptx,
 HasSymbol pty, HasSymbol ind, HasSymbol vv) =>
ptx -> pty -> ind -> vv -> [CodeExpr]
interpOver ptx
ptx pty
pty ind
ind vv
vv =
  [ ptx -> ind -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook ptx
ptx ind
ind (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0), pty -> ind -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook pty
pty ind
ind (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0)
  , ptx -> ind -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook ptx
ptx ind
ind (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1), pty -> ind -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook pty
pty ind
ind (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1)
  , vv -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy vv
vv ]
------------------------------------------------------------------------------------------
-- Code Templates

-- Note how this one uses a semantic function in its body
-- But it is also 'wrong' in the sense that it assumes x_1 <= x <= x_2
linInterpCT :: Func
linInterpCT :: Func
linInterpCT = Name
-> Name
-> [DefinedQuantityDict]
-> Space
-> Maybe Name
-> [FuncStmt]
-> Func
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
Name -> Name -> [c] -> Space -> Maybe Name -> [FuncStmt] -> Func
funcDef Name
"lin_interp" Name
"Performs linear interpolation" 
  [DefinedQuantityDict
x_1, DefinedQuantityDict
y_1, DefinedQuantityDict
x_2, DefinedQuantityDict
y_2, DefinedQuantityDict
x] Space
Real (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"y value interpolated at given x value")
  [ CodeExpr -> FuncStmt
FRet (CodeExpr -> FuncStmt) -> CodeExpr -> FuncStmt
forall a b. (a -> b) -> a -> b
$ (CodeExpr, CodeExpr)
-> (CodeExpr, CodeExpr) -> CodeExpr -> CodeExpr
onLine (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
x_1, DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_1) (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
x_2, DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_2) (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
x) ]

findCT :: Func
findCT :: Func
findCT = Name
-> Name
-> [DefinedQuantityDict]
-> Space
-> Maybe Name
-> [FuncStmt]
-> Func
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
Name -> Name -> [c] -> Space -> Maybe Name -> [FuncStmt] -> Func
funcDef Name
"find" 
  Name
"Finds the array index for a value closest to the given value" 
  [DefinedQuantityDict
arr, DefinedQuantityDict
v] Space
Natural (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"index of given value in given array")
  [
    DefinedQuantityDict -> CodeExpr -> [FuncStmt] -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> [FuncStmt] -> FuncStmt
ffor DefinedQuantityDict
i (CodeExpr -> CodeExpr
forall r. ExprC r => r -> r
dim (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
arr) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$- Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1)
      [ CodeExpr -> [FuncStmt] -> [FuncStmt] -> FuncStmt
FCond ((DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook DefinedQuantityDict
arr DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
v) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$&& (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
v CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook DefinedQuantityDict
arr DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1)))
        [ CodeExpr -> FuncStmt
FRet (CodeExpr -> FuncStmt) -> CodeExpr -> FuncStmt
forall a b. (a -> b) -> a -> b
$ DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
i ] [] ],
    Name -> FuncStmt
FThrow Name
"Bound error"
  ]

extractColumnCT :: Func
extractColumnCT :: Func
extractColumnCT = Name
-> Name
-> [DefinedQuantityDict]
-> Space
-> Maybe Name
-> [FuncStmt]
-> Func
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
Name -> Name -> [c] -> Space -> Maybe Name -> [FuncStmt] -> Func
funcDef Name
"extractColumn" Name
"Extracts a column from a 2D matrix" 
  [DefinedQuantityDict
mat, DefinedQuantityDict
j] (Space -> Space
Vect Space
Real) (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"column of the given matrix at the given index")
  [
    DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
col ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
    --
    DefinedQuantityDict -> CodeExpr -> [FuncStmt] -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> [FuncStmt] -> FuncStmt
ffor DefinedQuantityDict
i (CodeExpr -> CodeExpr
forall r. ExprC r => r -> r
dim (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mat))
      [ CodeExpr -> CodeExpr -> FuncStmt
FAppend (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
col) (DefinedQuantityDict
-> DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr
forall a i j.
(HasSymbol a, HasSymbol i, HasSymbol j, HasUID a, HasUID i,
 HasUID j) =>
a -> i -> j -> CodeExpr
aLook DefinedQuantityDict
mat DefinedQuantityDict
i DefinedQuantityDict
j) ],
    CodeExpr -> FuncStmt
FRet (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
col)
  ]

interpY :: Func
interpY :: Func
interpY = Name
-> Name
-> [DefinedQuantityDict]
-> Space
-> Maybe Name
-> [FuncStmt]
-> Func
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
Name -> Name -> [c] -> Space -> Maybe Name -> [FuncStmt] -> Func
funcDef (DefinedQuantityDict -> Name
forall x. HasSymbol x => x -> Name
showHasSymbImpl DefinedQuantityDict
U.interpY)
  Name
"Linearly interpolates a y value at given x and z values" 
  [DefinedQuantityDict
filename, DefinedQuantityDict
x, DefinedQuantityDict
z] Space
Real (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"y value interpolated at given x and z values")
  [
  -- hack
  DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
xMatrix ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
  DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
yMatrix ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
  DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
zVector ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
  --
  Func -> [DefinedQuantityDict] -> FuncStmt
call Func
readTable [DefinedQuantityDict
filename, DefinedQuantityDict
zVector, DefinedQuantityDict
xMatrix, DefinedQuantityDict
yMatrix],
  -- endhack
    DefinedQuantityDict
i     DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr
forall zv z.
(HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) =>
zv -> z -> CodeExpr
find DefinedQuantityDict
zVector DefinedQuantityDict
z,
    DefinedQuantityDict
x_z_1 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
xMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0),
    DefinedQuantityDict
y_z_1 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
yMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0),
    DefinedQuantityDict
x_z_2 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
xMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1),
    DefinedQuantityDict
y_z_2 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
yMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1),
    [FuncStmt] -> [FuncStmt] -> FuncStmt
FTry
      [ DefinedQuantityDict
j DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr
forall zv z.
(HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) =>
zv -> z -> CodeExpr
find DefinedQuantityDict
x_z_1 DefinedQuantityDict
x,
        DefinedQuantityDict
k DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr
forall zv z.
(HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) =>
zv -> z -> CodeExpr
find DefinedQuantityDict
x_z_2 DefinedQuantityDict
x ]
      [ Name -> FuncStmt
FThrow Name
"Interpolation of y failed" ],
    DefinedQuantityDict
y_1 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= [CodeExpr] -> CodeExpr
linInterp (DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> [CodeExpr]
forall ptx pty ind vv.
(HasUID ptx, HasUID pty, HasUID ind, HasUID vv, HasSymbol ptx,
 HasSymbol pty, HasSymbol ind, HasSymbol vv) =>
ptx -> pty -> ind -> vv -> [CodeExpr]
interpOver DefinedQuantityDict
x_z_1 DefinedQuantityDict
y_z_1 DefinedQuantityDict
j DefinedQuantityDict
x),
    DefinedQuantityDict
y_2 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= [CodeExpr] -> CodeExpr
linInterp (DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> [CodeExpr]
forall ptx pty ind vv.
(HasUID ptx, HasUID pty, HasUID ind, HasUID vv, HasSymbol ptx,
 HasSymbol pty, HasSymbol ind, HasSymbol vv) =>
ptx -> pty -> ind -> vv -> [CodeExpr]
interpOver DefinedQuantityDict
x_z_2 DefinedQuantityDict
y_z_2 DefinedQuantityDict
k DefinedQuantityDict
x),
    CodeExpr -> FuncStmt
FRet (CodeExpr -> FuncStmt) -> CodeExpr -> FuncStmt
forall a b. (a -> b) -> a -> b
$ [CodeExpr] -> CodeExpr
linInterp [ DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook DefinedQuantityDict
zVector DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0), DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_1, DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook DefinedQuantityDict
zVector DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1), DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_2, DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
z ]
  ]

interpZ :: Func
interpZ :: Func
interpZ = Name
-> Name
-> [DefinedQuantityDict]
-> Space
-> Maybe Name
-> [FuncStmt]
-> Func
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
Name -> Name -> [c] -> Space -> Maybe Name -> [FuncStmt] -> Func
funcDef (DefinedQuantityDict -> Name
forall x. HasSymbol x => x -> Name
showHasSymbImpl DefinedQuantityDict
U.interpZ)
  Name
"Linearly interpolates a z value at given x and y values" 
  [DefinedQuantityDict
filename, DefinedQuantityDict
x, DefinedQuantityDict
y] Space
Real (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"z value interpolated at given x and y values")
  [
    -- hack
  DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
xMatrix ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
  DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
yMatrix ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
  DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
fDecDef DefinedQuantityDict
zVector ([[CodeExpr]] -> CodeExpr
forall r. ExprC r => [[r]] -> r
matrix [[]]),
  --
  Func -> [DefinedQuantityDict] -> FuncStmt
call Func
readTable [DefinedQuantityDict
filename, DefinedQuantityDict
zVector, DefinedQuantityDict
xMatrix, DefinedQuantityDict
yMatrix],
  -- endhack
    DefinedQuantityDict -> CodeExpr -> [FuncStmt] -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> [FuncStmt] -> FuncStmt
ffor DefinedQuantityDict
i (CodeExpr -> CodeExpr
forall r. ExprC r => r -> r
dim (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
zVector) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$- Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1)
      [
        DefinedQuantityDict
x_z_1 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
xMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0),
        DefinedQuantityDict
y_z_1 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
yMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0),
        DefinedQuantityDict
x_z_2 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
xMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1),
        DefinedQuantityDict
y_z_2 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
getCol DefinedQuantityDict
yMatrix DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1),
        [FuncStmt] -> [FuncStmt] -> FuncStmt
FTry
          [ DefinedQuantityDict
j DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr
forall zv z.
(HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) =>
zv -> z -> CodeExpr
find DefinedQuantityDict
x_z_1 DefinedQuantityDict
x,
            DefinedQuantityDict
k DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr
forall zv z.
(HasUID zv, HasUID z, HasSymbol zv, HasSymbol z) =>
zv -> z -> CodeExpr
find DefinedQuantityDict
x_z_2 DefinedQuantityDict
x ]
          [ FuncStmt
FContinue ],
        DefinedQuantityDict
y_1 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= [CodeExpr] -> CodeExpr
linInterp (DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> [CodeExpr]
forall ptx pty ind vv.
(HasUID ptx, HasUID pty, HasUID ind, HasUID vv, HasSymbol ptx,
 HasSymbol pty, HasSymbol ind, HasSymbol vv) =>
ptx -> pty -> ind -> vv -> [CodeExpr]
interpOver DefinedQuantityDict
x_z_1 DefinedQuantityDict
y_z_1 DefinedQuantityDict
j DefinedQuantityDict
x),
        DefinedQuantityDict
y_2 DefinedQuantityDict -> CodeExpr -> FuncStmt
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeExpr -> FuncStmt
$:= [CodeExpr] -> CodeExpr
linInterp (DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> DefinedQuantityDict
-> [CodeExpr]
forall ptx pty ind vv.
(HasUID ptx, HasUID pty, HasUID ind, HasUID vv, HasSymbol ptx,
 HasSymbol pty, HasSymbol ind, HasSymbol vv) =>
ptx -> pty -> ind -> vv -> [CodeExpr]
interpOver DefinedQuantityDict
x_z_2 DefinedQuantityDict
y_z_2 DefinedQuantityDict
k DefinedQuantityDict
x),
        CodeExpr -> [FuncStmt] -> [FuncStmt] -> FuncStmt
FCond ((DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_1 CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$&& (DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_2))
          [ CodeExpr -> FuncStmt
FRet (CodeExpr -> FuncStmt) -> CodeExpr -> FuncStmt
forall a b. (a -> b) -> a -> b
$ [CodeExpr] -> CodeExpr
linInterp [ DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_1, DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook DefinedQuantityDict
zVector DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
0), DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y_2, DefinedQuantityDict -> DefinedQuantityDict -> CodeExpr -> CodeExpr
forall a i.
(HasSymbol a, HasSymbol i, HasUID a, HasUID i) =>
a -> i -> CodeExpr -> CodeExpr
vLook DefinedQuantityDict
zVector DefinedQuantityDict
i (Integer -> CodeExpr
forall r. LiteralC r => Integer -> r
int Integer
1), DefinedQuantityDict -> CodeExpr
forall c. (HasUID c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
y ]
          ] []
      ],
    Name -> FuncStmt
FThrow Name
"Interpolation of z failed"
  ]

interpMod :: Mod
interpMod :: Mod
interpMod = Name -> Name -> [Class] -> [Func] -> Mod
packmod Name
"Interpolation" 
  Name
"Provides functions for linear interpolation on three-dimensional data" []
  [Func
linInterpCT, Func
findCT, Func
extractColumnCT, Func
interpY, Func
interpZ]