{-# LANGUAGE PostfixOperators #-}
module Drasil.SSP.IMods where

import Prelude hiding (tan, product, sin, cos)

import Language.Drasil
import Theory.Drasil
import Utils.Drasil (weave)
import Language.Drasil.Chunk.Concept.NamedCombinators
import qualified Language.Drasil.Sentence.Combinators as S
import Drasil.DocLang.SRS (propCorSol)

-- Needed for derivations
import Data.Drasil.Concepts.Documentation (analysis, assumption, constraint,
  definition, first, goal, method_, physical, problem, solution, value)
import Data.Drasil.Concepts.Math (angle, equation, leftSide)
import Data.Drasil.Concepts.PhysicalProperties (mass)
import Data.Drasil.Concepts.Physics (force)

import Drasil.SSP.Assumptions (assumpSSC, assumpINSFL,
  assumpES, assumpSF, assumpSL)
import Drasil.SSP.BasicExprs (eqlExpr, eqlExprN, eqlExprSepG, eqlExprNSepG,
  eqlExprNoKQ, eqlExprNNoKQ, sliceExpr, momExpr, momExprNoKQ)
import Drasil.SSP.DataDefs (convertFunc1, convertFunc2,
  intersliceWtrF, lengthB, angleA, angleB, slcHeight, ratioVariation)
import Drasil.SSP.GenDefs (normShrRGD, momentEqlGD, normForcEqGD, mobShearWOGD,
  resShearWOGD, bsShrFEqGD, mobShrGD, srfWtrFGD)
import Drasil.SSP.Goals (goals, identifyCritAndFSGS)
import Drasil.SSP.Defs (crtSlpSrf, factorOfSafety, morPrice, slice,
  slpSrf, ssa)
import Drasil.SSP.References (chen2005, li2010, karchewski2012)
import Drasil.SSP.TMods (equilibrium, mcShrStrgth)
import Drasil.SSP.Unitals (baseAngle, baseHydroForce, baseLngth, baseWthX,
  critCoords,
  effCohesion, constF, dryWeight, earthqkLoadFctr, fricAngle, fs, fsMin,
  index, indx1, indxn, intNormForce, intShrForce, inxi, inxiM1, midpntHght,
  minFunction, mobShrC, mobShrI, nrmForceSum, nrmShearNum, normToShear,
  nrmFSubWat, numbSlices, satWeight, scalFunc, shearFNoIntsl, nrmShearDen,
  shearRNoIntsl, shrResC, slipDist, slipHght, slopeDist, slopeHght, sum1toN,
  surfAngle, surfHydroForce, surfLoad, totNrmForce, varblV, watrForce,
  waterDist, waterHght, waterWeight, watForceSum, xi, xMaxExtSlip, xMaxEtrSlip,
  xMinExtSlip, xMinEtrSlip, yi, yMaxSlip, yMinSlip)

-----------------------
--  Instance Models  --
-----------------------

iMods :: [InstanceModel]
iMods :: [InstanceModel]
iMods = [InstanceModel
fctSfty, InstanceModel
nrmShrFor, InstanceModel
nrmShrForNum, InstanceModel
nrmShrForDen, InstanceModel
intsliceFs, InstanceModel
crtSlpId]

--

fctSfty :: InstanceModel
fctSfty :: InstanceModel
fctSfty = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (forall e. QDefinition e -> ModelKind e
equationalModel' SimpleQDef
fctSftyQD)
 [forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
effCohesion, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
fricAngle,
  forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
dryWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
satWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw ConstrConcept
fs) [] (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (forall a. a -> Maybe a
Just Derivation
fctSftyDeriv) String
"fctSfty" [Sentence
fctSftyDesc]

fctSftyQD :: SimpleQDef
fctSftyQD :: SimpleQDef
fctSftyQD = forall c e.
(Quantity c, MayHaveUnit c) =>
c -> NP -> e -> QDefinition e
mkQuantDef' ConstrConcept
fs NP
factorOfSafety PExpr
fctSftyExpr

fctSftyExpr :: PExpr
fctSftyExpr :: PExpr
fctSftyExpr = forall {c}. (HasUID c, HasSymbol c) => c -> r
sumOp UnitalChunk
shearRNoIntsl forall r. ExprC r => r -> r -> r
$/ forall {c}. (HasUID c, HasSymbol c) => c -> r
sumOp UnitalChunk
shearFNoIntsl
  where prodOp :: r
prodOp = forall r. ExprC r => Symbol -> r -> r -> r -> r
defprod (forall q. HasSymbol q => q -> Symbol
eqSymb DefinedQuantityDict
varblV) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)
          (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
varblV))
        sumOp :: c -> r
sumOp c
sym = forall r. ExprC r => Symbol -> r -> r -> r -> r
defsum (forall q. HasSymbol q => q -> Symbol
eqSymb DefinedQuantityDict
index) (forall r. LiteralC r => Integer -> r
int Integer
1) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)
          (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy c
sym) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index) forall r. ExprC r => r -> r -> r
`mulRe` r
prodOp) forall r. ExprC r => r -> r -> r
`addRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy c
sym) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)

fctSftyDesc :: Sentence
fctSftyDesc :: Sentence
fctSftyDesc = SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [UnitalChunk
shearRNoIntsl forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
resShearWOGD,
  DefinedQuantityDict
mobShrC forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
convertFunc2,
  UnitalChunk
shearFNoIntsl forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
mobShearWOGD]

fctSftyDeriv :: Derivation
fctSftyDeriv :: Derivation
fctSftyDeriv = [Sentence] -> Derivation
mkDerivNoHeader (forall a. [[a]] -> [a]
weave [[Sentence]
fctSftyDerivSentences1, forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns1] forall a. [a] -> [a] -> [a]
++
  forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [PExpr
fctSftyDerivEqn10b, PExpr
fctSftyDerivEqn10c] forall a. [a] -> [a] -> [a]
++ [Sentence
fctSftyDerivEllipsis] forall a. [a] -> [a] -> [a]
++
  forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [PExpr
fctSftyDerivEqn10d, PExpr
fctSftyDerivEqn10e, PExpr
fctSftyDerivEqn10f] forall a. [a] -> [a] -> [a]
++
  forall a. [[a]] -> [a]
weave [[Sentence]
fctSftyDerivSentences2, forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns2] forall a. [a] -> [a] -> [a]
++
  [Sentence]
fctSftyDerivSentence20)

fctSftyDerivSentences1 :: [Sentence]
fctSftyDerivSentences1 :: [Sentence]
fctSftyDerivSentences1 = forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
fctSftyDerivSentence1,
  [Sentence]
fctSftyDerivSentence2, [Sentence]
fctSftyDerivSentence3, [Sentence]
fctSftyDerivSentence4,
  [Sentence]
fctSftyDerivSentence5, [Sentence]
fctSftyDerivSentence6, [Sentence]
fctSftyDerivSentence7,
  [Sentence]
fctSftyDerivSentence8, [Sentence]
fctSftyDerivSentence9, [Sentence]
fctSftyDerivSentence10]

fctSftyDerivSentences2 :: [Sentence]
fctSftyDerivSentences2 :: [Sentence]
fctSftyDerivSentences2 = forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
fctSftyDerivSentence11,
  [Sentence]
fctSftyDerivSentence12, [Sentence]
fctSftyDerivSentence13, [Sentence]
fctSftyDerivSentence14,
  [Sentence]
fctSftyDerivSentence15, [Sentence]
fctSftyDerivSentence16, [Sentence]
fctSftyDerivSentence17,
  [Sentence]
fctSftyDerivSentence18, [Sentence]
fctSftyDerivSentence19]

fctSftyDerivEqns1 :: (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns1 :: forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns1 = [PExpr
fctSftyDerivEqn1, PExpr
fctSftyDerivEqn2, PExpr
fctSftyDerivEqn3,
  PExpr
fctSftyDerivEqn4, PExpr
fctSftyDerivEqn5, PExpr
fctSftyDerivEqn6, PExpr
fctSftyDerivEqn7,
  PExpr
fctSftyDerivEqn8, PExpr
fctSftyDerivEqn9, PExpr
fctSftyDerivEqn10a]

fctSftyDerivEqns2 :: (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns2 :: forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns2 = [PExpr
fctSftyDerivEqn11, PExpr
fctSftyDerivEqn12, PExpr
fctSftyDerivEqn13,
  PExpr
fctSftyDerivEqn14, PExpr
fctSftyDerivEqn15, PExpr
fctSftyDerivEqn16, PExpr
fctSftyDerivEqn17,
  PExpr
fctSftyDerivEqn18, forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
$= PExpr
fctSftyExpr]

fctSftyDerivSentence1 :: [Sentence]
fctSftyDerivSentence1 :: [Sentence]
fctSftyDerivSentence1 = [forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the UnitalChunk
mobShrI), forall r. (Referable r, HasShortName r) => r -> Sentence
definedIn'' GenDefn
bsShrFEqGD, 
  String -> Sentence
S String
"can be substituted into the definition of",
  forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
mobShrI, String -> Sentence
S String
"based on the", forall n. NamedIdea n => n -> Sentence
phrase ConstrConcept
fs Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"from",
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
mobShrGD, String -> Sentence
S String
"yielding", Int -> Sentence
eqN Int
1, String -> Sentence
S String
"below"]

fctSftyDerivSentence2 :: [Sentence]
fctSftyDerivSentence2 :: [Sentence]
fctSftyDerivSentence2 = [String -> Sentence
S String
"An expression for the", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
nrmFSubWat Sentence -> Sentence -> Sentence
`sC`
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
nrmFSubWat Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"can be derived by substituting the",
  forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
totNrmForce, String -> Sentence
S String
"equilibrium from", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normForcEqGD,
  String -> Sentence
S String
"into the definition for", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
nrmFSubWat, String -> Sentence
S String
"from" Sentence -> Sentence -> Sentence
+:+. forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
resShearWOGD, String -> Sentence
S String
"This results in", Int -> Sentence
eqN Int
2]

fctSftyDerivSentence3 :: [Sentence]
fctSftyDerivSentence3 :: [Sentence]
fctSftyDerivSentence3 = [String -> Sentence
S String
"Substituting", Int -> Sentence
eqN Int
2, String -> Sentence
S String
"into", Int -> Sentence
eqN Int
1, String -> Sentence
S String
"gives"]

fctSftyDerivSentence4 :: [Sentence]
fctSftyDerivSentence4 :: [Sentence]
fctSftyDerivSentence4 = [String -> Sentence
S String
"Since the", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
intShrForce,
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intShrForce Sentence -> Sentence -> Sentence
`S.and_` forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
intNormForce, forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce,
  String -> Sentence
S String
"are unknown, they are separated from the other terms as follows"]

fctSftyDerivSentence5 :: [Sentence]
fctSftyDerivSentence5 :: [Sentence]
fctSftyDerivSentence5 = [String -> Sentence
S String
"Applying assumptions", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSF Sentence -> Sentence -> Sentence
`S.and_`
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSL Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which state that the",
  forall n. NounPhrase n => n -> Sentence
phraseNP (DefinedQuantityDict
earthqkLoadFctr forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`andThe` UnitalChunk
surfLoad) Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"respectively, are zero, allows for further simplification as shown below"]

fctSftyDerivSentence6 :: [Sentence]
fctSftyDerivSentence6 :: [Sentence]
fctSftyDerivSentence6 = [String -> Sentence
S String
"The definitions of", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
resShearWOGD
  Sentence -> Sentence -> Sentence
`S.and_` forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
mobShearWOGD, String -> Sentence
S String
"are present in this equation, and",
  String -> Sentence
S String
"thus can be replaced by", ModelExpr -> Sentence
eS (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl) Sentence -> Sentence -> Sentence
`S.and_`
  ModelExpr -> Sentence
eS (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"respectively"]

fctSftyDerivSentence7 :: [Sentence]
fctSftyDerivSentence7 :: [Sentence]
fctSftyDerivSentence7 = [forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the UnitalChunk
intShrForce), forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intShrForce,
  String -> Sentence
S String
"can be expressed in terms of the", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
intNormForce,
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce, String -> Sentence
S String
"using", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpINSFL Sentence -> Sentence -> Sentence
`S.and_`
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"resulting in"]

fctSftyDerivSentence8 :: [Sentence]
fctSftyDerivSentence8 :: [Sentence]
fctSftyDerivSentence8 = [String -> Sentence
S String
"Rearranging yields the following"]

fctSftyDerivSentence9 :: [Sentence]
fctSftyDerivSentence9 :: [Sentence]
fctSftyDerivSentence9 = [String -> Sentence
S String
"The definitions for" Sentence -> Sentence -> Sentence
+:+ forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
shrResC Sentence -> Sentence -> Sentence
`S.and_`
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
mobShrC Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"from" Sentence -> Sentence -> Sentence
+:+ forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
convertFunc1 Sentence -> Sentence -> Sentence
`S.and_`
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
convertFunc2 Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"simplify the above to", Int -> Sentence
eqN Int
3]

fctSftyDerivSentence10 :: [Sentence]
fctSftyDerivSentence10 :: [Sentence]
fctSftyDerivSentence10 = [String -> Sentence
S String
"Versions of", Int -> Sentence
eqN Int
3, String -> Sentence
S String
"instantiated for slices",
  String -> Sentence
S String
"1 to", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
numbSlices, String -> Sentence
S String
"are shown below"]

fctSftyDerivEllipsis :: Sentence
fctSftyDerivEllipsis :: Sentence
fctSftyDerivEllipsis = String -> Sentence
S String
"..."

fctSftyDerivSentence11 :: [Sentence]
fctSftyDerivSentence11 :: [Sentence]
fctSftyDerivSentence11 = [String -> Sentence
S String
"Applying", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpES Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"which says that", ModelExpr -> Sentence
eS (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`S.and_`
  ModelExpr -> Sentence
eS (forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
intNormForce), String -> Sentence
S String
"are zero, results in the following special cases:",Int -> Sentence
eqN Int
8, String -> Sentence
S String
"for the first slice"]

fctSftyDerivSentence12 :: [Sentence]
fctSftyDerivSentence12 :: [Sentence]
fctSftyDerivSentence12 = [String -> Sentence
S String
"and", Int -> Sentence
eqN Int
9, String -> Sentence
S String
"for the", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
numbSlices Sentence -> Sentence -> Sentence
:+:
  String -> Sentence
S String
"th slice"]

fctSftyDerivSentence13 :: [Sentence]
fctSftyDerivSentence13 :: [Sentence]
fctSftyDerivSentence13 = [String -> Sentence
S String
"Substituting", Int -> Sentence
eqN Int
8, String -> Sentence
S String
"into", Int -> Sentence
eqN Int
4, String -> Sentence
S String
"yields", Int -> Sentence
eqN Int
10]

fctSftyDerivSentence14 :: [Sentence]
fctSftyDerivSentence14 :: [Sentence]
fctSftyDerivSentence14 = [String -> Sentence
S String
"which can be substituted into", Int -> Sentence
eqN Int
5, String -> Sentence
S String
"to get", Int -> Sentence
eqN Int
11]

fctSftyDerivSentence15 :: [Sentence]
fctSftyDerivSentence15 :: [Sentence]
fctSftyDerivSentence15 = [String -> Sentence
S String
"and so on until", Int -> Sentence
eqN Int
12, String -> Sentence
S String
"is obtained from", Int -> Sentence
eqN Int
7]

fctSftyDerivSentence16 :: [Sentence]
fctSftyDerivSentence16 :: [Sentence]
fctSftyDerivSentence16 = [Int -> Sentence
eqN Int
9, String -> Sentence
S String
"can then be substituted into the",
  forall n. NamedIdea n => n -> Sentence
phrase CI
leftSide Sentence -> Sentence -> Sentence
`S.of_` Int -> Sentence
eqN Int
12 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"resulting in"]

fctSftyDerivSentence17 :: [Sentence]
fctSftyDerivSentence17 :: [Sentence]
fctSftyDerivSentence17 = [String -> Sentence
S String
"This can be rearranged by multiplying both sides",
  String -> Sentence
S String
"by", ModelExpr -> Sentence
eS (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) Sentence -> Sentence -> Sentence
`S.and_`
  String -> Sentence
S String
"then distributing the multiplication of each", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
mobShrC,
  String -> Sentence
S String
"over addition to obtain"]

fctSftyDerivSentence18 :: [Sentence]
fctSftyDerivSentence18 :: [Sentence]
fctSftyDerivSentence18 = [String -> Sentence
S String
"The multiplication of the", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
mobShrC,
  String -> Sentence
S String
"terms can be further distributed over the subtractions, resulting in the",
  String -> Sentence
S String
"equation having terms that each either contain an", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearRNoIntsl,
  String -> Sentence
S String
"or a" Sentence -> Sentence -> Sentence
+:+. forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearFNoIntsl, String -> Sentence
S String
"The equation can then be rearranged so",
  String -> Sentence
S String
"terms containing an", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearRNoIntsl, String -> Sentence
S String
"are on one side of the",
  String -> Sentence
S String
"equality, and terms containing a", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearFNoIntsl Sentence -> Sentence -> Sentence
+:+.
  String -> Sentence
S String
"are on the other", String -> Sentence
S String
"The multiplication by the", forall n. NamedIdea n => n -> Sentence
phrase ConstrConcept
fs,
  String -> Sentence
S String
"is common to all of the", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearFNoIntsl, String -> Sentence
S String
"terms, and thus can be",
  String -> Sentence
S String
"factored out, resulting in"]

fctSftyDerivSentence19 :: [Sentence]
fctSftyDerivSentence19 :: [Sentence]
fctSftyDerivSentence19 = [String -> Sentence
S String
"Isolating the", forall n. NamedIdea n => n -> Sentence
phrase ConstrConcept
fs, String -> Sentence
S String
"on the left-hand",
  String -> Sentence
S String
"side and using compact notation for the products and sums yields",
  Int -> Sentence
eqN Int
13 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which can also be seen in", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty]

fctSftyDerivSentence20 :: [Sentence]
fctSftyDerivSentence20 :: [Sentence]
fctSftyDerivSentence20 = [forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch ConstrConcept
fs Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"depends on the unknowns" Sentence -> Sentence -> Sentence
+:+
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor) Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce Sentence -> Sentence -> Sentence
+:+.
  Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs)]

fctSftyDerivEqn1 :: PExpr
fctSftyDerivEqn1 :: PExpr
fctSftyDerivEqn1 = --FIXME: pull the right side of this from GD4
  forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExpr forall r. ExprC r => r -> r
sin forall r. ExprC r => r -> r
cos (\r
x r
y -> r
x forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` r
y)
  forall r. ExprC r => r -> r -> r
$= (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmFSubWat forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) forall r. ExprC r => r -> r -> r
$/ forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn2 :: PExpr
fctSftyDerivEqn2 :: PExpr
fctSftyDerivEqn2 = forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmFSubWat forall r. ExprC r => r -> r -> r
$= forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprN forall r. ExprC r => r -> r
cos forall r. ExprC r => r -> r
sin (\r
x r
y -> r
x forall r. ExprC r => r -> r -> r
$-
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` r
y) forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce

fctSftyDerivEqn3 :: PExpr
fctSftyDerivEqn3 :: PExpr
fctSftyDerivEqn3 = forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExpr forall r. ExprC r => r -> r
sin forall r. ExprC r => r -> r
cos (\r
x r
y -> r
x forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` r
y) forall r. ExprC r => r -> r -> r
$= ((forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprN forall r. ExprC r => r -> r
cos forall r. ExprC r => r -> r
sin (\r
x r
y -> r
x forall r. ExprC r => r -> r -> r
$-
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce forall r. ExprC r => r -> r -> r
`addRe` r
y) forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) forall r. ExprC r => r -> r -> r
$/ forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn4 :: PExpr
fctSftyDerivEqn4 :: PExpr
fctSftyDerivEqn4 = forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprSepG forall r. ExprC r => r -> r
sin forall r. ExprC r => r -> r
cos forall r. ExprC r => r -> r -> r
addRe forall r. ExprC r => r -> r -> r
`addRe`
  ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
$=
  ((forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprNSepG forall r. ExprC r => r -> r
cos forall r. ExprC r => r -> r
sin forall r. ExprC r => r -> r -> r
addRe forall r. ExprC r => r -> r -> r
`addRe`
  (((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
$-
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) forall r. ExprC r => r -> r -> r
$/ forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn5 :: PExpr
fctSftyDerivEqn5 :: PExpr
fctSftyDerivEqn5 = forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprNoKQ forall r. ExprC r => r -> r
sin forall r. ExprC r => r -> r
cos forall r. ExprC r => r -> r -> r
addRe forall r. ExprC r => r -> r -> r
`addRe`
  ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
$=
  ((forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprNNoKQ forall r. ExprC r => r -> r
cos forall r. ExprC r => r -> r
sin forall r. ExprC r => r -> r -> r
addRe forall r. ExprC r => r -> r -> r
`addRe`
  ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
$-
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) forall r. ExprC r => r -> r -> r
$/ forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn6 :: PExpr
fctSftyDerivEqn6 :: PExpr
fctSftyDerivEqn6 = (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
`addRe` ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`addRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
$- ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`addRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle))) forall r. ExprC r => r -> r -> r
$= (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl forall r. ExprC r => r -> r -> r
`addRe`
  (((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
`addRe`
  ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle))) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle))) forall r. ExprC r => r -> r -> r
$/ forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn7 :: PExpr
fctSftyDerivEqn7 :: PExpr
fctSftyDerivEqn7 = (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
`addRe` ((forall r. ExprC r => r -> r
neg (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear) forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce)) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
$- ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)))
  forall r. ExprC r => r -> r -> r
$= (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl forall r. ExprC r => r -> r -> r
`addRe` (((forall r. ExprC r => r -> r
neg (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce)) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
`addRe` ((forall r. ExprC r => r -> r
neg (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce)
  forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle))) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle))) forall r. ExprC r => r -> r -> r
$/ forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn8 :: PExpr
fctSftyDerivEqn8 :: PExpr
fctSftyDerivEqn8 = (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
$- forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) forall r. ExprC r => r -> r -> r
$-
  ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
`addRe`
  forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs))) forall r. ExprC r => r -> r -> r
$= (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe`
  ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) forall r. ExprC r => r -> r -> r
$- ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
`addRe` forall r. ExprC r => r -> r
cos (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl)

fctSftyDerivEqn9 :: PExpr
fctSftyDerivEqn9 :: PExpr
fctSftyDerivEqn9 = (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
shrResC) forall r. ExprC r => r -> r -> r
$= (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
mobShrC forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
shrResC forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) forall r. ExprC r => r -> r -> r
$-
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl)

fctSftyDerivEqn10a :: PExpr
fctSftyDerivEqn10a :: PExpr
fctSftyDerivEqn10a = forall r. (ExprC r, LiteralC r) => Integer -> r
sliceExpr Integer
1

fctSftyDerivEqn10b :: PExpr
fctSftyDerivEqn10b :: PExpr
fctSftyDerivEqn10b = forall r. (ExprC r, LiteralC r) => Integer -> r
sliceExpr Integer
2

fctSftyDerivEqn10c :: PExpr
fctSftyDerivEqn10c :: PExpr
fctSftyDerivEqn10c = forall r. (ExprC r, LiteralC r) => Integer -> r
sliceExpr Integer
3

fctSftyDerivEqn10d :: PExpr
fctSftyDerivEqn10d :: PExpr
fctSftyDerivEqn10d = forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
$= (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2))

fctSftyDerivEqn10e :: PExpr
fctSftyDerivEqn10e :: PExpr
fctSftyDerivEqn10e = forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$= (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1))

fctSftyDerivEqn10f :: PExpr
fctSftyDerivEqn10f :: PExpr
fctSftyDerivEqn10f = forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices) forall r. ExprC r => r -> r -> r
$= (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices))

fctSftyDerivEqn11 :: PExpr
fctSftyDerivEqn11 :: PExpr
fctSftyDerivEqn11 = (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 DefinedQuantityDict
shrResC) forall r. ExprC r => r -> r -> r
$=
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearRNoIntsl)

fctSftyDerivEqn12 :: PExpr
fctSftyDerivEqn12 :: PExpr
fctSftyDerivEqn12 = forall r. ExprC r => r -> r
neg ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$- forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl) forall r. ExprC r => r -> r -> r
$/
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
$=
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1))

fctSftyDerivEqn13 :: PExpr
fctSftyDerivEqn13 :: PExpr
fctSftyDerivEqn13 = forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
$=
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2))

fctSftyDerivEqn14 :: PExpr
fctSftyDerivEqn14 :: PExpr
fctSftyDerivEqn14 = forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
$=
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
3)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
3))

-- Need to add ellipses where appropriate
fctSftyDerivEqn15 :: PExpr
fctSftyDerivEqn15 :: PExpr
fctSftyDerivEqn15 = forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$= (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe`
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$- forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$- forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1))

-- Ellipses needed here too
fctSftyDerivEqn16 :: PExpr
fctSftyDerivEqn16 :: PExpr
fctSftyDerivEqn16 = forall r. ExprC r => r -> r
neg ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$- forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl) forall r. ExprC r => r -> r -> r
$/
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
$= (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$-
  forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
3) forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$- forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$- forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1))

-- Ellipses needed here too
fctSftyDerivEqn17 :: PExpr
fctSftyDerivEqn17 :: PExpr
fctSftyDerivEqn17 = forall r. ExprC r => r -> r
neg (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$- forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl) forall r. ExprC r => r -> r -> r
$=
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$-
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearRNoIntsl) forall r. ExprC r => r -> r -> r
`addRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
$- forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2))) forall r. ExprC r => r -> r -> r
`addRe`
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
$-
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1))))

-- Ellipses needed here too
fctSftyDerivEqn18 :: PExpr
fctSftyDerivEqn18 :: PExpr
fctSftyDerivEqn18 = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`addRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`addRe` forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl) forall r. ExprC r => r -> r -> r
$=
  (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`addRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r. LiteralC r => Integer -> r
int Integer
2) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r. LiteralC r => Integer -> r
int Integer
2)) forall r. ExprC r => r -> r -> r
`addRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
  forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`addRe` forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl)

------------------------------------------------------------------------

nrmShrFor :: InstanceModel
nrmShrFor :: InstanceModel
nrmShrFor = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im ModelKind Relation
nrmShrForMK [forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght,
  forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw DefinedQuantityDict
normToShear) [] (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (forall a. a -> Maybe a
Just Derivation
nrmShrDeriv) String
"nrmShrFor" [Sentence
nrmShrFDesc]

nrmShrForMK :: ModelKind Expr
nrmShrForMK :: ModelKind Relation
nrmShrForMK = forall e. String -> NP -> QDefinition e -> ModelKind e
equationalModel String
"nrmShrForIM"
  (String -> NP
nounPhraseSP String
"normal and shear force proportionality constant") SimpleQDef
nrmShrForQD

nrmShrForQD :: SimpleQDef
nrmShrForQD :: SimpleQDef
nrmShrForQD = forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef DefinedQuantityDict
normToShear PExpr
nrmShrFExpr

nrmShrFExpr :: PExpr
nrmShrFExpr :: PExpr
nrmShrFExpr = forall r. (ExprC r, LiteralC r) => r -> r
sum1toN (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearNum) forall r. ExprC r => r -> r -> r
$/ forall r. (ExprC r, LiteralC r) => r -> r
sum1toN (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearDen)

nrmShrFDesc :: Sentence
nrmShrFDesc :: Sentence
nrmShrFDesc = UnitalChunk
nrmShearNum forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  InstanceModel
nrmShrForNum Sentence -> Sentence -> Sentence
`S.and_` (UnitalChunk
nrmShearDen forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  InstanceModel
nrmShrForDen !.)

nrmShrDeriv :: Derivation
nrmShrDeriv :: Derivation
nrmShrDeriv = [Sentence] -> Derivation
mkDerivNoHeader (forall a. [[a]] -> [a]
weave [[Sentence]
nrmShrDerivationSentences, forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS forall r. (ExprC r, LiteralC r) => [r]
nrmShrDerivEqns] forall a. [a] -> [a] -> [a]
++
  [Sentence]
nrmShrDerivSentence5)

nrmShrDerivSentence1 :: [Sentence]
nrmShrDerivSentence1 :: [Sentence]
nrmShrDerivSentence1 = [String -> Sentence
S String
"From the", forall n. NamedIdea n => n -> Sentence
phrase GenDefn
momentEqlGD Sentence -> Sentence -> Sentence
`S.of_`
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
momentEqlGD, String -> Sentence
S String
"with the primary", forall n. NamedIdea n => n -> Sentence
phrase CI
assumption,
  String -> Sentence
S String
"for the Morgenstern-Price method of", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpINSFL Sentence -> Sentence -> Sentence
`S.and_`
  String -> Sentence
S String
"associated", forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
definition, forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
`sC` Int -> Sentence
eqN Int
14,
  String -> Sentence
S String
"can be derived"]

nrmShrDerivSentence2 :: [Sentence]
nrmShrDerivSentence2 :: [Sentence]
nrmShrDerivSentence2 = [String -> Sentence
S String
"Rearranging the", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"in terms of",
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear, String -> Sentence
S String
"leads to", Int -> Sentence
eqN Int
15]

nrmShrDerivSentence3 :: [Sentence]
nrmShrDerivSentence3 :: [Sentence]
nrmShrDerivSentence3 = [String -> Sentence
S String
"This", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"can be simplified by",
  String -> Sentence
S String
"applying", forall n. NamedIdea n => n -> Sentence
plural CI
assumption, forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSF Sentence -> Sentence -> Sentence
`S.and_`
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSL Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which state that the seismic" Sentence -> Sentence -> Sentence
`S.and_`
  forall n. NamedIdea n => n -> Sentence
plural UnitalChunk
surfLoad Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"respectively" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"are zero"]

nrmShrDerivSentence4 :: [Sentence]
nrmShrDerivSentence4 :: [Sentence]
nrmShrDerivSentence4 = [String -> Sentence
S String
"Taking the summation of all", forall n. NamedIdea n => n -> Sentence
plural IdeaDict
slice Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"and applying", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpES, String -> Sentence
S String
"to set",
  ModelExpr -> Sentence
eS (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`sC` ModelExpr -> Sentence
eS (forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
intNormForce) Sentence -> Sentence -> Sentence
`sC`
  ModelExpr -> Sentence
eS (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watrForce) (forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and", ModelExpr -> Sentence
eS (forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
watrForce),
  String -> Sentence
S String
"equal to zero" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"a general", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"for the",
  forall a. Quantity a => a -> Sentence
getTandS DefinedQuantityDict
normToShear, String -> Sentence
S String
"is developed in", Int -> Sentence
eqN Int
16 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which combines", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor Sentence -> Sentence -> Sentence
`sC` forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrForNum Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and",
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrForDen]

nrmShrDerivSentence5 :: [Sentence]
nrmShrDerivSentence5 :: [Sentence]
nrmShrDerivSentence5 = [Int -> Sentence
eqN Int
16 Sentence -> Sentence -> Sentence
`S.for` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"is a function of the unknown" Sentence -> Sentence -> Sentence
+:+ forall a. Quantity a => a -> Sentence
getTandS UnitalChunk
intNormForce Sentence -> Sentence -> Sentence
+:+
  Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs) Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"which itself depends on the unknown" Sentence -> Sentence -> Sentence
+:+
  forall a. Quantity a => a -> Sentence
getTandS ConstrConcept
fs Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty)]

nrmShrDerivationSentences :: [Sentence]
nrmShrDerivationSentences :: [Sentence]
nrmShrDerivationSentences = forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
nrmShrDerivSentence1,
  [Sentence]
nrmShrDerivSentence2, [Sentence]
nrmShrDerivSentence3, [Sentence]
nrmShrDerivSentence4]

nrmShrDerivEqns :: (ExprC r, LiteralC r) => [r]
nrmShrDerivEqns :: forall r. (ExprC r, LiteralC r) => [r]
nrmShrDerivEqns = [PExpr
nrmShrDerivEqn1, PExpr
nrmShrDerivEqn2, PExpr
nrmShrDerivEqn3,
  PExpr
nrmShrDerivEqn4]

nrmShrDerivEqn1, nrmShrDerivEqn2, nrmShrDerivEqn3, nrmShrDerivEqn4 :: PExpr
nrmShrDerivEqn1 :: PExpr
nrmShrDerivEqn1 = forall r. LiteralC r => Integer -> r
exactDbl Integer
0 forall r. ExprC r => r -> r -> r
$=
  forall r. (ExprC r, LiteralC r) => (r -> r -> r) -> r
momExpr (\ r
x r
y -> r
x forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
`mulRe` forall r. (ExprC r, LiteralC r) => r -> r
half (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX) forall r. ExprC r => r -> r -> r
`mulRe`
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`addRe` (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe`
  forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc))) forall r. ExprC r => r -> r -> r
`addRe` r
y)

nrmShrDerivEqn2 :: PExpr
nrmShrDerivEqn2 = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
$= forall r. (ExprC r, LiteralC r) => (r -> r -> r) -> r
momExpr forall r. ExprC r => r -> r -> r
addRe
  forall r. ExprC r => r -> r -> r
$/ forall r. ExprC r => r -> r
neg (forall r. (ExprC r, LiteralC r) => r -> r
half (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX) forall r. ExprC r => r -> r -> r
`mulRe` (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`addRe`
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc)))

nrmShrDerivEqn3 :: PExpr
nrmShrDerivEqn3 = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
$= forall r. (ExprC r, LiteralC r) => (r -> r -> r) -> r
momExprNoKQ forall r. ExprC r => r -> r -> r
addRe
  forall r. ExprC r => r -> r -> r
$/ forall r. ExprC r => r -> r
neg (forall r. (ExprC r, LiteralC r) => r -> r
half (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX) forall r. ExprC r => r -> r -> r
`mulRe` (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`addRe`
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc)))

nrmShrDerivEqn4 :: PExpr
nrmShrDerivEqn4 = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear forall r. ExprC r => r -> r -> r
$= forall r. (ExprC r, LiteralC r) => r -> r
sum1toN
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
nrmForceSum forall r. ExprC r => r -> r -> r
`addRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watForceSum) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) forall r. ExprC r => r -> r -> r
`addRe`
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
midpntHght forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
neg (forall r. LiteralC r => Integer -> r
exactDbl Integer
2 forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfHydroForce forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfAngle))))
  forall r. ExprC r => r -> r -> r
$/ forall r. (ExprC r, LiteralC r) => r -> r
sum1toN
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`addRe`
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc)))

---------------------------------------------------------------------

nrmShrForNum :: InstanceModel
nrmShrForNum :: InstanceModel
nrmShrForNum = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
nrmShrForNumRC) [forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght,
  forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght]
  (forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw UnitalChunk
nrmShearNum) [] (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (forall a. a -> Maybe a
Just Derivation
nrmShrFNumDeriv) String
"nrmShrForNum" [Sentence
nrmShrFNumDesc]

nrmShrForNumRC :: RelationConcept
nrmShrForNumRC :: RelationConcept
nrmShrForNumRC = forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"nrmShrForNumRC" (String -> NP
nounPhraseSP String
"normal and shear force proportionality constant numerator")
  Sentence
nrmShrFNumDesc Relation
nrmShrFNumRel

nrmShrFNumRel :: Relation
nrmShrFNumRel :: Relation
nrmShrFNumRel = forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearNum forall r. ExprC r => r -> r -> r
$= forall r. ExprC r => [(r, r)] -> r
incompleteCase [(Relation, Relation)
case1,(Relation, Relation)
case2,(Relation, Relation)
case3]
  where case1 :: (Relation, Relation)
case1 = (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`addRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
watrForce) forall r. ExprC r => r -> r -> r
`mulRe`
          forall r. ExprC r => r -> r
tan (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
baseAngle), forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r. LiteralC r => Integer -> r
int Integer
1)
        case2 :: (Relation, Relation)
case2 = ((forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe`
          (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
nrmForceSum forall r. ExprC r => r -> r -> r
`addRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watForceSum)
           forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
midpntHght forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r
neg
          (forall r. LiteralC r => Integer -> r
exactDbl Integer
2) forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfHydroForce forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
sin (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfAngle))),
          forall r. LiteralC r => Integer -> r
int Integer
2 forall r. ExprC r => r -> r -> r
$<= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$<= (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1))
        case3 :: (Relation, Relation)
case3 = (forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce)
          (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`addRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watrForce)
          (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)) forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r
tan (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
baseAngle)
          (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)), forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)

nrmShrFNumDeriv :: Derivation
nrmShrFNumDeriv :: Derivation
nrmShrFNumDeriv = [Sentence] -> Derivation
mkDerivNoHeader [[Sentence] -> Sentence
foldlSent [String -> Sentence
S String
"See", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor,
  String -> Sentence
S String
"for the derivation" Sentence -> Sentence -> Sentence
`S.of_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
nrmShearNum]]

nrmShrFNumDesc :: Sentence
nrmShrFNumDesc :: Sentence
nrmShrFNumDesc = (SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [UnitalChunk
baseWthX forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
lengthB,
  UnitalChunk
watrForce forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
intersliceWtrF,
  UnitalChunk
baseAngle forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
angleA,
  UnitalChunk
midpntHght forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
slcHeight,
  UnitalChunk
surfHydroForce forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
srfWtrFGD,
  UnitalChunk
surfAngle forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
angleB] !.)

---------------------------------------------------------------------------

nrmShrForDen :: InstanceModel
nrmShrForDen :: InstanceModel
nrmShrForDen = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
nrmShrForDenRC) [forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw UnitalChunk
nrmShearDen) [] (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (forall a. a -> Maybe a
Just Derivation
nrmShrFDenDeriv) String
"nrmShrForDen" [Sentence
nrmShrFDenDesc]

nrmShrForDenRC :: RelationConcept
nrmShrForDenRC :: RelationConcept
nrmShrForDenRC = forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"nrmShrForDenRC" (String -> NP
nounPhraseSP String
"normal and shear force proportionality constant denominator")
  Sentence
nrmShrFDenDesc Relation
nrmShrFDenRel

nrmShrFDenRel :: Relation
nrmShrFDenRel :: Relation
nrmShrFDenRel = forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearDen forall r. ExprC r => r -> r -> r
$= forall r. ExprC r => [(r, r)] -> r
incompleteCase [
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
intNormForce, forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r. LiteralC r => Integer -> r
int Integer
1),
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`addRe`
    (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce)),
    forall r. LiteralC r => Integer -> r
int Integer
2 forall r. ExprC r => r -> r -> r
$<= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$<= (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)),
  (forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
baseWthX forall r. ExprC r => r -> r -> r
`mulRe` forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1) forall r. ExprC r => r -> r -> r
`mulRe`
    forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
scalFunc) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1), forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)
  ]

nrmShrFDenDeriv :: Derivation
nrmShrFDenDeriv :: Derivation
nrmShrFDenDeriv = [Sentence] -> Derivation
mkDerivNoHeader [[Sentence] -> Sentence
foldlSent [String -> Sentence
S String
"See", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor,
  String -> Sentence
S String
"for the derivation" Sentence -> Sentence -> Sentence
`S.of_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
nrmShearDen]]

nrmShrFDenDesc :: Sentence
nrmShrFDenDesc :: Sentence
nrmShrFDenDesc = UnitalChunk
baseWthX forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  DataDefinition
lengthB Sentence -> Sentence -> Sentence
`S.and_` (DefinedQuantityDict
scalFunc forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  DataDefinition
ratioVariation !.)

--------------------------------------------------------------------------

intsliceFs :: InstanceModel
intsliceFs :: InstanceModel
intsliceFs = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
intsliceFsRC) [forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght
  , forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
effCohesion, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
fricAngle, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
dryWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
satWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight
  , forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw UnitalChunk
intNormForce) [] [forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
chen2005] (forall a. a -> Maybe a
Just Derivation
intrSlcDeriv) String
"intsliceFs" [Sentence
sliceFsDesc]

intsliceFsRC :: RelationConcept
intsliceFsRC :: RelationConcept
intsliceFsRC = forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"intsliceFsRC" (String -> NP
nounPhraseSP String
"interslice normal forces")
  Sentence
sliceFsDesc Relation
sliceFsRel -- inslideFxL

sliceFsRel :: Relation
sliceFsRel :: Relation
sliceFsRel = forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
$= forall r. ExprC r => [(r, r)] -> r
incompleteCase [
  ((forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearRNoIntsl) forall r. ExprC r => r -> r -> r
$/ forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 DefinedQuantityDict
shrResC,
    forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r. LiteralC r => Integer -> r
int Integer
1),
  ((forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
mobShrC forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`addRe`
    (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl)) forall r. ExprC r => r -> r -> r
$/ forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
shrResC,
    forall r. LiteralC r => Integer -> r
int Integer
2 forall r. ExprC r => r -> r -> r
$<= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$<= (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices forall r. ExprC r => r -> r -> r
$- forall r. LiteralC r => Integer -> r
int Integer
1)),
  (forall r. LiteralC r => Integer -> r
int Integer
0, forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r. LiteralC r => Integer -> r
int Integer
0 forall r. ExprC r => r -> r -> r
$|| forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)]
  -- FIXME: Use index i as part of condition

sliceFsDesc :: Sentence
sliceFsDesc :: Sentence
sliceFsDesc = (SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [UnitalChunk
shearFNoIntsl forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
mobShearWOGD,
  UnitalChunk
shearRNoIntsl forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
resShearWOGD,
  DefinedQuantityDict
shrResC forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
convertFunc1,
  DefinedQuantityDict
mobShrC forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
convertFunc2] !.)

intrSlcDeriv :: Derivation
intrSlcDeriv :: Derivation
intrSlcDeriv = [Sentence] -> Derivation
mkDerivNoHeader (forall a. [[a]] -> [a]
weave [[Sentence]
intrSlcDerivationSentences, forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS forall r. (ExprC r, LiteralC r) => [r]
intrSlcDerivEqns] forall a. [a] -> [a] -> [a]
++ [Sentence]
intrSlcDerivSentence3)

intrSlcDerivSentence1 :: [Sentence]
intrSlcDerivSentence1 :: [Sentence]
intrSlcDerivSentence1 = [String -> Sentence
S String
"This derivation is identical to the derivation for",
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty, String -> Sentence
S String
"up until", Int -> Sentence
eqN Int
3, String -> Sentence
S String
"shown again below"]

intrSlcDerivSentence2 :: [Sentence]
intrSlcDerivSentence2 :: [Sentence]
intrSlcDerivSentence2 = [String -> Sentence
S String
"A simple rearrangement of", Int -> Sentence
eqN Int
3, String -> Sentence
S String
"leads to",
  Int -> Sentence
eqN Int
17 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"also seen in", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs]

intrSlcDerivSentence3 :: [Sentence]
intrSlcDerivSentence3 :: [Sentence]
intrSlcDerivSentence3 = [String -> Sentence
S String
"The cases shown in" Sentence -> Sentence -> Sentence
+:+ forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"for when" Sentence -> Sentence -> Sentence
+:+ ModelExpr -> Sentence
eS (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r. LiteralC r => Integer -> r
int Integer
0) Sentence -> Sentence -> Sentence
`sC` ModelExpr -> Sentence
eS (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r. LiteralC r => Integer -> r
int Integer
1) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"or" Sentence -> Sentence -> Sentence
+:+
  ModelExpr -> Sentence
eS (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index forall r. ExprC r => r -> r -> r
$= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices) Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"are derived by applying" Sentence -> Sentence -> Sentence
+:+
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpES Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which says that" Sentence -> Sentence -> Sentence
+:+
  ModelExpr -> Sentence
eS (forall r. ExprC r => r -> r -> r
idx (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`S.and_` ModelExpr -> Sentence
eS (forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
intNormForce) Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"are zero" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"to" Sentence -> Sentence -> Sentence
+:+. Int -> Sentence
eqN Int
17 Sentence -> Sentence -> Sentence
+:+ forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"depends on the unknowns" Sentence -> Sentence -> Sentence
+:+ forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch ConstrConcept
fs Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty) Sentence -> Sentence -> Sentence
`S.and_`
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor)]

intrSlcDerivationSentences :: [Sentence]
intrSlcDerivationSentences :: [Sentence]
intrSlcDerivationSentences = forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
intrSlcDerivSentence1,
  [Sentence]
intrSlcDerivSentence2]

intrSlcDerivEqns :: (ExprC r, LiteralC r) => [r]
intrSlcDerivEqns :: forall r. (ExprC r, LiteralC r) => [r]
intrSlcDerivEqns = [PExpr
fctSftyDerivEqn9, PExpr
intrSlcDerivEqn]

intrSlcDerivEqn :: PExpr
intrSlcDerivEqn :: PExpr
intrSlcDerivEqn = forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
$=
  (forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
mobShrC forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce forall r. ExprC r => r -> r -> r
`addRe`
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs forall r. ExprC r => r -> r -> r
`mulRe` forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) forall r. ExprC r => r -> r -> r
$- forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl) forall r. ExprC r => r -> r -> r
$/ forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
shrResC

--------------------------------------------------------------------------
crtSlpId :: InstanceModel
crtSlpId :: InstanceModel
crtSlpId = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> String
-> [Sentence]
-> InstanceModel
imNoDeriv (forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
crtSlpIdRC) [forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterDist,
  forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
effCohesion, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
fricAngle, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
dryWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
satWeight,
  forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF] (forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw DefinedQuantityDict
fsMin) [] [forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
li2010] String
"crtSlpId"
  [Sentence
crtSlpIdDesc]

crtSlpIdRC :: RelationConcept
crtSlpIdRC :: RelationConcept
crtSlpIdRC = forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"crtSlpIdIM" 
  (String -> NP
nounPhraseSP String
"critical slip surface identification")
  Sentence
crtSlpIdDesc
  Relation
crtSlpIdRel

-- placeholder expression hack that's better than the horrible hack
crtSlpIdRel :: Relation
crtSlpIdRel :: Relation
crtSlpIdRel = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
slopeDist forall r. ExprC r => r -> r -> r
$= forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
slopeHght

  {- equationalModel "crtSlpIdIM"
  (nounPhraseSP "critical slip surface identification") crtSlpIdQD -}

{-
crtSlpIdQD :: SimpleQDef
crtSlpIdQD = mkQuantDef fsMin crtSlpIdExpr

-- FIXME: horrible hack. This is short an argument... that was never defined!
-- FIXME: critCoords should also be an output
crtSlpIdExpr :: Expr
crtSlpIdExpr = apply minFunction [sy slopeDist,
  sy slopeHght, sy waterDist, sy waterHght, sy effCohesion, sy fricAngle,
  sy dryWeight, sy satWeight, sy waterWeight]
-}

-- FIXME: The constraints described here should be replaced with formal constraints on the input variables once that is possible
crtSlpIdDesc :: Sentence
crtSlpIdDesc :: Sentence
crtSlpIdDesc = [Sentence] -> Sentence
foldlSent [forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the DefinedQuantityDict
minFunction), String -> Sentence
S String
"must enforce the",
  forall n. NounPhrase n => n -> Sentence
pluralNP (IdeaDict
constraint forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`onThePS` ConceptChunk
crtSlpSrf), String -> Sentence
S String
"expressed in" Sentence -> Sentence -> Sentence
+:+.
  (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSSC Sentence -> Sentence -> Sentence
`S.and_` forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ([Contents] -> [Section] -> Section
propCorSol [] [])),
  String -> Sentence
S String
"The sizes of", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterDist Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterHght Sentence -> Sentence -> Sentence
+:+.
  String -> Sentence
S String
"must be equal and not 1", String -> Sentence
S String
"The", String -> Sentence
S String
"sizes of", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
`S.and_`
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght Sentence -> Sentence -> Sentence
+:+. (String -> Sentence
S String
"must be equal" Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"at least 2"),
  forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the IdeaDict
first) Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"last", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterDist,
  forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value, String -> Sentence
S String
"must be equal to the", forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
first Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"last",
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
+:+. forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value, forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterDist Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist,
  forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
+:+. String -> Sentence
S String
"must be monotonically increasing", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMaxExtSlip Sentence -> Sentence -> Sentence
`sC`
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMaxEtrSlip Sentence -> Sentence -> Sentence
`sC` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMinExtSlip Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMinEtrSlip, String -> Sentence
S String
"must be",
  String -> Sentence
S String
"between or equal to the minimum and maximum", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
+:+.
  forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value, forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
yMaxSlip, String -> Sentence
S String
"cannot be below the minimum", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght Sentence -> Sentence -> Sentence
+:+.
  forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
yMinSlip, String -> Sentence
S String
"cannot be above the maximum", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght Sentence -> Sentence -> Sentence
+:+.
  forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, String -> Sentence
S String
"All", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
xi, forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
`S.of_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"must be",
  String -> Sentence
S String
"between" Sentence -> Sentence -> Sentence
+:+. (forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMinEtrSlip Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMaxExtSlip), String -> Sentence
S String
"All", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
yi,
  forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
`S.of_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"must not be below" Sentence -> Sentence -> Sentence
+:+. forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
yMinSlip,
  String -> Sentence
S String
"For any given vertex in", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"the", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
yi, forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value,
  String -> Sentence
S String
"must not exceed the", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght, forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, String -> Sentence
S String
"corresponding to the",
  String -> Sentence
S String
"same", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
xi Sentence -> Sentence -> Sentence
+:+. forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the IdeaDict
first) Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"last",
  String -> Sentence
S String
"vertices in", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"must each be equal to one of the vertices",
  String -> Sentence
S String
"formed by" Sentence -> Sentence -> Sentence
+:+. (forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght), String -> Sentence
S String
"The slope between",
  String -> Sentence
S String
"consecutive vertices must be always increasing as", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
xi Sentence -> Sentence -> Sentence
+:+.
  String -> Sentence
S String
"increases", String -> Sentence
S String
"The internal", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
angle, String -> Sentence
S String
"between consecutive",
  String -> Sentence
S String
"vertices in", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"must not be below 110 degrees"]

-----------
-- Intro --
-----------

instModIntro :: [Sentence]
instModIntro :: [Sentence]
instModIntro = [Sentence
instModIntro1, Sentence
instModIntro2]

instModIntro1, instModIntro2 :: Sentence

instModIntro1 :: Sentence
instModIntro1 = [Sentence] -> Sentence
foldlSent [forall n. NounPhrase n => n -> Sentence
atStartNP' (forall t. NamedIdea t => t -> NP
the IdeaDict
goal), SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List
  (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS [ConceptInstance]
goals) Sentence -> Sentence -> Sentence
`S.are` String -> Sentence
S String
"met by the simultaneous" Sentence -> Sentence -> Sentence
+:+. (forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
solution Sentence -> Sentence -> Sentence
`S.of_`
  SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS [InstanceModel
fctSfty, InstanceModel
nrmShrFor, InstanceModel
intsliceFs])), forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the IdeaDict
goal),
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
identifyCritAndFSGS Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S String
"also contributed to by",
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
crtSlpId]

instModIntro2 :: Sentence
instModIntro2 = [Sentence] -> Sentence
foldlSent [forall n. NounPhrase n => n -> Sentence
titleizeNP (forall t. NamedIdea t => t -> NP
the IdeaDict
morPrice),
  forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
method_, String -> Sentence
S String
"is a vertical", forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
slice Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"limit equilibrium",
  forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
ssa Sentence -> Sentence -> Sentence
+:+. forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
method_, forall n. NamedIdea n => n -> Sentence
atStart IdeaDict
analysis, String -> Sentence
S String
"is performed by",
  String -> Sentence
S String
"breaking the assumed", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
slpSrf,
  String -> Sentence
S String
"into a series of vertical", forall n. NamedIdea n => n -> Sentence
plural IdeaDict
slice, String -> Sentence
S String
"of" Sentence -> Sentence -> Sentence
+:+. forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
mass,
  String -> Sentence
S String
"Static equilibrium analysis is performed, using two", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
force,
  forall n. NamedIdea n => n -> Sentence
plural ConceptChunk
equation Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"one moment", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"as in" Sentence -> Sentence -> Sentence
+:+. forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS TheoryModel
equilibrium,
  forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the IdeaDict
problem), String -> Sentence
S String
"is statically indeterminate with only these 3",
  forall n. NamedIdea n => n -> Sentence
plural ConceptChunk
equation, String -> Sentence
S String
"and one constitutive", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation,
  Sentence -> Sentence
sParen forall a b. (a -> b) -> a -> b
$ String -> Sentence
S String
"the Mohr Coulomb shear strength of" Sentence -> Sentence -> Sentence
+:+
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS TheoryModel
mcShrStrgth, String -> Sentence
S String
"so the", forall n. NamedIdea n => n -> Sentence
phrase CI
assumption,
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"corresponding equation",
  forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
+:+. String -> Sentence
S String
"are used",
  forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the ConceptChunk
force), String -> Sentence
S String
"equilibrium", forall n. NamedIdea n => n -> Sentence
plural ConceptChunk
equation, String -> Sentence
S String
"can be modified",
  String -> Sentence
S String
"to be expressed only in terms of known", forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
physical, forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"as done in", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
resShearWOGD Sentence -> Sentence -> Sentence
`S.and_` forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
mobShearWOGD]