# FortranExpression(basicSymbols, subscriptedSymbols, R)ΒΆ

- basicSymbols: List Symbol
- subscriptedSymbols: List Symbol
- R: FortranMachineTypeCategory

A domain of expressions involving functions which can be translated into standard Fortran-77, with some extra extensions from the NAG Fortran Library.

- 0: %
- from AbelianMonoid
- 1: %
- from MagmaWithUnit
- *: (%, %) -> %
- from Magma
- *: (%, R) -> %
- from RightModule R
- *: (Integer, %) -> %
- from AbelianGroup
- *: (NonNegativeInteger, %) -> %
- from AbelianMonoid
- *: (PositiveInteger, %) -> %
- from AbelianSemiGroup
- *: (R, %) -> %
- from LeftModule R
- +: (%, %) -> %
- from AbelianSemiGroup
- -: % -> %
- from AbelianGroup
- -: (%, %) -> %
- from AbelianGroup
- =: (%, %) -> Boolean
- from BasicType
- ^: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- ^: (%, PositiveInteger) -> %
- from Magma
- ~=: (%, %) -> Boolean
- from BasicType

- abs: % -> %
`abs(x)`

represents the Fortran intrinsic function ABS

- acos: % -> %
`acos(x)`

represents the Fortran intrinsic function ACOS- annihilate?: (%, %) -> Boolean
- from Rng
- antiCommutator: (%, %) -> %
- from NonAssociativeSemiRng

- asin: % -> %
`asin(x)`

represents the Fortran intrinsic function ASIN- associator: (%, %, %) -> %
- from NonAssociativeRng

- atan: % -> %
`atan(x)`

represents the Fortran intrinsic function ATAN- belong?: BasicOperator -> Boolean
- from ExpressionSpace
- box: % -> %
- from ExpressionSpace
- box: List % -> %
- from ExpressionSpace
- characteristic: () -> NonNegativeInteger
- from NonAssociativeRing

- coerce: % -> Expression R
`coerce(x)`

is undocumented.- coerce: % -> OutputForm
- from CoercibleTo OutputForm
- coerce: Integer -> %
- from NonAssociativeRing
- coerce: Kernel % -> %
- from RetractableTo Kernel %
- coerce: R -> %
- from Algebra R
- commutator: (%, %) -> %
- from NonAssociativeRng

- cos: % -> %
`cos(x)`

represents the Fortran intrinsic function COS

- cosh: % -> %
`cosh(x)`

represents the Fortran intrinsic function COSH- D: (%, List Symbol) -> %
- from PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> %
- from PartialDifferentialRing Symbol
- D: (%, Symbol) -> %
- from PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> %
- from PartialDifferentialRing Symbol
- differentiate: (%, List Symbol) -> %
- from PartialDifferentialRing Symbol
- differentiate: (%, List Symbol, List NonNegativeInteger) -> %
- from PartialDifferentialRing Symbol
- differentiate: (%, Symbol) -> %
- from PartialDifferentialRing Symbol
- differentiate: (%, Symbol, NonNegativeInteger) -> %
- from PartialDifferentialRing Symbol
- distribute: % -> %
- from ExpressionSpace
- distribute: (%, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %, %, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %, %, %, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, %, %, %, %, %, %, %, %, %) -> %
- from ExpressionSpace
- elt: (BasicOperator, List %) -> %
- from ExpressionSpace
- eval: (%, %, %) -> %
- from InnerEvalable(%, %)
- eval: (%, BasicOperator, % -> %) -> %
- from ExpressionSpace
- eval: (%, BasicOperator, List % -> %) -> %
- from ExpressionSpace
- eval: (%, Equation %) -> %
- from Evalable %
- eval: (%, Kernel %, %) -> %
- from InnerEvalable(Kernel %, %)
- eval: (%, List %, List %) -> %
- from InnerEvalable(%, %)
- eval: (%, List BasicOperator, List % -> %) -> %
- from ExpressionSpace
- eval: (%, List BasicOperator, List List % -> %) -> %
- from ExpressionSpace
- eval: (%, List Equation %) -> %
- from Evalable %
- eval: (%, List Kernel %, List %) -> %
- from InnerEvalable(Kernel %, %)
- eval: (%, List Symbol, List % -> %) -> %
- from ExpressionSpace
- eval: (%, List Symbol, List List % -> %) -> %
- from ExpressionSpace
- eval: (%, Symbol, % -> %) -> %
- from ExpressionSpace
- eval: (%, Symbol, List % -> %) -> %
- from ExpressionSpace

- exp: % -> %
`exp(x)`

represents the Fortran intrinsic function EXP- freeOf?: (%, %) -> Boolean
- from ExpressionSpace
- freeOf?: (%, Symbol) -> Boolean
- from ExpressionSpace
- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory
- height: % -> NonNegativeInteger
- from ExpressionSpace
- is?: (%, BasicOperator) -> Boolean
- from ExpressionSpace
- is?: (%, Symbol) -> Boolean
- from ExpressionSpace
- kernel: (BasicOperator, %) -> %
- from ExpressionSpace
- kernel: (BasicOperator, List %) -> %
- from ExpressionSpace
- kernels: % -> List Kernel %
- from ExpressionSpace
- kernels: List % -> List Kernel %
- from ExpressionSpace
- latex: % -> String
- from SetCategory
- leftPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- leftPower: (%, PositiveInteger) -> %
- from Magma
- leftRecip: % -> Union(%, failed)
- from MagmaWithUnit

- log10: % -> %
`log10(x)`

represents the Fortran intrinsic function`LOG10`

- log: % -> %
`log(x)`

represents the Fortran intrinsic function LOG- mainKernel: % -> Union(Kernel %, failed)
- from ExpressionSpace
- map: (% -> %, Kernel %) -> %
- from ExpressionSpace
- one?: % -> Boolean
- from MagmaWithUnit
- operator: BasicOperator -> BasicOperator
- from ExpressionSpace
- operators: % -> List BasicOperator
- from ExpressionSpace
- opposite?: (%, %) -> Boolean
- from AbelianMonoid
- paren: % -> %
- from ExpressionSpace
- paren: List % -> %
- from ExpressionSpace

- pi: () -> %
`pi(x)`

represents the NAG Library function X01AAF which returns an approximation to the value of`pi`

- recip: % -> Union(%, failed)
- from MagmaWithUnit
- retract: % -> Kernel %
- from RetractableTo Kernel %
- retract: % -> R
- from RetractableTo R

- retract: Expression Float -> % if R has RetractableTo Float
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Expression Integer -> %
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Expression R -> %
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Fraction Polynomial Float -> % if R has RetractableTo Float
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Fraction Polynomial Integer -> %
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Polynomial Float -> % if R has RetractableTo Float
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Polynomial Integer -> %
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retract: Symbol -> %
`retract(e)`

takes`e`

and transforms it into a FortranExpression checking that it is one of the given basic symbols or subscripted symbols which correspond to scalar and array parameters respectively.- retractIfCan: % -> Union(Kernel %, failed)
- from RetractableTo Kernel %
- retractIfCan: % -> Union(R, failed)
- from RetractableTo R

- retractIfCan: Expression Float -> Union(%, failed) if R has RetractableTo Float
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Expression Integer -> Union(%, failed)
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Expression R -> Union(%, failed)
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Fraction Polynomial Float -> Union(%, failed) if R has RetractableTo Float
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Fraction Polynomial Integer -> Union(%, failed)
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Polynomial Float -> Union(%, failed) if R has RetractableTo Float
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Polynomial Integer -> Union(%, failed)
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it contains no non-Fortran functions, and that it only contains the given basic symbols and subscripted symbols which correspond to scalar and array parameters respectively.

- retractIfCan: Symbol -> Union(%, failed)
`retractIfCan(e)`

takes`e`

and tries to transform it into a FortranExpression checking that it is one of the given basic symbols or subscripted symbols which correspond to scalar and array parameters respectively.- rightPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- rightPower: (%, PositiveInteger) -> %
- from Magma
- rightRecip: % -> Union(%, failed)
- from MagmaWithUnit
- sample: %
- from AbelianMonoid

- sin: % -> %
`sin(x)`

represents the Fortran intrinsic function SIN

- sinh: % -> %
`sinh(x)`

represents the Fortran intrinsic function SINH- smaller?: (%, %) -> Boolean
- from Comparable

- sqrt: % -> %
`sqrt(x)`

represents the Fortran intrinsic function SQRT- subst: (%, Equation %) -> %
- from ExpressionSpace
- subst: (%, List Equation %) -> %
- from ExpressionSpace
- subst: (%, List Kernel %, List %) -> %
- from ExpressionSpace
- subtractIfCan: (%, %) -> Union(%, failed)
- from CancellationAbelianMonoid

- tan: % -> %
`tan(x)`

represents the Fortran intrinsic function TAN

- tanh: % -> %
`tanh(x)`

represents the Fortran intrinsic function TANH- tower: % -> List Kernel %
- from ExpressionSpace
- tower: List % -> List Kernel %
- from ExpressionSpace

- useNagFunctions: () -> Boolean
`useNagFunctions()`

indicates whether NAG functions are being used for mathematical and machine constants.

- useNagFunctions: Boolean -> Boolean
`useNagFunctions(v)`

sets the flag which controls whether NAG functions are being used for mathematical and machine constants. The previous value is returned.

- variables: % -> List Symbol
`variables(e)`

return a list of all the variables in`e`

.- zero?: % -> Boolean
- from AbelianMonoid

Algebra R

BiModule(%, %)

BiModule(R, R)

Evalable %

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

Module R