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 ExpressionSpace2 Kernel %

box: % -> %: from ExpressionSpace2 Kernel %

characteristic: () -> NonNegativeInteger: from NonAssociativeRing

coerce: % -> Expression R: coerce(x) is undocumented.
coerce: % -> OutputForm: from CoercibleTo OutputForm
coerce: Integer -> %: from NonAssociativeRing
coerce: Kernel % -> %: from CoercibleFrom Kernel %
coerce: R -> %: from CoercibleFrom 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

definingPolynomial: % -> %: from ExpressionSpace2 Kernel %

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 ExpressionSpace2 Kernel %
distribute: (%, %) -> %: from ExpressionSpace2 Kernel %

elt: (BasicOperator, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %, %, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %, %, %, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, %, %, %, %, %, %, %, %, %) -> %: from ExpressionSpace2 Kernel %
elt: (BasicOperator, List %) -> %: from ExpressionSpace2 Kernel %

eval: (%, %, %) -> %: from InnerEvalable(%, %)
eval: (%, BasicOperator, % -> %) -> %: from ExpressionSpace2 Kernel %
eval: (%, BasicOperator, List % -> %) -> %: from ExpressionSpace2 Kernel %
eval: (%, Equation %) -> %: from Evalable %
eval: (%, Kernel %, %) -> %: from InnerEvalable(Kernel %, %)
eval: (%, List %, List %) -> %: from InnerEvalable(%, %)
eval: (%, List BasicOperator, List(% -> %)) -> %: from ExpressionSpace2 Kernel %
eval: (%, List BasicOperator, List(List % -> %)) -> %: from ExpressionSpace2 Kernel %
eval: (%, List Equation %) -> %: from Evalable %
eval: (%, List Kernel %, List %) -> %: from InnerEvalable(Kernel %, %)
eval: (%, List Symbol, List(% -> %)) -> %: from ExpressionSpace2 Kernel %
eval: (%, List Symbol, List(List % -> %)) -> %: from ExpressionSpace2 Kernel %
eval: (%, Symbol, % -> %) -> %: from ExpressionSpace2 Kernel %
eval: (%, Symbol, List % -> %) -> %: from ExpressionSpace2 Kernel %

exp: % -> %: exp(x) represents the Fortran intrinsic function EXP

freeOf?: (%, %) -> Boolean: from ExpressionSpace2 Kernel %
freeOf?: (%, Symbol) -> Boolean: from ExpressionSpace2 Kernel %

height: % -> NonNegativeInteger: from ExpressionSpace2 Kernel %

is?: (%, BasicOperator) -> Boolean: from ExpressionSpace2 Kernel %
is?: (%, Symbol) -> Boolean: from ExpressionSpace2 Kernel %

kernel: (BasicOperator, %) -> %: from ExpressionSpace2 Kernel %
kernel: (BasicOperator, List %) -> %: from ExpressionSpace2 Kernel %

kernels: % -> List Kernel %: from ExpressionSpace2 Kernel %
kernels: List % -> List Kernel %: from ExpressionSpace2 Kernel %

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 ExpressionSpace2 Kernel %

map: (% -> %, Kernel %) -> %: from ExpressionSpace2 Kernel %

minPoly: Kernel % -> SparseUnivariatePolynomial %: from ExpressionSpace2 Kernel %

one?: % -> Boolean: from MagmaWithUnit

operator: BasicOperator -> BasicOperator: from ExpressionSpace2 Kernel %

operators: % -> List BasicOperator: from ExpressionSpace2 Kernel %

opposite?: (%, %) -> Boolean: from AbelianMonoid

paren: % -> %: from ExpressionSpace2 Kernel %

pi: () -> %: pi(x) represents the NAG Library function X01AAF which returns an approximation to the value of pi

plenaryPower: (%, PositiveInteger) -> %: from NonAssociativeAlgebra R

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.