-- | Defines concepts used in computing.
module Data.Drasil.Concepts.Computation
  ( module Data.Drasil.Concepts.Computation
  , module Drasil.Metadata.Concepts.Computation
  ) where

import Drasil.Database (mkUid)
import Language.Drasil (cn', commonIdea, Sentence(..),
  ConceptChunk, CI, IdeaDict, idea', cncpt''')
import Language.Drasil.Chunk.Concept.NamedCombinators

import Data.Drasil.Concepts.Documentation (datum, input_, literacy, output_,
  quantity, type_, value, variable)
import Data.Drasil.Concepts.Math (parameter)
import Drasil.Metadata.Concepts.Computation (algorithm)
import Drasil.Metadata.Domains (compScience)

absTolerance, relTolerance:: ConceptChunk
absTolerance :: ConceptChunk
absTolerance = UID -> NP -> Sentence -> ConceptChunk
cncpt''' (String -> UID
mkUid String
"absTolerance") (String -> NP
cn' String
"Absolute tolerance")
  (String -> Sentence
S String
"a fixed number that is used to make direct comparisons")
relTolerance :: ConceptChunk
relTolerance = UID -> NP -> Sentence -> ConceptChunk
cncpt''' (String -> UID
mkUid String
"relTolerance") (String -> NP
cn' String
"Relative tolerance")
  (String -> Sentence
S String
" maximum amount of error that the user is willing to allow in the solution")

-- | Collects all computing-related named chunks (not concept-level yet).
compcon :: [IdeaDict]
compcon :: [IdeaDict]
compcon = [IdeaDict
application, IdeaDict
computer, IdeaDict
structure, IdeaDict
dataStruct, IdeaDict
dataType,
  IdeaDict
inDatum, IdeaDict
outDatum, IdeaDict
inParam, IdeaDict
inVar, IdeaDict
inValue, IdeaDict
inQty, IdeaDict
computerLiteracy, IdeaDict
computerApp]

application, computer, structure :: IdeaDict
os :: CI
------------------------------------------------------------------------------------
--  NC      |     |      id       |       term             |  abbreviation | domain
-------------------------------------------------------------------------------------s
application :: IdeaDict
application = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"application")      (String -> NP
cn' String
"application")
computer :: IdeaDict
computer    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"computer")         (String -> NP
cn' String
"computer")
structure :: IdeaDict
structure   = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"structure")        (String -> NP
cn' String
"structure")
os :: CI
os          = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"os") (String -> NP
cn' String
"operating system")    String
"OS"   [IdeaDict
compScience]

dataStruct, dataType, inDatum, outDatum, inParam, inVar, inValue, inQty,
  computerLiteracy, computerApp :: IdeaDict

dataStruct :: IdeaDict
dataStruct       = IdeaDict -> IdeaDict -> IdeaDict
compoundNCPSPP IdeaDict
datum IdeaDict
structure
dataType :: IdeaDict
dataType         = IdeaDict -> IdeaDict -> IdeaDict
compoundNCPSPP IdeaDict
datum IdeaDict
type_
inDatum :: IdeaDict
inDatum          = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
input_ IdeaDict
datum
outDatum :: IdeaDict
outDatum         = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
output_ IdeaDict
datum
inParam :: IdeaDict
inParam          = IdeaDict -> ConceptChunk -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
input_ ConceptChunk
parameter
inVar :: IdeaDict
inVar            = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
input_ IdeaDict
variable
inValue :: IdeaDict
inValue          = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
input_ IdeaDict
value
inQty :: IdeaDict
inQty            = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
input_ IdeaDict
quantity
computerLiteracy :: IdeaDict
computerLiteracy = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
computer IdeaDict
literacy
computerApp :: IdeaDict
computerApp      = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
computer IdeaDict
application