FortranExpression(basicSymbols, subscriptedSymbols, R)ΒΆ

fortran.spad line 1426

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

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra R

BasicType

BiModule(%, %)

BiModule(R, R)

CancellationAbelianMonoid

CoercibleTo OutputForm

Comparable

Evalable %

ExpressionSpace

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

LeftModule %

LeftModule R

Magma

MagmaWithUnit

Module R

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

PartialDifferentialRing Symbol

RetractableTo Kernel %

RetractableTo R

RightModule %

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

unitsKnown