{-# LANGUAGE GADTs #-}

-- | Defines functions to render 'CodeExpr's as printable 'P.Expr's.
module Language.Drasil.Printing.Import.ModelExpr where -- TODO: tighten exports

-- TODO: tighten exports
import Language.Drasil (UID, DomainDesc(..), RealInterval(..), Inclusive(..),
  RTopology(..), Special(..), LiteralC(int))
import Language.Drasil.Display (Symbol(..))
import Language.Drasil.Literal.Development (Literal(..))
import Language.Drasil.ModelExpr.Development

import qualified Language.Drasil.Printing.AST as P
import Language.Drasil.Printing.PrintingInformation (PrintingInformation, ckdb, stg)

import Control.Lens ((^.))
import Data.List (intersperse)

import Language.Drasil.Printing.Import.Literal (literal)
import Language.Drasil.Printing.Import.Space (space)
import Language.Drasil.Printing.Import.Symbol (symbol)
import Language.Drasil.Printing.Import.Helpers (lookupC, parens)

-- | Helper that adds parenthesis to a display expression where appropriate.
modelExpr' :: PrintingInformation -> Int -> ModelExpr -> P.Expr
modelExpr' :: PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' s :: PrintingInformation
s p :: Int
p e :: ModelExpr
e = Expr -> Expr
fence (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
s
  where fence :: Expr -> Expr
fence = if ModelExpr -> Int
mePrec ModelExpr
e Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
p then Expr -> Expr
parens else Expr -> Expr
forall a. a -> a
id

-- | Helper that creates an expression row given printing information, an operator, and an expression.
mkCall :: PrintingInformation -> P.Ops -> ModelExpr -> P.Expr
mkCall :: PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall s :: PrintingInformation
s o :: Ops
o e :: ModelExpr
e = [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
o, Expr -> Expr
parens (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
s]

-- | Helper that creates a binary expression row given printing information, an operator, and two expressions.
mkBOp :: PrintingInformation -> P.Ops -> ModelExpr -> ModelExpr -> P.Expr
mkBOp :: PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp sm :: PrintingInformation
sm o :: Ops
o a :: ModelExpr
a b :: ModelExpr
b = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm, Ops -> Expr
P.MO Ops
o, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
sm]

-- | Helper for properly rendering negation of expressions.
neg' :: ModelExpr -> Bool
neg' :: ModelExpr -> Bool
neg' (Lit (Dbl _))          = Bool
True
neg' (Lit (Int _))          = Bool
True
neg' (Lit (ExactDbl _))     = Bool
True
neg' Operator{}             = Bool
True
neg' (AssocA MulI _)        = Bool
True
neg' (AssocA MulRe _)       = Bool
True
neg' (LABinaryOp Index _ _) = Bool
True
neg' (UnaryOp _ _)          = Bool
True
neg' (UnaryOpB _ _)         = Bool
True
neg' (UnaryOpVV _ _)        = Bool
True
neg' (C _)                  = Bool
True
neg' _                      = Bool
False

-- | Render negated expressions.
neg :: PrintingInformation -> ModelExpr -> P.Expr
neg :: PrintingInformation -> ModelExpr -> Expr
neg sm :: PrintingInformation
sm a :: ModelExpr
a = [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Neg, (if ModelExpr -> Bool
neg' ModelExpr
a then Expr -> Expr
forall a. a -> a
id else Expr -> Expr
parens) (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm]

-- | For printing indexes.
indx :: PrintingInformation -> ModelExpr -> ModelExpr -> P.Expr
indx :: PrintingInformation -> ModelExpr -> ModelExpr -> Expr
indx sm :: PrintingInformation
sm (C c :: UID
c) i :: ModelExpr
i = Symbol -> Expr
f Symbol
s
  where
    i' :: Expr
i' = ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
i PrintingInformation
sm
    s :: Symbol
s = Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
c
    f :: Symbol -> Expr
f (Corners [] [] [] [b :: Symbol
b] e :: Symbol
e) =
      let e' :: Expr
e' = Symbol -> Expr
symbol Symbol
e
          b' :: Expr
b' = Symbol -> Expr
symbol Symbol
b in
      [Expr] -> Expr
P.Row [[Expr] -> Expr
P.Row [Expr
e', Expr -> Expr
P.Sub ([Expr] -> Expr
P.Row [Expr
b', Ops -> Expr
P.MO Ops
P.Comma, Expr
i'])]] -- FIXME, extra Row
    f a :: Symbol
a@(Variable _) = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
a, Expr -> Expr
P.Sub Expr
i']
    f a :: Symbol
a@(Label _)    = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
a, Expr -> Expr
P.Sub Expr
i']
--    f a@(Greek _)  = P.Row [symbol a, P.Sub i']
    f   e :: Symbol
e          = let e' :: Expr
e' = Symbol -> Expr
symbol Symbol
e in [Expr] -> Expr
P.Row [[Expr] -> Expr
P.Row [Expr
e'], Expr -> Expr
P.Sub Expr
i']
indx sm :: PrintingInformation
sm a :: ModelExpr
a i :: ModelExpr
i = [Expr] -> Expr
P.Row [[Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm], Expr -> Expr
P.Sub (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
i PrintingInformation
sm]

-- | For printing expressions that call something.
call :: PrintingInformation -> UID -> [ModelExpr] -> [(UID, ModelExpr)] -> P.Expr
call :: PrintingInformation
-> UID -> [ModelExpr] -> [(UID, ModelExpr)] -> Expr
call sm :: PrintingInformation
sm f :: UID
f ps :: [ModelExpr]
ps ns :: [(UID, ModelExpr)]
ns = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
f,
  Expr -> Expr
parens (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ [Expr] -> Expr
P.Row ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
intersperse (Ops -> Expr
P.MO Ops
P.Comma) ([Expr] -> [Expr]) -> [Expr] -> [Expr]
forall a b. (a -> b) -> a -> b
$ (ModelExpr -> Expr) -> [ModelExpr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (ModelExpr -> PrintingInformation -> Expr
`modelExpr` PrintingInformation
sm) [ModelExpr]
ps [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
  (UID -> ModelExpr -> Expr) -> [UID] -> [ModelExpr] -> [Expr]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\n :: UID
n a :: ModelExpr
a -> [Expr] -> Expr
P.Row [Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
n,
  Ops -> Expr
P.MO Ops
P.Eq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm]) (((UID, ModelExpr) -> UID) -> [(UID, ModelExpr)] -> [UID]
forall a b. (a -> b) -> [a] -> [b]
map (UID, ModelExpr) -> UID
forall a b. (a, b) -> a
fst [(UID, ModelExpr)]
ns) (((UID, ModelExpr) -> ModelExpr)
-> [(UID, ModelExpr)] -> [ModelExpr]
forall a b. (a -> b) -> [a] -> [b]
map (UID, ModelExpr) -> ModelExpr
forall a b. (a, b) -> b
snd [(UID, ModelExpr)]
ns)]

-- | Helper function for addition 'EOperator's.
eopAdds :: PrintingInformation -> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> P.Expr
eopAdds :: PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
eopAdds sm :: PrintingInformation
sm (BoundedDD v :: Symbol
v Continuous l :: ModelExpr
l h :: ModelExpr
h) e :: ModelExpr
e =
  [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Inte, Expr -> Expr
P.Sub (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
l PrintingInformation
sm), Expr -> Expr
P.Sup (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
h PrintingInformation
sm),
         [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
sm], Spacing -> Expr
P.Spc Spacing
P.Thin, String -> Expr
P.Ident "d", Symbol -> Expr
symbol Symbol
v]
eopAdds sm :: PrintingInformation
sm (AllDD v :: Symbol
v Continuous) e :: ModelExpr
e =
  [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Inte, Expr -> Expr
P.Sub (Symbol -> Expr
symbol Symbol
v), [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
sm], Spacing -> Expr
P.Spc Spacing
P.Thin,
         String -> Expr
P.Ident "d", Symbol -> Expr
symbol Symbol
v]
eopAdds sm :: PrintingInformation
sm (BoundedDD v :: Symbol
v Discrete l :: ModelExpr
l h :: ModelExpr
h) e :: ModelExpr
e =
  [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Summ, Expr -> Expr
P.Sub ([Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
v, Ops -> Expr
P.MO Ops
P.Eq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
l PrintingInformation
sm]), Expr -> Expr
P.Sup (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
h PrintingInformation
sm),
         [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
sm]]
eopAdds sm :: PrintingInformation
sm (AllDD _ Discrete) e :: ModelExpr
e = [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Summ, [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
sm]]

-- | Helper function for multiplicative 'EOperator's.
eopMuls :: PrintingInformation -> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> P.Expr
eopMuls :: PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
eopMuls sm :: PrintingInformation
sm (BoundedDD v :: Symbol
v Discrete l :: ModelExpr
l h :: ModelExpr
h) e :: ModelExpr
e =
  [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Prod, Expr -> Expr
P.Sub ([Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
v, Ops -> Expr
P.MO Ops
P.Eq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
l PrintingInformation
sm]), Expr -> Expr
P.Sup (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
h PrintingInformation
sm),
         [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
sm]]
eopMuls sm :: PrintingInformation
sm (AllDD _ Discrete) e :: ModelExpr
e = [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Prod, [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
e PrintingInformation
sm]]
eopMuls _ (AllDD _ Continuous) _ = String -> Expr
forall a. HasCallStack => String -> a
error "Printing/Import.hs Product-Integral not implemented."
eopMuls _ (BoundedDD _ Continuous _ _) _ = String -> Expr
forall a. HasCallStack => String -> a
error "Printing/Import.hs Product-Integral not implemented."


-- | Helper function for translating 'EOperator's.
eop :: PrintingInformation -> AssocArithOper -> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> P.Expr
eop :: PrintingInformation
-> AssocArithOper
-> DomainDesc t ModelExpr ModelExpr
-> ModelExpr
-> Expr
eop sm :: PrintingInformation
sm AddI = PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
forall (t :: RTopology).
PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
eopAdds PrintingInformation
sm
eop sm :: PrintingInformation
sm AddRe = PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
forall (t :: RTopology).
PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
eopAdds PrintingInformation
sm
eop sm :: PrintingInformation
sm MulI = PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
forall (t :: RTopology).
PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
eopMuls PrintingInformation
sm
eop sm :: PrintingInformation
sm MulRe = PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
forall (t :: RTopology).
PrintingInformation
-> DomainDesc t ModelExpr ModelExpr -> ModelExpr -> Expr
eopMuls PrintingInformation
sm

-- | Helper function for display nth derivative
sup :: Integer -> [P.Expr]
sup :: Integer -> [Expr]
sup n :: Integer
n | Integer
n Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== 1 = []
      | Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> 1 = [Expr -> Expr
P.Sup (Integer -> Expr
P.Int Integer
n)]
      | Bool
otherwise = String -> [Expr]
forall a. HasCallStack => String -> a
error "non-positive argument to derivative"

-- | Translate Exprs to printable layout AST.
modelExpr :: ModelExpr -> PrintingInformation -> P.Expr
modelExpr :: ModelExpr -> PrintingInformation -> Expr
modelExpr (Lit l :: Literal
l)                    sm :: PrintingInformation
sm = Literal -> PrintingInformation -> Expr
literal Literal
l PrintingInformation
sm
modelExpr (AssocB And l :: [ModelExpr]
l)             sm :: PrintingInformation
sm = Ops -> Int -> [ModelExpr] -> PrintingInformation -> Expr
assocExpr Ops
P.And (AssocBoolOper -> Int
precB AssocBoolOper
And) [ModelExpr]
l PrintingInformation
sm
modelExpr (AssocB Or l :: [ModelExpr]
l)              sm :: PrintingInformation
sm = Ops -> Int -> [ModelExpr] -> PrintingInformation -> Expr
assocExpr Ops
P.Or (AssocBoolOper -> Int
precB AssocBoolOper
Or) [ModelExpr]
l PrintingInformation
sm
modelExpr (AssocB Equivalence l :: [ModelExpr]
l)     sm :: PrintingInformation
sm = Ops -> Int -> [ModelExpr] -> PrintingInformation -> Expr
assocExpr Ops
P.Eq (AssocBoolOper -> Int
precB AssocBoolOper
Equivalence) [ModelExpr]
l PrintingInformation
sm
modelExpr (AssocA AddI l :: [ModelExpr]
l)            sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
addExpr [ModelExpr]
l AssocArithOper
AddI PrintingInformation
sm
modelExpr (AssocA AddRe l :: [ModelExpr]
l)           sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
addExpr [ModelExpr]
l AssocArithOper
AddRe PrintingInformation
sm
modelExpr (AssocA MulI l :: [ModelExpr]
l)            sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr [ModelExpr]
l AssocArithOper
MulI PrintingInformation
sm
modelExpr (AssocA MulRe l :: [ModelExpr]
l)           sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr [ModelExpr]
l AssocArithOper
MulRe PrintingInformation
sm
modelExpr (Deriv 0 Part a :: ModelExpr
a _)         sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm]
modelExpr (Deriv 0 Total a :: ModelExpr
a _)        sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm]
modelExpr (Deriv n :: Integer
n Part a :: ModelExpr
a b :: UID
b)         sm :: PrintingInformation
sm =
  let st :: [Expr]
st = [Spacing -> Expr
P.Spc Spacing
P.Thin, Special -> Expr
P.Spec Special
Partial] in 
    Expr -> Expr -> Expr
P.Div ([Expr] -> Expr
P.Row ([Expr]
st [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ Integer -> [Expr]
sup Integer
n [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm]))
    ([Expr] -> Expr
P.Row ([Expr]
st [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
b] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ Integer -> [Expr]
sup Integer
n))
modelExpr (Deriv n :: Integer
n Total a :: ModelExpr
a b :: UID
b)        sm :: PrintingInformation
sm =
  let st :: [Expr]
st = [Spacing -> Expr
P.Spc Spacing
P.Thin, String -> Expr
P.Ident "d"] in
    Expr -> Expr -> Expr
P.Div ([Expr] -> Expr
P.Row ([Expr]
st [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ Integer -> [Expr]
sup Integer
n [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm]))
        ([Expr] -> Expr
P.Row ([Expr]
st [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
b] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ Integer -> [Expr]
sup Integer
n))
modelExpr (C c :: UID
c)                      sm :: PrintingInformation
sm = Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
c
modelExpr (FCall f :: UID
f [x :: ModelExpr
x] [])           sm :: PrintingInformation
sm =
  [Expr] -> Expr
P.Row [Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
f, Expr -> Expr
parens (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
x PrintingInformation
sm]
modelExpr (FCall f :: UID
f l :: [ModelExpr]
l ns :: [(UID, ModelExpr)]
ns)             sm :: PrintingInformation
sm = PrintingInformation
-> UID -> [ModelExpr] -> [(UID, ModelExpr)] -> Expr
call PrintingInformation
sm UID
f [ModelExpr]
l [(UID, ModelExpr)]
ns
modelExpr (Case _ ps :: [(ModelExpr, ModelExpr)]
ps)                sm :: PrintingInformation
sm =
  if [(ModelExpr, ModelExpr)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(ModelExpr, ModelExpr)]
ps Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 2
    then String -> Expr
forall a. HasCallStack => String -> a
error "Attempting to use multi-case modelExpr incorrectly"
    else [(Expr, Expr)] -> Expr
P.Case ([Expr] -> [Expr] -> [(Expr, Expr)]
forall a b. [a] -> [b] -> [(a, b)]
zip (((ModelExpr, ModelExpr) -> Expr)
-> [(ModelExpr, ModelExpr)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map ((ModelExpr -> PrintingInformation -> Expr)
-> PrintingInformation -> ModelExpr -> Expr
forall a b c. (a -> b -> c) -> b -> a -> c
flip ModelExpr -> PrintingInformation -> Expr
modelExpr PrintingInformation
sm (ModelExpr -> Expr)
-> ((ModelExpr, ModelExpr) -> ModelExpr)
-> (ModelExpr, ModelExpr)
-> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModelExpr, ModelExpr) -> ModelExpr
forall a b. (a, b) -> a
fst) [(ModelExpr, ModelExpr)]
ps) (((ModelExpr, ModelExpr) -> Expr)
-> [(ModelExpr, ModelExpr)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map ((ModelExpr -> PrintingInformation -> Expr)
-> PrintingInformation -> ModelExpr -> Expr
forall a b c. (a -> b -> c) -> b -> a -> c
flip ModelExpr -> PrintingInformation -> Expr
modelExpr PrintingInformation
sm (ModelExpr -> Expr)
-> ((ModelExpr, ModelExpr) -> ModelExpr)
-> (ModelExpr, ModelExpr)
-> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModelExpr, ModelExpr) -> ModelExpr
forall a b. (a, b) -> b
snd) [(ModelExpr, ModelExpr)]
ps))
modelExpr (Matrix a :: [[ModelExpr]]
a)                 sm :: PrintingInformation
sm = [[Expr]] -> Expr
P.Mtx ([[Expr]] -> Expr) -> [[Expr]] -> Expr
forall a b. (a -> b) -> a -> b
$ ([ModelExpr] -> [Expr]) -> [[ModelExpr]] -> [[Expr]]
forall a b. (a -> b) -> [a] -> [b]
map ((ModelExpr -> Expr) -> [ModelExpr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (ModelExpr -> PrintingInformation -> Expr
`modelExpr` PrintingInformation
sm)) [[ModelExpr]]
a
modelExpr (UnaryOp Log u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Log ModelExpr
u
modelExpr (UnaryOp Ln u :: ModelExpr
u)             sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Ln ModelExpr
u
modelExpr (UnaryOp Sin u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Sin ModelExpr
u
modelExpr (UnaryOp Cos u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Cos ModelExpr
u
modelExpr (UnaryOp Tan u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Tan ModelExpr
u
modelExpr (UnaryOp Sec u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Sec ModelExpr
u
modelExpr (UnaryOp Csc u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Csc ModelExpr
u
modelExpr (UnaryOp Cot u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Cot ModelExpr
u
modelExpr (UnaryOp Arcsin u :: ModelExpr
u)         sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Arcsin ModelExpr
u
modelExpr (UnaryOp Arccos u :: ModelExpr
u)         sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Arccos ModelExpr
u
modelExpr (UnaryOp Arctan u :: ModelExpr
u)         sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Arctan ModelExpr
u
modelExpr (UnaryOp Exp u :: ModelExpr
u)            sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Exp, Expr -> Expr
P.Sup (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
u PrintingInformation
sm]
modelExpr (UnaryOp Abs u :: ModelExpr
u)            sm :: PrintingInformation
sm = Fence -> Fence -> Expr -> Expr
P.Fenced Fence
P.Abs Fence
P.Abs (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
u PrintingInformation
sm
modelExpr (UnaryOpB Not u :: ModelExpr
u)           sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [Ops -> Expr
P.MO Ops
P.Not, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
u PrintingInformation
sm]
modelExpr (UnaryOpVN Norm u :: ModelExpr
u)         sm :: PrintingInformation
sm = Fence -> Fence -> Expr -> Expr
P.Fenced Fence
P.Norm Fence
P.Norm (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
u PrintingInformation
sm
modelExpr (UnaryOpVN Dim u :: ModelExpr
u)          sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> Expr
mkCall PrintingInformation
sm Ops
P.Dim ModelExpr
u
modelExpr (UnaryOp Sqrt u :: ModelExpr
u)           sm :: PrintingInformation
sm = Expr -> Expr
P.Sqrt (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
u PrintingInformation
sm
modelExpr (UnaryOp Neg u :: ModelExpr
u)            sm :: PrintingInformation
sm = PrintingInformation -> ModelExpr -> Expr
neg PrintingInformation
sm ModelExpr
u
modelExpr (UnaryOpVV NegV u :: ModelExpr
u)         sm :: PrintingInformation
sm = PrintingInformation -> ModelExpr -> Expr
neg PrintingInformation
sm ModelExpr
u
modelExpr (ArithBinaryOp Frac a :: ModelExpr
a b :: ModelExpr
b)   sm :: PrintingInformation
sm = Expr -> Expr -> Expr
P.Div (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm) (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
sm)
modelExpr (ArithBinaryOp Pow a :: ModelExpr
a b :: ModelExpr
b)    sm :: PrintingInformation
sm = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
pow PrintingInformation
sm ModelExpr
a ModelExpr
b
modelExpr (ArithBinaryOp Subt a :: ModelExpr
a b :: ModelExpr
b)   sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
sm, Ops -> Expr
P.MO Ops
P.Subt, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
sm]
modelExpr (BoolBinaryOp Impl a :: ModelExpr
a b :: ModelExpr
b)    sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Impl ModelExpr
a ModelExpr
b
modelExpr (BoolBinaryOp Iff a :: ModelExpr
a b :: ModelExpr
b)     sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Iff ModelExpr
a ModelExpr
b
modelExpr (EqBinaryOp Eq a :: ModelExpr
a b :: ModelExpr
b)        sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Eq ModelExpr
a ModelExpr
b
modelExpr (EqBinaryOp NEq a :: ModelExpr
a b :: ModelExpr
b)       sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.NEq ModelExpr
a ModelExpr
b
modelExpr (LABinaryOp Index a :: ModelExpr
a b :: ModelExpr
b)     sm :: PrintingInformation
sm = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
indx PrintingInformation
sm ModelExpr
a ModelExpr
b
modelExpr (OrdBinaryOp Lt a :: ModelExpr
a b :: ModelExpr
b)       sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Lt ModelExpr
a ModelExpr
b
modelExpr (OrdBinaryOp Gt a :: ModelExpr
a b :: ModelExpr
b)       sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Gt ModelExpr
a ModelExpr
b
modelExpr (OrdBinaryOp LEq a :: ModelExpr
a b :: ModelExpr
b)      sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.LEq ModelExpr
a ModelExpr
b
modelExpr (OrdBinaryOp GEq a :: ModelExpr
a b :: ModelExpr
b)      sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.GEq ModelExpr
a ModelExpr
b
modelExpr (VVNBinaryOp Dot a :: ModelExpr
a b :: ModelExpr
b)      sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Dot ModelExpr
a ModelExpr
b
modelExpr (VVVBinaryOp Cross a :: ModelExpr
a b :: ModelExpr
b)    sm :: PrintingInformation
sm = PrintingInformation -> Ops -> ModelExpr -> ModelExpr -> Expr
mkBOp PrintingInformation
sm Ops
P.Cross ModelExpr
a ModelExpr
b
modelExpr (Operator o :: AssocArithOper
o d :: DomainDesc t ModelExpr ModelExpr
d e :: ModelExpr
e)           sm :: PrintingInformation
sm = PrintingInformation
-> AssocArithOper
-> DomainDesc t ModelExpr ModelExpr
-> ModelExpr
-> Expr
forall (t :: RTopology).
PrintingInformation
-> AssocArithOper
-> DomainDesc t ModelExpr ModelExpr
-> ModelExpr
-> Expr
eop PrintingInformation
sm AssocArithOper
o DomainDesc t ModelExpr ModelExpr
d ModelExpr
e
modelExpr (RealI c :: UID
c ri :: RealInterval ModelExpr ModelExpr
ri)               sm :: PrintingInformation
sm = PrintingInformation
-> Symbol -> RealInterval ModelExpr ModelExpr -> Expr
renderRealInt PrintingInformation
sm (Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg)
  (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
c) RealInterval ModelExpr ModelExpr
ri
modelExpr (Spc s :: Space
s)                    sm :: PrintingInformation
sm = PrintingInformation -> Space -> Expr
space PrintingInformation
sm Space
s
modelExpr (SpaceBinaryOp IsIn l :: ModelExpr
l r :: ModelExpr
r)   sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
l PrintingInformation
sm, Ops -> Expr
P.MO Ops
P.IsIn, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
r PrintingInformation
sm]
modelExpr (StatBinaryOp Defines l :: ModelExpr
l r :: ModelExpr
r) sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
l PrintingInformation
sm, Ops -> Expr
P.MO Ops
P.Eq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
r PrintingInformation
sm]
modelExpr (ForAll c :: UID
c s :: Space
s de :: ModelExpr
de)            sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row [
    Ops -> Expr
P.MO Ops
P.ForAll, Symbol -> Expr
symbol (Symbol -> Expr) -> Symbol -> Expr
forall a b. (a -> b) -> a -> b
$ Stage -> ChunkDB -> UID -> Symbol
lookupC (PrintingInformation
sm PrintingInformation
-> Getting Stage PrintingInformation Stage -> Stage
forall s a. s -> Getting a s a -> a
^. Getting Stage PrintingInformation Stage
Lens' PrintingInformation Stage
stg) (PrintingInformation
sm PrintingInformation
-> Getting ChunkDB PrintingInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB PrintingInformation ChunkDB
Lens' PrintingInformation ChunkDB
ckdb) UID
c, Ops -> Expr
P.MO Ops
P.IsIn, PrintingInformation -> Space -> Expr
space PrintingInformation
sm Space
s,
    Ops -> Expr
P.MO Ops
P.Dot, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
de PrintingInformation
sm
  ]

-- | Common method of converting associative operations into printable layout AST.
assocExpr :: P.Ops -> Int -> [ModelExpr] -> PrintingInformation -> P.Expr
assocExpr :: Ops -> Int -> [ModelExpr] -> PrintingInformation -> Expr
assocExpr op :: Ops
op prec :: Int
prec exprs :: [ModelExpr]
exprs sm :: PrintingInformation
sm = [Expr] -> Expr
P.Row ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
intersperse (Ops -> Expr
P.MO Ops
op) ([Expr] -> [Expr]) -> [Expr] -> [Expr]
forall a b. (a -> b) -> a -> b
$ (ModelExpr -> Expr) -> [ModelExpr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm Int
prec) [ModelExpr]
exprs

-- | Helper for rendering printable expressions.
addExpr :: [ModelExpr] -> AssocArithOper -> PrintingInformation -> [P.Expr]
addExpr :: [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
addExpr exprs :: [ModelExpr]
exprs o :: AssocArithOper
o sm :: PrintingInformation
sm = [Expr] -> [Expr]
addExprFilter ((ModelExpr -> Expr) -> [ModelExpr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o)) [ModelExpr]
exprs)

-- | Add add symbol only when the second Expr is not negation 
addExprFilter :: [P.Expr] -> [P.Expr]
addExprFilter :: [Expr] -> [Expr]
addExprFilter [] = []
addExprFilter [x :: Expr
x] = [Expr
x]
addExprFilter (x1 :: Expr
x1:P.Row[P.MO P.Neg, x2 :: Expr
x2]:xs :: [Expr]
xs) = Expr
x1 Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr] -> [Expr]
addExprFilter ([Expr] -> Expr
P.Row[Ops -> Expr
P.MO Ops
P.Neg, Expr
x2] Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr]
xs)
addExprFilter (x :: Expr
x:xs :: [Expr]
xs) = Expr
x Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: Ops -> Expr
P.MO Ops
P.Add Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: [Expr] -> [Expr]
addExprFilter [Expr]
xs

-- | Helper for rendering printable expressions.
mulExpr ::  [ModelExpr] -> AssocArithOper -> PrintingInformation -> [P.Expr]
mulExpr :: [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr (hd1 :: ModelExpr
hd1:hd2 :: ModelExpr
hd2:tl :: [ModelExpr]
tl) o :: AssocArithOper
o sm :: PrintingInformation
sm = case (ModelExpr
hd1, ModelExpr
hd2) of
  (a :: ModelExpr
a, Lit (Int _))      ->  [PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o) ModelExpr
a, Ops -> Expr
P.MO Ops
P.Dot] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr (ModelExpr
hd2 ModelExpr -> [ModelExpr] -> [ModelExpr]
forall a. a -> [a] -> [a]
: [ModelExpr]
tl) AssocArithOper
o PrintingInformation
sm
  (a :: ModelExpr
a, Lit (ExactDbl _)) ->  [PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o) ModelExpr
a, Ops -> Expr
P.MO Ops
P.Dot] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr (ModelExpr
hd2 ModelExpr -> [ModelExpr] -> [ModelExpr]
forall a. a -> [a] -> [a]
: [ModelExpr]
tl) AssocArithOper
o PrintingInformation
sm
  (a :: ModelExpr
a, Lit (Dbl _))      ->  [PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o) ModelExpr
a, Ops -> Expr
P.MO Ops
P.Dot] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr (ModelExpr
hd2 ModelExpr -> [ModelExpr] -> [ModelExpr]
forall a. a -> [a] -> [a]
: [ModelExpr]
tl) AssocArithOper
o PrintingInformation
sm
  (a :: ModelExpr
a, _)                ->  [PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o) ModelExpr
a, Ops -> Expr
P.MO Ops
P.Mul] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [ModelExpr] -> AssocArithOper -> PrintingInformation -> [Expr]
mulExpr (ModelExpr
hd2 ModelExpr -> [ModelExpr] -> [ModelExpr]
forall a. a -> [a] -> [a]
: [ModelExpr]
tl) AssocArithOper
o PrintingInformation
sm
mulExpr [hd :: ModelExpr
hd]         o :: AssocArithOper
o sm :: PrintingInformation
sm = [PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o) ModelExpr
hd]
mulExpr []           o :: AssocArithOper
o sm :: PrintingInformation
sm = [PrintingInformation -> Int -> ModelExpr -> Expr
modelExpr' PrintingInformation
sm (AssocArithOper -> Int
precA AssocArithOper
o) (Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int 1)]


-- | Helper that adds parenthesis to the first expression. The second expression
-- is written as a superscript attached to the first.
withParens :: PrintingInformation -> ModelExpr -> ModelExpr -> P.Expr
withParens :: PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens prI :: PrintingInformation
prI a :: ModelExpr
a b :: ModelExpr
b = [Expr] -> Expr
P.Row [Expr -> Expr
parens (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
prI), Expr -> Expr
P.Sup (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
prI)]

-- | Helper for properly rendering exponents.
pow :: PrintingInformation -> ModelExpr -> ModelExpr -> P.Expr
pow :: PrintingInformation -> ModelExpr -> ModelExpr -> Expr
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(AssocA AddI _)          b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(AssocA AddRe _)         b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(AssocA MulI _)          b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(AssocA MulRe _)         b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(ArithBinaryOp Subt _ _) b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(ArithBinaryOp Frac _ _) b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a@(ArithBinaryOp Pow _ _)  b :: ModelExpr
b = PrintingInformation -> ModelExpr -> ModelExpr -> Expr
withParens PrintingInformation
prI ModelExpr
a ModelExpr
b
pow prI :: PrintingInformation
prI a :: ModelExpr
a                          b :: ModelExpr
b = [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
prI, Expr -> Expr
P.Sup (ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
prI)]

-- | Print a 'RealInterval'.
renderRealInt :: PrintingInformation -> Symbol -> RealInterval ModelExpr ModelExpr -> P.Expr
renderRealInt :: PrintingInformation
-> Symbol -> RealInterval ModelExpr ModelExpr -> Expr
renderRealInt st :: PrintingInformation
st s :: Symbol
s (Bounded (Inc,a :: ModelExpr
a) (Inc,b :: ModelExpr
b)) =
  [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st, Ops -> Expr
P.MO Ops
P.LEq, Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.LEq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (Bounded (Inc,a :: ModelExpr
a) (Exc,b :: ModelExpr
b)) =
  [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st, Ops -> Expr
P.MO Ops
P.LEq, Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.Lt, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (Bounded (Exc,a :: ModelExpr
a) (Inc,b :: ModelExpr
b)) =
  [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st, Ops -> Expr
P.MO Ops
P.Lt, Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.LEq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (Bounded (Exc,a :: ModelExpr
a) (Exc,b :: ModelExpr
b)) =
  [Expr] -> Expr
P.Row [ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st, Ops -> Expr
P.MO Ops
P.Lt, Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.Lt, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
b PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (UpTo (Inc,a :: ModelExpr
a))   = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.LEq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (UpTo (Exc,a :: ModelExpr
a))   = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.Lt,  ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (UpFrom (Inc,a :: ModelExpr
a)) = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.GEq, ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st]
renderRealInt st :: PrintingInformation
st s :: Symbol
s (UpFrom (Exc,a :: ModelExpr
a)) = [Expr] -> Expr
P.Row [Symbol -> Expr
symbol Symbol
s, Ops -> Expr
P.MO Ops
P.Gt,  ModelExpr -> PrintingInformation -> Expr
modelExpr ModelExpr
a PrintingInformation
st]