FortranExpression(basicSymbols, subscriptedSymbols, R)

fortran.spad line 1426 [edit on github]

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

* : (%, %) -> %
from Magma
* : (%, R) -> %
from RightModule(R)
* : (R, %) -> %
from LeftModule(R)
* : (Integer, %) -> %
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> %
from AbelianGroup
- : (%, %) -> %
from AbelianGroup
0 : () -> %
from AbelianMonoid
1 : () -> %
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
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)
^ : (%, NonNegativeInteger) -> %
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
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 : R -> %
from Algebra(R)
coerce : Integer -> %
from NonAssociativeRing
coerce : Kernel(%) -> %
from CoercibleFrom(Kernel(%))
coerce : % -> Expression(R)

coerce(x) is undocumented

coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> %
from NonAssociativeRng
cos : % -> %

cos(x) represents the Fortran intrinsic function COS

cosh : % -> %

cosh(x) represents the Fortran intrinsic function COSH

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, Mapping(%, %)) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, BasicOperator, Mapping(%, List(%))) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, Equation(%)) -> %
from Evalable(%)
eval : (%, Kernel(%), %) -> %
from InnerEvalable(Kernel(%), %)
eval : (%, List(%), List(%)) -> %
from InnerEvalable(%, %)
eval : (%, List(BasicOperator), List(Mapping(%, %))) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, List(BasicOperator), List(Mapping(%, List(%)))) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, List(Equation(%))) -> %
from Evalable(%)
eval : (%, List(Kernel(%)), List(%)) -> %
from InnerEvalable(Kernel(%), %)
eval : (%, List(Symbol), List(Mapping(%, %))) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, List(Symbol), List(Mapping(%, List(%)))) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, Symbol, Mapping(%, %)) -> %
from ExpressionSpace2(Kernel(%))
eval : (%, Symbol, Mapping(%, 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
log : % -> %

log(x) represents the Fortran intrinsic function LOG

log10 : % -> %

log10(x) represents the Fortran intrinsic function LOG10

mainKernel : % -> Union(Kernel(%), "failed")
from ExpressionSpace2(Kernel(%))
map : (Mapping(%, %), 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 : 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 : 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 : 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.

retract : % -> R
from RetractableTo(R)
retract : % -> Kernel(%)
from RetractableTo(Kernel(%))
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 : 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 : 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.

retractIfCan : % -> Union(R, "failed")
from RetractableTo(R)
retractIfCan : % -> Union(Kernel(%), "failed")
from RetractableTo(Kernel(%))
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 ExpressionSpace2(Kernel(%))
subst : (%, List(Equation(%))) -> %
from ExpressionSpace2(Kernel(%))
subst : (%, List(Kernel(%)), List(%)) -> %
from ExpressionSpace2(Kernel(%))
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 ExpressionSpace2(Kernel(%))
tower : List(%) -> List(Kernel(%))
from ExpressionSpace2(Kernel(%))
variables : % -> List(Symbol)

variables(e) return a list of all the variables in e.

zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

NonAssociativeSemiRing

RetractableTo(R)

LeftModule(R)

BiModule(%, %)

Rng

BiModule(R, R)

SemiRing

unitsKnown

CoercibleFrom(R)

Magma

SemiGroup

RightModule(R)

LeftModule(%)

NonAssociativeRing

ExpressionSpace2(Kernel(%))

PartialDifferentialRing(Symbol)

RetractableTo(Kernel(%))

Module(R)

Algebra(R)

NonAssociativeSemiRng

CancellationAbelianMonoid

Comparable

AbelianMonoid

MagmaWithUnit

RightModule(%)

CoercibleFrom(Kernel(%))

CoercibleTo(OutputForm)

SemiRng

Monoid

BasicType

Ring

InnerEvalable(Kernel(%), %)

ExpressionSpace

AbelianSemiGroup

SetCategory

InnerEvalable(%, %)

NonAssociativeRng

Evalable(%)

AbelianGroup

NonAssociativeAlgebra(R)