F

Documentation of 'org.matheclipse.core.expression.F' Java class F

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

java.lang.Object
- org.matheclipse.core.expression.F

```
public class F
extends java.lang.Object
```
Factory for creating MathEclipse expression objects. See AddNewFunctions

Field Summary

Fields
Modifier and Type	Field and Description
`static ISymbol`	`a`
`static ISymbol`	`Abs`
`static ISymbol`	`AddTo`
`static ISymbol`	`And`
`static ISymbol`	`Apart`
`static ISymbol`	`Append`
`static ISymbol`	`AppendTo`
`static ISymbol`	`Apply`
`static ISymbol`	`ArcCos`
`static ISymbol`	`ArcCosh`
`static ISymbol`	`ArcCot`
`static ISymbol`	`ArcCoth`
`static ISymbol`	`ArcCsc`
`static ISymbol`	`ArcCsch`
`static ISymbol`	`ArcSec`
`static ISymbol`	`ArcSech`
`static ISymbol`	`ArcSin`
`static ISymbol`	`ArcSinh`
`static ISymbol`	`ArcTan`
`static ISymbol`	`ArcTanh`
`static ISymbol`	`Arg`
`static ISymbol`	`Array`
`static ISymbol`	`AtomQ`
`static ISymbol`	`Attributes`
`static ISymbol`	`Automatic`
`static ISymbol`	`Axes`
`static ISymbol`	`AxesOrigin`
`static ISymbol`	`AxesStyle`
`static ISymbol`	`b`
`static ISymbol`	`Background`
`static ISymbol`	`Binomial`
`static ISymbol`	`Blank`
`static ISymbol`	`BlankHead`
`static ISymbol`	`Block`
`static ISymbol`	`Boole`
`static ISymbol`	`BooleanMinimize`
`static ISymbol`	`BoxRatios`
`static ISymbol`	`Break`
`static ISymbol`	`c`
`static IInteger`	`C0` * Constant integer "0"
`static IInteger`	`C1` Constant integer "1"
`static IFraction`	`C1D2` Constant fraction "1/2"
`static IFraction`	`C1D3` Constant fraction "1/3"
`static IFraction`	`C1D4` Constant fraction "1/4"
`static IInteger`	`C2` Constant integer "2"
`static IInteger`	`C3` Constant integer "3"
`static IInteger`	`C4` Constant integer "4"
`static IInteger`	`C5` Constant integer "5"
`static ISymbol`	`Cancel`
`static ISymbol`	`CartesianProduct`
`static ISymbol`	`Cases`
`static ISymbol`	`Catalan`
`static ISymbol`	`CatalanNumber`
`static ISymbol`	`Catch`
`static IAST`	`CComplexInfinity` Represents `ComplexInfinity` (i.e.
`static INum`	`CD0` Constant double "0.0"
`static INum`	`CD1` Constant double "1.0"
`static ISymbol`	`Ceiling`
`static ISymbol`	`CharacteristicPolynomial`
`static ISymbol`	`ChessboardDistance`
`static ISymbol`	`Chop`
`static IComplex`	`CI` Complex imaginary unit.
`static IAST`	`CInfinity` Represents `Infinity` (i.e.
`static ISymbol`	`Clear`
`static ISymbol`	`ClearAll`
`static IInteger`	`CN1` Constant integer "-1"
`static IFraction`	`CN1D2` Constant fraction "-1/2"
`static IFraction`	`CN1D3` Constant fraction "-1/3"
`static IFraction`	`CN1D4` Constant fraction "-1/4"
`static IInteger`	`CN2` Constant integer "-2"
`static IInteger`	`CN3` Constant integer "-3"
`static IInteger`	`CN4` Constant integer "-4"
`static IInteger`	`CN5` Constant integer "-5"
`static IComplex`	`CNI` Complex negative imaginary unit.
`static IAST`	`CNInfinity` Represents `-Infinity` (i.e.
`static ISymbol`	`Coefficient`
`static ISymbol`	`CoefficientList`
`static ISymbol`	`Collect`
`static ISymbol`	`Complement`
`static ISymbol`	`Complex`
`static ISymbol`	`ComplexInfinity`
`static ISymbol`	`ComposeList`
`static ISymbol`	`CompoundExpression`
`static ISymbol`	`Condition`
`static ISymbol`	`Conjugate`
`static ISymbol`	`ConjugateTranspose`
`static ISymbol`	`Constant`
`static ISymbol`	`ConstantArray`
`static ISymbol`	`Continue`
`static ISymbol`	`ContinuedFraction`
`static ISymbol`	`CoprimeQ`
`static ISymbol`	`Cos`
`static ISymbol`	`Cosh`
`static ISymbol`	`Cot`
`static ISymbol`	`Coth`
`static ISymbol`	`Count`
`static ISymbol`	`Cross`
`static ISymbol`	`Csc`
`static ISymbol`	`Csch`
`static ISymbol`	`Curl`
`static ISymbol`	`d`
`static ISymbol`	`D`
`static ISymbol`	`Decrement`
`static ISymbol`	`Default`
`static ISymbol`	`Defer`
`static ISymbol`	`Definition`
`static ISymbol`	`Degree`
`static ISymbol`	`Delete`
`static ISymbol`	`DeleteCases`
`static ISymbol`	`Denominator`
`static ISymbol`	`Depth`
`static ISymbol`	`Derivative`
`static ISymbol`	`Det`
`static ISymbol`	`DiagonalMatrix`
`static ISymbol`	`DigitQ`
`static ISymbol`	`Dimensions`
`static ISymbol`	`DirectedInfinity`
`static ISymbol`	`Discriminant`
`static ISymbol`	`Distribute`
`static ISymbol`	`Divergence`
`static ISymbol`	`DivideBy`
`static ISymbol`	`Do`
`static ISymbol`	`Dot`
`static ISymbol`	`Drop`
`static ISymbol`	`e`
`static ISymbol`	`E`
`static ISymbol`	`Eigenvalues`
`static ISymbol`	`Eigenvectors`
`static ISymbol`	`Equal`
`static ISymbol`	`Erf`
`static ISymbol`	`EuclidianDistance`
`static ISymbol`	`EulerGamma`
`static ISymbol`	`EulerPhi`
`static ISymbol`	`EvenQ`
`static ISymbol`	`Exp`
`static ISymbol`	`Expand`
`static ISymbol`	`ExpandAll`
`static ISymbol`	`Exponent`
`static ISymbol`	`ExtendedGCD`
`static ISymbol`	`Extract`
`static ISymbol`	`f`
`static ISymbol`	`Factor`
`static ISymbol`	`Factorial`
`static ISymbol`	`Factorial2`
`static ISymbol`	`FactorInteger`
`static ISymbol`	`FactorSquareFree`
`static ISymbol`	`FactorSquareFreeList`
`static ISymbol`	`FactorTerms`
`static ISymbol`	`False`
`static ISymbol`	`Fibonacci`
`static ISymbol`	`FindRoot`
`static ISymbol`	`First`
`static ISymbol`	`Fit`
`static ISymbol`	`FixedPoint`
`static ISymbol`	`Flat`
`static ISymbol`	`Flatten`
`static ISymbol`	`Floor`
`static ISymbol`	`Fold`
`static ISymbol`	`FoldList`
`static ISymbol`	`For`
`static ISymbol`	`FractionalPart`
`static ISymbol`	`FreeQ`
`static ISymbol`	`FrobeniusSolve`
`static ISymbol`	`FromCharacterCode`
`static ISymbol`	`FromContinuedFraction`
`static ISymbol`	`FullForm`
`static ISymbol`	`FullSimplify`
`static ISymbol`	`Function`
`static ISymbol`	`g`
`static ISymbol`	`Gamma`
`static ISymbol`	`GCD`
`static ISymbol`	`GeometricMean`
`static ISymbol`	`Glaisher`
`static ISymbol`	`GoldenRatio`
`static ISymbol`	`Graphics`
`static ISymbol`	`Graphics3D`
`static ISymbol`	`Greater`
`static ISymbol`	`GreaterEqual`
`static ISymbol`	`GroebnerBasis`
`static ISymbol`	`h`
`static ISymbol`	`HarmonicNumber`
`static ISymbol`	`Head`
`static ISymbol`	`HilbertMatrix`
`static ISymbol`	`Hold`
`static ISymbol`	`HoldAll`
`static ISymbol`	`HoldFirst`
`static ISymbol`	`HoldRest`
`static ISymbol`	`Horner`
`static ISymbol`	`i`
`static ISymbol`	`I`
`static ISymbol`	`IdentityMatrix`
`static ISymbol`	`If`
`static ISymbol`	`Im`
`static ISymbol`	`Increment`
`static ISymbol`	`Indeterminate`
`static ISymbol`	`Infinity`
`static ISymbol`	`Inner`
`static ISymbol`	`Insert`
`static ISymbol`	`IntegerHead`
`static ISymbol`	`IntegerPart`
`static ISymbol`	`IntegerPartitions`
`static ISymbol`	`IntegerQ`
`static ISymbol`	`Integrate`
`static ISymbol`	`Intersection`
`static ISymbol`	`Inverse`
`static ISymbol`	`InverseErf`
`static ISymbol`	`InverseFunction`
`static boolean`	`isSystemInitialized` Set to `true` at the end of initSymbols() method
`static boolean`	`isSystemStarted` Set to `true` at the start of initSymbols() method
`static ISymbol`	`j`
`static ISymbol`	`JacobiMatrix`
`static ISymbol`	`JacobiSymbol`
`static ISymbol`	`JavaForm`
`static ISymbol`	`Join`
`static ISymbol`	`k`
`static ISymbol`	`Khinchin`
`static ISymbol`	`KOrderlessPartitions`
`static ISymbol`	`KPartitions`
`static ISymbol`	`l`
`static ISymbol`	`Last`
`static ISymbol`	`LCM`
`static ISymbol`	`LeafCount`
`static ISymbol`	`Length`
`static ISymbol`	`Less`
`static ISymbol`	`LessEqual`
`static ISymbol`	`LetterQ`
`static ISymbol`	`Level`
`static ISymbol`	`Limit`
`static ISymbol`	`Line`
`static ISymbol`	`LinearProgramming`
`static ISymbol`	`LinearSolve`
`static ISymbol`	`List`
`static ISymbol`	`Listable`
`static ISymbol`	`Log`
`static ISymbol`	`LowerCaseQ`
`static ISymbol`	`LUDecomposition`
`static ISymbol`	`m`
`static ISymbol`	`ManhattanDistance`
`static ISymbol`	`Map`
`static ISymbol`	`MapAll`
`static ISymbol`	`MapThread`
`static ISymbol`	`MatchQ`
`static ISymbol`	`MatrixPower`
`static ISymbol`	`MatrixQ`
`static ISymbol`	`Max`
`static ISymbol`	`Mean`
`static ISymbol`	`Median`
`static ISymbol`	`MemberQ`
`static ISymbol`	`MeshRange`
`static ISymbol`	`MethodHead`
`static ISymbol`	`Min`
`static ISymbol`	`Mod`
`static ISymbol`	`Module`
`static ISymbol`	`MoebiusMu`
`static ISymbol`	`Most`
`static ISymbol`	`Multinomial`
`static ISymbol`	`n`
`static ISymbol`	`N`
`static ISymbol`	`Negative`
`static ISymbol`	`Nest`
`static ISymbol`	`NestList`
`static ISymbol`	`NestWhile`
`static ISymbol`	`NestWhileList`
`static ISymbol`	`NextPrime`
`static ISymbol`	`NFourierTransform`
`static ISymbol`	`NHoldAll`
`static ISymbol`	`NHoldFirst`
`static ISymbol`	`NHoldRest`
`static ISymbol`	`NIntegrate`
`static ISymbol`	`NonCommutativeMultiply`
`static ISymbol`	`NonNegative`
`static ISymbol`	`Norm`
`static ISymbol`	`Not`
`static ISymbol`	`NRoots`
`static ISymbol`	`NSolve`
`static ISymbol`	`Null`
`static ISymbol`	`NumberQ`
`static ISymbol`	`Numerator`
`static ISymbol`	`NumericFunction`
`static ISymbol`	`NumericQ`
`static ISymbol`	`o`
`static ISymbol`	`OddQ`
`static ISymbol`	`OneIdentity`
`static ISymbol`	`Options`
`static ISymbol`	`Or`
`static ISymbol`	`Order`
`static ISymbol`	`OrderedQ`
`static ISymbol`	`Orderless`
`static ISymbol`	`Out`
`static ISymbol`	`Outer`
`static ISymbol`	`p`
`static ISymbol`	`Package`
`static ISymbol`	`PadLeft`
`static ISymbol`	`PadRight`
`static ISymbol`	`Part`
`static ISymbol`	`Partition`
`static ISymbol`	`Pattern`
`static ISymbol`	`PatternHead`
`static ISymbol`	`Permutations`
`static ISymbol`	`Pi`
`static ISymbol`	`Plot`
`static ISymbol`	`Plot3D`
`static ISymbol`	`PlotRange`
`static ISymbol`	`Plus`
`static ISymbol`	`PolynomialExtendedGCD`
`static ISymbol`	`PolynomialGCD`
`static ISymbol`	`PolynomialLCM`
`static ISymbol`	`PolynomialQ`
`static ISymbol`	`PolynomialQuotient`
`static ISymbol`	`PolynomialQuotientRemainder`
`static ISymbol`	`PolynomialRemainder`
`static ISymbol`	`Position`
`static ISymbol`	`Positive`
`static ISymbol`	`PossibleZeroQ`
`static ISymbol`	`Power`
`static ISymbol`	`PowerExpand`
`static ISymbol`	`PowerMod`
`static ISymbol`	`PreDecrement`
`static java.util.Map<java.lang.String,java.lang.String>`	`PREDEFINED_INTERNAL_FORM_STRINGS` The map for predefined strings for the `IExpr.internalFormString(boolean, int)` method.
`static java.util.Map<java.lang.String,IPattern>`	`PREDEFINED_PATTERN_MAP`
`static java.util.Map<java.lang.String,ISymbol>`	`PREDEFINED_SYMBOLS_MAP` The map for predefined symbols
`static ISymbol`	`PreIncrement`
`static ISymbol`	`Prepend`
`static ISymbol`	`PrependTo`
`static ISymbol`	`PrimeQ`
`static ISymbol`	`PrimitiveRoots`
`static ISymbol`	`Print`
`static ISymbol`	`Product`
`static ISymbol`	`q`
`static ISymbol`	`Quiet`
`static ISymbol`	`Quotient`
`static ISymbol`	`r`
`static ISymbol`	`RandomInteger`
`static ISymbol`	`RandomReal`
`static ISymbol`	`Range`
`static ISymbol`	`Rational`
`static ISymbol`	`Rationalize`
`static ISymbol`	`Re`
`static ISymbol`	`RealHead`
`static ISymbol`	`Reap`
`static ISymbol`	`ReplaceAll`
`static ISymbol`	`ReplacePart`
`static ISymbol`	`ReplaceRepeated`
`static ISymbol`	`Rest`
`static ISymbol`	`Resultant`
`static ISymbol`	`Return`
`static ISymbol`	`Reverse`
`static ISymbol`	`Riffle`
`static ISymbol`	`RootIntervals`
`static ISymbol`	`RootOf`
`static ISymbol`	`Roots`
`static ISymbol`	`RotateLeft`
`static ISymbol`	`RotateRight`
`static ISymbol`	`Round`
`static ISymbol`	`Rule`
`static ISymbol`	`RuleDelayed`
`static ISymbol`	`s`
`static ISymbol`	`SameQ`
`static ISymbol`	`Scan`
`static ISymbol`	`Sec`
`static ISymbol`	`Sech`
`static ISymbol`	`Second`
`static ISymbol`	`Select`
`static ISymbol`	`Sequence`
`static ISymbol`	`Set`
`static ISymbol`	`SetAttributes`
`static ISymbol`	`SetDelayed`
`static ISymbol`	`Show`
`static ISymbol`	`Sign`
`static ISymbol`	`SignCmp`
`static ISymbol`	`Simplify`
`static ISymbol`	`Sin`
`static ISymbol`	`SingularValueDecomposition`
`static ISymbol`	`Sinh`
`static ISymbol`	`Slot`
`static IAST`	`Slot1` Represents `#1`
`static IAST`	`Slot2` Represents `#2`
`static ISymbol`	`SlotSequence`
`static ISymbol`	`Solve`
`static ISymbol`	`Sort`
`static ISymbol`	`Sow`
`static ISymbol`	`Sqrt`
`static ISymbol`	`SquaredEuclidianDistance`
`static ISymbol`	`SquareFreeQ`
`static ISymbol`	`StirlingS2`
`static ISymbol`	`StringDrop`
`static ISymbol`	`StringHead`
`static ISymbol`	`StringJoin`
`static ISymbol`	`StringLength`
`static ISymbol`	`StringTake`
`static ISymbol`	`Subsets`
`static ISymbol`	`SubtractFrom`
`static ISymbol`	`Sum`
`static ISymbol`	`SurfaceGraphics`
`static ISymbol`	`Switch`
`static ISymbolObserver`	`SYMBOL_OBSERVER`
`static ISymbol`	`SymbolHead`
`static ISymbol`	`SyntaxLength`
`static ISymbol`	`SyntaxQ`
`static ISymbol`	`t`
`static ISymbol`	`Table`
`static ISymbol`	`Take`
`static ISymbol`	`Tan`
`static ISymbol`	`Tanh`
`static ISymbol`	`Taylor`
`static ISymbol`	`Thread`
`static ISymbol`	`Through`
`static ISymbol`	`Throw`
`static ISymbol`	`TimeConstrained`
`static ISymbol`	`Times`
`static ISymbol`	`TimesBy`
`static ISymbol`	`Timing`
`static ISymbol`	`ToCharacterCode`
`static ISymbol`	`Together`
`static ISymbol`	`ToString`
`static ISymbol`	`Total`
`static ISymbol`	`ToUnicode`
`static ISymbol`	`Tr`
`static ISymbol`	`Trace`
`static ISymbol`	`Transpose`
`static ISymbol`	`TrigExpand`
`static ISymbol`	`TrigReduce`
`static ISymbol`	`TrigToExp`
`static ISymbol`	`True`
`static ISymbol`	`TrueQ`
`static ISymbol`	`u`
`static ISymbol`	`Unequal`
`static ISymbol`	`Unevaluated`
`static ISymbol`	`Union`
`static ISymbol`	`Unique`
`static ISymbol`	`UnitStep`
`static ISymbol`	`UnsameQ`
`static ISymbol`	`UpperCaseQ`
`static ISymbol`	`UpSet`
`static ISymbol`	`UpSetDelayed`
`static ISymbol`	`v`
`static ISymbol`	`ValueQ`
`static ISymbol`	`VandermondeMatrix`
`static ISymbol`	`Variables`
`static ISymbol`	`VectorQ`
`static ISymbol`	`w`
`static ISymbol`	`Which`
`static ISymbol`	`While`
`static ISymbol`	`White`
`static ISymbol`	`x`
`static ISymbol`	`y`
`static ISymbol`	`z`

Constructor Summary

Constructors
Constructor and Description

F()

Constructors
Constructor and Description
`F()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static IAST`	`$(IExpr head, IExpr... a)` Create a new abstract syntax tree (AST).
`static IPattern`	`$p(ISymbol symbol)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol, boolean def)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol, IExpr check)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol, IExpr check, boolean def)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(java.lang.String symbolName)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(java.lang.String symbolName, boolean def)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(java.lang.String symbolName, IExpr check)` Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(java.lang.String symbolName, IExpr check, boolean def)` Create a pattern for pattern-matching and term rewriting
`static IPatternSequence`	`$ps(ISymbol symbol)` Create a pattern for pattern-matching and term rewriting
`static IPatternSequence`	`$ps(ISymbol symbol, IExpr check)` Create a pattern for pattern-matching and term rewriting
`static IPatternSequence`	`$ps(ISymbol symbol, IExpr check, boolean def)` Create a pattern for pattern-matching and term rewriting
`static IPatternSequence`	`$ps(java.lang.String symbolName)` Create a pattern for pattern-matching and term rewriting
`static ISymbol`	`$s(java.lang.String symbolName)` Get a global symbol which is retrieved from the global symbols map or created or retrieved from the thread local variables map.
`static ISymbol`	`$s(java.lang.String symbolName, boolean setEval)`
`static IAST`	`Abs(IExpr a0)`
`static IExpr`	`and(java.math.BigInteger i, IExpr b)`
`static IExpr`	`and(IExpr a, java.math.BigInteger i)`
`static IAST`	`And(IExpr a0, IExpr a1)`
`static IExpr`	`and(IExpr a, java.lang.Integer i)`
`static IExpr`	`and(java.lang.Integer i, IExpr b)`
`static IAST`	`Apart(IExpr a0)`
`static IAST`	`Apart(IExpr a0, IExpr a1)`
`static IAST`	`Append(IExpr a0, IExpr a1)`
`static IAST`	`Apply(IExpr a0, IExpr a1)`
`static IAST`	`ArcCos(IExpr a0)`
`static IAST`	`ArcCosh(IExpr a0)`
`static IAST`	`ArcCot(IExpr a0)`
`static IAST`	`ArcCoth(IExpr a0)`
`static IAST`	`ArcCsc(IExpr a0)`
`static IAST`	`ArcCsch(IExpr a0)`
`static IAST`	`ArcSec(IExpr a0)`
`static IAST`	`ArcSech(IExpr a0)`
`static IAST`	`ArcSin(IExpr a0)`
`static IAST`	`ArcSinh(IExpr a0)`
`static IAST`	`ArcTan(IExpr a0)`
`static IAST`	`ArcTan(IExpr a0, IExpr a1)`
`static IAST`	`ArcTanh(IExpr a0)`
`static IAST`	`Arg(IExpr a0)`
`static IAST`	`ast(IAST f, IExpr head, boolean include, int first, int last)` Creates a new AST from the given `ast` and `head`.
`static IAST`	`ast(IExpr head)` Create a new abstract syntax tree (AST).
`static IAST`	`ast(IExpr[] arr, IExpr head)` Create a new abstract syntax tree (AST).
`static IAST`	`ast(IExpr head, int initialCapacity, boolean initNull)` Create a new abstract syntax tree (AST).
`static IAST`	`AtomQ(IExpr a)`
`static IAST`	`BernoulliB(IExpr a0)`
`static IAST`	`binary(IExpr head, IExpr a0, IExpr a1)` Create a function with 2 arguments without evaluation.
`static IAST`	`Binomial(IExpr a0, IExpr a1)`
`static IAST`	`Block(IExpr a0, IExpr a1)`
`static ISymbol`	`bool(boolean value)` Gives symbols "True" or "False" (type ISymbol) depending on the boolean value.
`static IAST`	`Break()`
`static IAST`	`Cancel(IExpr a)`
`static IExpr`	`cast(java.lang.Object obj)` Converts a given object into a MathEclipse IExpr expression
`static IAST`	`Catch(IExpr a)`
`static IComplex`	`CC(IFraction re)` Create a symbolic complex number
`static IComplex`	`CC(IFraction re, IFraction im)` Create a symbolic complex number
`static IComplex`	`CC(long real_numerator, long real_denominator, long imag_numerator, long imag_denominator)` Create a symbolic complex number
`static IAST`	`Ceiling(IExpr a0)`
`static IAST`	`Chop(IExpr a0)`
`static IAST`	`Clear(IExpr... a)`
`static IAST`	`CNInfinity()`
`static IAST`	`Coefficient(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`CoefficientList(IExpr a0, IExpr a1)`
`static IAST`	`Collect(IExpr a0, IExpr a1)`
`static int`	`compareTo(java.math.BigInteger i, IExpr b)`
`static int`	`compareTo(IExpr a, java.math.BigInteger i)`
`static int`	`compareTo(IExpr a, IExpr b)`
`static int`	`compareTo(IExpr a, java.lang.Integer i)`
`static int`	`compareTo(java.lang.Integer i, IExpr b)`
`static IComplex`	`complex(double realPart, double imagPart)` Create a symbolic complex number
`static IAST`	`Complex(IExpr a0, IExpr a1)` TODO: check if Complex is working in pattern matching?
`static IComplex`	`complex(IFraction re)` Create a symbolic complex number
`static IComplex`	`complex(IFraction re, IFraction im)` Create a symbolic complex number
`static IComplex`	`complex(IInteger re, IInteger im)` Create a symbolic complex number
`static IComplex`	`complex(long real_numerator, long real_denominator, long imag_numerator, long imag_denominator)` Create a symbolic complex number
`static IComplexNum`	`complexNum(double r)` Create a complex numeric number with imaginary part = 0.0
`static IComplexNum`	`complexNum(double r, double i)` Create a complex numeric value
`static IComplexNum`	`complexNum(IComplex obj)`
`static IComplexNum`	`complexNum(IFraction obj)`
`static IComplexNum`	`complexNum(IInteger obj)`
`static IAST`	`CompoundExpression(IExpr... a)`
`static IAST`	`Condition(IExpr a0, IExpr a1)`
`static IAST`	`Conjugate(IExpr a0)`
`static IAST`	`Continue()`
`static IAST`	`CoprimeQ(IExpr a0, IExpr a1)`
`static IAST`	`Cos(IExpr a0)`
`static IAST`	`Cosh(IExpr a0)`
`static IAST`	`Cot(IExpr a0)`
`static IAST`	`Coth(IExpr a0)`
`static IAST`	`Count(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Cross(IExpr a0, IExpr a1)`
`static IAST`	`Csc(IExpr a0)`
`static IAST`	`Csch(IExpr a0)`
`static IAST`	`D()`
`static IAST`	`D(IExpr a0, IExpr a1)`
`static IAST`	`Decrement(IExpr a)`
`static IAST`	`Defer(IExpr a0)`
`static IAST`	`Delete(IExpr a0, IExpr a1)`
`static IAST`	`DeleteCases(IExpr... a)`
`static IAST`	`Denominator(IExpr a0)`
`static IAST`	`Depth(IExpr a0)`
`static IAST`	`Derivative(IExpr a0)`
`static IAST`	`Det(IExpr a0)`
`static IAST`	`Discriminant(IExpr a0, IExpr a1)`
`static IAST`	`Distribute(IExpr a)`
`static IAST`	`Distribute(IExpr a0, IExpr a1)`
`static IAST`	`Distribute(IExpr a0, IExpr a1, IExpr a2)`
`static IExpr`	`div(java.math.BigInteger i, IExpr b)`
`static IExpr`	`div(IExpr a, java.math.BigInteger i)`
`static IExpr`	`div(IExpr a, java.lang.Integer i)`
`static IExpr`	`div(java.lang.Integer i, IExpr b)`
`static IAST`	`Divide(IExpr a0, IExpr a1)`
`static IAST`	`Do(IExpr a0, IExpr a1)`
`static IAST`	`Dot(IExpr... a)`
`static IAST`	`Dot(IExpr a0, IExpr a1)`
`static IAST`	`Drop(IExpr a0, IExpr a1)`
`static IAST`	`Equal(IExpr... a)`
`static IAST`	`Equal(IExpr a0, IExpr a1)`
`static boolean`	`equals(java.math.BigInteger i, IExpr b)`
`static boolean`	`equals(IExpr a, java.math.BigInteger i)`
`static boolean`	`equals(IExpr a, IExpr b)`
`static boolean`	`equals(IExpr a, java.lang.Integer i)`
`static boolean`	`equals(java.lang.Integer i, IExpr b)`
`static IAST`	`Erf(IExpr a)`
`static IExpr`	`eval(IExpr a)` Evaluate an expression.
`static IExpr`	`eval(ISymbol head, IExpr a0)` Create a function with 1 argument and evaluate it.
`static IExpr`	`eval(ISymbol head, IExpr a0, IExpr a1)` Create a function with 2 arguments and evaluate it.
`static IExpr`	`eval(ISymbol head, IExpr a0, IExpr a1, IExpr a2)` Create a function with 3 arguments and evaluate it.
`static IExpr`	`evalBlock(IExpr expr, ISymbol symbol, IExpr localValue)` Evaluate an expression for a local variable.
`static IExpr`	`evalExpand(IExpr a)` Apply `ExpandAll[]` to the given expression and evaluate it.
`static IExpr`	`evalExpandAll(IExpr a)` Apply `ExpandAll[]` to the given expression and evaluate it.
`static IExpr`	`evaln(IExpr a0)` Evaluate the given expression in numeric mode
`static IExpr`	`evalNull(ISymbol head, IExpr a0)` Create a function with 1 argument and evaluate it.
`static IExpr`	`evalNull(ISymbol head, IExpr a0, IExpr a1)` Create a function with 2 arguments and evaluate it.
`static IExpr`	`evalNull(ISymbol head, IExpr a0, IExpr a1, IExpr a2)` Create a function with 3 arguments and evaluate it.
`static boolean`	`evalTrue(IExpr expr)` Evaluate the given expression and test if the result equals the symbol `True`.
`static IAST`	`EvenQ(IExpr a)`
`static IAST`	`Exp(IExpr a0)`
`static IAST`	`Expand(IExpr a0)`
`static IAST`	`Expand(IExpr a0, IExpr a1)`
`static IAST`	`ExpandAll(IExpr a0)`
`static IAST`	`Exponent(IExpr a0, IExpr a1)`
`static IAST`	`Exponent(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Factor(IExpr a0)`
`static IAST`	`Factorial(IExpr a0)`
`static IAST`	`FactorInteger(IExpr a0)`
`static IAST`	`FactorSquareFree(IExpr a)`
`static IAST`	`FactorSquareFreeList(IExpr a)`
`static IAST`	`Fibonacci(IExpr a0)`
`static IAST`	`First(IExpr a0)`
`static IAST`	`Flatten(IExpr a0, IExpr a1)`
`static IAST`	`Floor(IExpr a0)`
`static IFraction`	`fraction(BigFraction value)` Create a "fractional" number
`static IFraction`	`fraction(java.math.BigInteger numerator, java.math.BigInteger denominator)` Create a "fractional" number
`static IFraction`	`fraction(double value)` Create a "fractional" number
`static IFraction`	`fraction(IInteger numerator, IInteger denominator)` Create a "fractional" number
`static IFraction`	`fraction(long numerator, long denominator)` Create a "fractional" number
`static IAST`	`FractionalPart(IExpr a)`
`static IAST`	`FreeQ(IExpr a0, IExpr a1)`
`static IAST`	`FullForm(IExpr a0)`
`static IAST`	`FullSimplify(IExpr a)`
`static IAST`	`Function(IExpr a0)`
`static IAST`	`Gamma(IExpr a0)`
`static IAST`	`Gamma(IExpr a0, IExpr a1)`
`static IAST`	`GCD(IExpr a0, IExpr a1)`
`static Namespace`	`getNamespace()` Get the namespace
`static IAST`	`Graphics()`
`static IAST`	`Greater(IExpr a0, IExpr a1)`
`static IAST`	`GreaterEqual(IExpr a0, IExpr a1)`
`static IAST`	`Head(IExpr a)`
`static IAST`	`Hold(IExpr a0)`
`static IAST`	`If(IExpr a0, IExpr a1)`
`static IAST`	`If(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Im(IExpr a0)`
`static IAST`	`Increment(IExpr a)`
`static ISymbol`	`initFinalSymbol(java.lang.String symbolName)` Convert the symbolName to lowercase (if `Config.PARSER_USE_LOWERCASE_SYMBOLS` is set) and insert a new Symbol in the `PREDEFINED_SYMBOLS_MAP`.
`static void`	`initSymbols()` Initialize the complete System.
`static void`	`initSymbols(java.lang.String fileName, ISymbolObserver symbolObserver, boolean noPackageLoading)` Initialize the complete System
`static IAST`	`Insert(IExpr a0, IExpr a1, IExpr a2)`
`static IInteger`	`integer(java.math.BigInteger integerValue)` Create a large integer number.
`static IInteger`	`integer(long integerValue)` Create a large integer number.
`static IInteger`	`integer(java.lang.String integerString, int numberFormat)` Create a large integer number.
`static IAST`	`IntegerPart(IExpr a0)`
`static IAST`	`IntegerQ(IExpr a)`
`static IAST`	`Integrate(IExpr a0, IExpr a1)`
`static IAST`	`Inverse(IExpr a0)`
`static IAST`	`InverseErf(IExpr a0)`
`static IAST`	`InverseFunction(IExpr a)`
`static boolean`	`isNumEqualInteger(double value, IInteger ii)` After a successful `isCase()` the symbols associated with the patterns contain the matched values on the local stack.
`static boolean`	`isNumIntValue(double value)`
`static boolean`	`isNumIntValue(double value, double epsilon)`
`static boolean`	`isNumIntValue(double value, int i)`
`static boolean`	`isZero(double value)` Test if the absolute value is less `Config.DOUBLE_EPSILON`.
`static boolean`	`isZero(double value, double epsilon)` Test if the absolute value is less than the given epsilon.
`static IAST`	`Join(IExpr a0, IExpr a1)`
`static IAST`	`Last(IExpr a0)`
`static IAST`	`LCM(IExpr a0, IExpr a1)`
`static IAST`	`LeafCount(IExpr a0)`
`static IAST`	`Length(IExpr a)`
`static IAST`	`Less(IExpr a0, IExpr a1)`
`static IAST`	`LessEqual(IExpr a0, IExpr a1)`
`static IAST`	`Limit(IExpr a0, IExpr a1)`
`static IAST`	`Line()`
`static IAST`	`LinearSolve(IExpr a0, IExpr a1)`
`static IAST`	`List()`
`static IAST`	`List(double... numbers)`
`static IAST`	`List(IExpr... a)`
`static IAST`	`List(IExpr a0)`
`static IAST`	`List(IExpr a0, IExpr a1)`
`static IAST`	`List(long... numbers)`
`static ISymbol`	`local(java.lang.String symbolName)` Create a local symbol which is created or retrieved from the eval engines thread local variables map and push a `null` value on the local stack;
`static ISymbol`	`local(java.lang.String symbolName, IExpr value)` Create a local symbol which is created or retrieved from the eval engines thread local variables map and push a value on the local stack;
`static IAST`	`Log(IExpr a0)`
`static IAST`	`Map(IExpr a0)`
`static IAST`	`Map(IExpr a0, IExpr a1)`
`static IAST`	`MapAll(IExpr a0)`
`static IAST`	`MatchQ(IExpr a0, IExpr a1)`
`static IAST`	`MatrixPower(IExpr a0)`
`static IAST`	`Max()`
`static IAST`	`Max(IExpr a0)`
`static IAST`	`Max(IExpr a0, IExpr a1)`
`static IAST`	`MemberQ(IExpr a0, IExpr a1)`
`static ISymbol`	`method(java.lang.String symbolName, java.lang.String className, java.lang.String methodName)`
`static ISymbol`	`method(java.lang.String symbolName, java.lang.String packageName, java.lang.String className, java.lang.String methodName)`
`static IAST`	`Min()`
`static IAST`	`Min(IExpr a0)`
`static IAST`	`Min(IExpr a0, IExpr a1)`
`static IExpr`	`minus(java.math.BigInteger i, IExpr b)`
`static IExpr`	`minus(IExpr a, java.math.BigInteger i)`
`static IExpr`	`minus(IExpr a, java.lang.Integer i)`
`static IExpr`	`minus(java.lang.Integer i, IExpr b)`
`static IExpr`	`mod(java.math.BigInteger i, IExpr b)`
`static IExpr`	`mod(IExpr a, java.math.BigInteger i)`
`static IExpr`	`Mod(IExpr a0, IExpr a1)`
`static IExpr`	`mod(IExpr a, java.lang.Integer i)`
`static IExpr`	`mod(java.lang.Integer i, IExpr b)`
`static IAST`	`Module(IExpr a0, IExpr a1)`
`static IExpr`	`multiply(java.math.BigInteger i, IExpr b)`
`static IExpr`	`multiply(IExpr a, java.math.BigInteger i)`
`static IExpr`	`multiply(IExpr a, java.lang.Integer i)`
`static IExpr`	`multiply(java.lang.Integer i, IExpr b)`
`static IAST`	`N(IExpr a0)` Evaluate the given expression in numeric mode
`static IAST`	`Negate(IExpr a)` Multiplies the given argument by `-1`.
`static IAST`	`Negative(IExpr a0)`
`static IAST`	`newInstance(int intialArgumentsCapacity, IExpr head)` Create a new abstract syntax tree (AST).
`static IAST`	`Not(IExpr a)`
`static INum`	`num(double d)` Create a numeric value
`static INum`	`num(IFraction obj)`
`static INum`	`num(IInteger obj)`
`static INum`	`num(java.lang.String doubleString)` Create a numeric value
`static IAST`	`NumberQ(IExpr a0)`
`static IAST`	`Numerator(IExpr a0)`
`static IAST`	`NumericQ(IExpr a0)`
`static IAST`	`OddQ(IExpr a)`
`static IAST`	`Options(IExpr a0)`
`static IExpr`	`or(java.math.BigInteger i, IExpr b)`
`static IExpr`	`or(IExpr a, java.math.BigInteger i)`
`static IAST`	`Or(IExpr a0, IExpr a1)`
`static IExpr`	`or(IExpr a, java.lang.Integer i)`
`static IExpr`	`or(java.lang.Integer i, IExpr b)`
`static IAST`	`Order(IExpr a0, IExpr a1)`
`static IAST`	`OrderedQ(IExpr a)`
`static IAST`	`Part()`
`static IAST`	`Part(IExpr... a)`
`static IAST`	`Plus()`
`static IExpr`	`plus(java.math.BigInteger i, IExpr b)`
`static IAST`	`Plus(IExpr... a)`
`static IAST`	`Plus(IExpr a0)`
`static IExpr`	`plus(IExpr a, java.math.BigInteger i)`
`static IAST`	`Plus(IExpr a0, IExpr a1)`
`static IExpr`	`plus(IExpr a, java.lang.Integer i)`
`static IExpr`	`plus(java.lang.Integer i, IExpr b)`
`static IAST`	`PolynomialQ(IExpr a0, IExpr a1)`
`static IAST`	`PolynomialQuotient(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialRemainder(IExpr a0, IExpr a1, IExpr a2)`
`static void`	`popLocal(ISymbol temp)` Pop the current top value from the symbols local variable stack.
`static IAST`	`Positive(IExpr a0)`
`static IAST`	`PossibleZeroQ(IExpr a0)`
`static IAST`	`Power()`
`static IAST`	`Power(IExpr a0, IExpr a1)`
`static IAST`	`Power(IExpr a0, long exp)`
`static IAST`	`PowerExpand(IExpr a0)`
`static ISymbol`	`predefinedSymbol(java.lang.String symbolName)` Create a "predefined" symbol for constants or function names.
`static IAST`	`Prepend(IExpr a0, IExpr a1)`
`static IAST`	`PrimeQ(IExpr a0)`
`static IAST`	`Print(IExpr... a)`
`static IAST`	`Product(IExpr a0, IExpr a1)`
`static IFraction`	`QQ(IInteger numerator, IInteger denominator)` Create a "fractional" number
`static IFraction`	`QQ(long numerator, long denominator)` Create a "fractional" number
`static IAST`	`quaternary(IExpr head, IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Quiet(IExpr a0)`
`static IAST`	`quinary(IExpr head, IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`Quotient(IExpr a0, IExpr a1)`
`static IAST`	`Rational(IExpr a0, IExpr a1)`
`static IAST`	`Re(IExpr a0)`
`static IAST`	`Reap(IExpr a)`
`static IAST`	`ReplaceAll(IExpr a0, IExpr a1)`
`static IAST`	`ReplacePart(IExpr a0, IExpr a1)`
`static IAST`	`ReplacePart(IExpr a0, IExpr a1, IExpr a2)` TODO: check if this function is necessary ???
`static IAST`	`Rest(IExpr a0)`
`static IAST`	`Return(IExpr a)`
`static IAST`	`Reverse(IExpr a)`
`static IAST`	`Roots(IExpr a0)`
`static IAST`	`Round(IExpr a0)`
`static IAST`	`Rule(IExpr a0, IExpr a1)`
`static IAST`	`RuleDelayed(IExpr a0, IExpr a1)`
`static IAST`	`SameQ(IExpr a0, IExpr a1)`
`static IAST`	`Scan(IExpr a0, IExpr a1)`
`static IAST`	`Sec(IExpr a0)`
`static IAST`	`Sech(IExpr a0)`
`static IAST`	`Select(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`senary(IExpr head, IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4, IExpr a5)`
`static IAST`	`Sequence()`
`static IAST`	`Sequence(IExpr... a)`
`static IAST`	`Sequence(IExpr a0)`
`static IAST`	`Set(IExpr a0, IExpr a1)`
`static IAST`	`SetAttributes(IExpr a0)`
`static IAST`	`SetAttributes(IExpr a0, IExpr a1)`
`static IAST`	`SetDelayed(IExpr a0, IExpr a1)`
`static IAST`	`Show(IExpr a0)`
`static IAST`	`Sign(IExpr a)`
`static IAST`	`SignCmp(IExpr a0)`
`static IAST`	`Simplify(IExpr a0)`
`static IAST`	`Sin(IExpr a0)`
`static IAST`	`Sinh(IExpr a0)`
`static IAST`	`Slot(IExpr a0)`
`static IAST`	`Slot(int i)`
`static IAST`	`Sort(IExpr a0, IExpr a1)`
`static IAST`	`Sow(IExpr a)`
`static IAST`	`Sqr(IExpr a0)`
`static IAST`	`Sqrt(IExpr a0)`
`static IAST`	`StringJoin(IExpr a)`
`static IStringX`	`stringx(java.lang.String str)` Create a string expression
`static IStringX`	`stringx(java.lang.StringBuffer str)` Create a string expression
`static IExpr`	`subst(IExpr expr, Function<IExpr,IExpr> function)` Substitute all (sub-) expressions with the given unary function.
`static IExpr`	`subst(IExpr expr, IAST astRules)` Substitute all (sub-) expressions with the given rule set.
`static IAST`	`Subtract(IExpr a0, IExpr a1)`
`static IAST`	`Sum(IExpr a0, IExpr a1)`
`static IAST`	`SurfaceGraphics()`
`static IAST`	`Take(IExpr a0, IExpr a1)`
`static IAST`	`Tan(IExpr a0)`
`static IAST`	`Tanh(IExpr a0)`
`static IAST`	`Taylor(IExpr a0, IExpr a1)`
`static IAST`	`ternary(IExpr head, IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Throw(IExpr a)`
`static IAST`	`TimeConstrained(IExpr a0, IExpr a1)`
`static IAST`	`TimeConstrained(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Times()`
`static IAST`	`Times(IExpr... a)`
`static IAST`	`Times(IExpr a0)`
`static IAST`	`Times(IExpr a0, IExpr a1)`
`static IAST`	`Together(IExpr a0)`
`static IAST`	`Tr(IExpr a0)`
`static IAST`	`Trace(IExpr a0)`
`static IAST`	`Transpose(IExpr a0)`
`static IAST`	`TrigExpand(IExpr a0)`
`static IAST`	`TrigReduce(IExpr v)`
`static IAST`	`TrigToExp(IExpr a0)`
`static IAST`	`unary(IExpr head, IExpr a0)` Create a function with 1 argument without evaluation.
`static IAST`	`Unequal(IExpr a0, IExpr a1)`
`static IAST`	`Unevaluated(IExpr a0)`
`static IAST`	`Unique(IExpr a0)`
`static IAST`	`UnsameQ(IExpr a0, IExpr a1)`
`static IAST`	`UpSet(IExpr a0, IExpr a1)`
`static IAST`	`UpSetDelayed(IExpr a0, IExpr a1)`
`static IAST`	`While(IExpr a0, IExpr a1)`
`static IInteger`	`ZZ(java.math.BigInteger integerValue)` Create a large integer number.
`static IInteger`	`ZZ(long integerValue)` Create a large integer number.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

isSystemStarted
```
public static boolean isSystemStarted
```
Set to true at the start of initSymbols() method

isSystemInitialized
```
public static boolean isSystemInitialized
```
Set to true at the end of initSymbols() method

PREDEFINED_INTERNAL_FORM_STRINGS
```
public static final java.util.Map<java.lang.String,java.lang.String> PREDEFINED_INTERNAL_FORM_STRINGS
```
The map for predefined strings for the IExpr.internalFormString(boolean, int) method.

PREDEFINED_PATTERN_MAP

public static final java.util.Map<java.lang.String,IPattern> PREDEFINED_PATTERN_MAP

PREDEFINED_SYMBOLS_MAP

public static final java.util.Map<java.lang.String,ISymbol> PREDEFINED_SYMBOLS_MAP

The map for predefined symbols

SYMBOL_OBSERVER

public static ISymbolObserver SYMBOL_OBSERVER

Catalan
```
public static final ISymbol Catalan
```

ComplexInfinity

public static final ISymbol ComplexInfinity

Degree
```
public static final ISymbol Degree
```

E
```
public static final ISymbol E
```

EulerGamma
```
public static final ISymbol EulerGamma
```

Glaisher
```
public static final ISymbol Glaisher
```

GoldenRatio

public static final ISymbol GoldenRatio

I
```
public static final ISymbol I
```

Infinity
```
public static final ISymbol Infinity
```

Khinchin
```
public static final ISymbol Khinchin
```

Pi
```
public static final ISymbol Pi
```

IntegerHead

public static final ISymbol IntegerHead

SymbolHead
```
public static final ISymbol SymbolHead
```

RealHead
```
public static final ISymbol RealHead
```

PatternHead

public static final ISymbol PatternHead

BlankHead
```
public static final ISymbol BlankHead
```

StringHead
```
public static final ISymbol StringHead
```

MethodHead
```
public static final ISymbol MethodHead
```

False
```
public static final ISymbol False
```

List
```
public static final ISymbol List
```

True
```
public static final ISymbol True
```

Null
```
public static final ISymbol Null
```

Second
```
public static final ISymbol Second
```

Indeterminate

public static final ISymbol Indeterminate

DirectedInfinity

public static final ISymbol DirectedInfinity

Listable
```
public static final ISymbol Listable
```

Constant
```
public static final ISymbol Constant
```

NumericFunction

public static final ISymbol NumericFunction

Orderless
```
public static final ISymbol Orderless
```

OneIdentity

public static final ISymbol OneIdentity

Flat
```
public static final ISymbol Flat
```

HoldFirst
```
public static final ISymbol HoldFirst
```

HoldRest
```
public static final ISymbol HoldRest
```

HoldAll
```
public static final ISymbol HoldAll
```

NHoldFirst
```
public static final ISymbol NHoldFirst
```

NHoldRest
```
public static final ISymbol NHoldRest
```

NHoldAll
```
public static final ISymbol NHoldAll
```

Line
```
public static final ISymbol Line
```

BoxRatios
```
public static final ISymbol BoxRatios
```

MeshRange
```
public static final ISymbol MeshRange
```

PlotRange
```
public static final ISymbol PlotRange
```

AxesStyle
```
public static final ISymbol AxesStyle
```

Automatic
```
public static final ISymbol Automatic
```

AxesOrigin
```
public static final ISymbol AxesOrigin
```

Axes
```
public static final ISymbol Axes
```

Background
```
public static final ISymbol Background
```

White
```
public static final ISymbol White
```

Slot
```
public static final ISymbol Slot
```

SlotSequence

public static final ISymbol SlotSequence

Options
```
public static final ISymbol Options
```

Graphics
```
public static final ISymbol Graphics
```

Graphics3D
```
public static final ISymbol Graphics3D
```

Show
```
public static final ISymbol Show
```

SurfaceGraphics

public static final ISymbol SurfaceGraphics

ArcCosh
```
public static final ISymbol ArcCosh
```

ArcCoth
```
public static final ISymbol ArcCoth
```

ArcCsc
```
public static final ISymbol ArcCsc
```

ArcCsch
```
public static final ISymbol ArcCsch
```

ArcSec
```
public static final ISymbol ArcSec
```

ArcSech
```
public static final ISymbol ArcSech
```

ArcSinh
```
public static final ISymbol ArcSinh
```

ArcTanh
```
public static final ISymbol ArcTanh
```

Plot
```
public static final ISymbol Plot
```

Plot3D
```
public static final ISymbol Plot3D
```

RootOf
```
public static final ISymbol RootOf
```

Sequence
```
public static final ISymbol Sequence
```

Append
```
public static final ISymbol Append
```

AppendTo
```
public static final ISymbol AppendTo
```

Apply
```
public static final ISymbol Apply
```

Attributes
```
public static final ISymbol Attributes
```

Array
```
public static final ISymbol Array
```

AtomQ
```
public static final ISymbol AtomQ
```

Blank
```
public static final ISymbol Blank
```

Block
```
public static final ISymbol Block
```

Break
```
public static final ISymbol Break
```

Cases
```
public static final ISymbol Cases
```

Catch
```
public static final ISymbol Catch
```

Clear
```
public static final ISymbol Clear
```

ClearAll
```
public static final ISymbol ClearAll
```

Condition
```
public static final ISymbol Condition
```

Continue
```
public static final ISymbol Continue
```

Defer
```
public static final ISymbol Defer
```

Definition
```
public static final ISymbol Definition
```

Delete
```
public static final ISymbol Delete
```

DeleteCases

public static final ISymbol DeleteCases

Depth
```
public static final ISymbol Depth
```

Drop
```
public static final ISymbol Drop
```

Do
```
public static final ISymbol Do
```

First
```
public static final ISymbol First
```

FixedPoint
```
public static final ISymbol FixedPoint
```

Flatten
```
public static final ISymbol Flatten
```

Fold
```
public static final ISymbol Fold
```

FoldList
```
public static final ISymbol FoldList
```

For
```
public static final ISymbol For
```

FreeQ
```
public static final ISymbol FreeQ
```

FullForm
```
public static final ISymbol FullForm
```

Head
```
public static final ISymbol Head
```

If
```
public static final ISymbol If
```

Insert
```
public static final ISymbol Insert
```

JavaForm
```
public static final ISymbol JavaForm
```

Last
```
public static final ISymbol Last
```

LeafCount
```
public static final ISymbol LeafCount
```

Length
```
public static final ISymbol Length
```

MemberQ
```
public static final ISymbol MemberQ
```

Module
```
public static final ISymbol Module
```

N
```
public static final ISymbol N
```

Nest
```
public static final ISymbol Nest
```

NestList
```
public static final ISymbol NestList
```

NestWhile
```
public static final ISymbol NestWhile
```

NestWhileList

public static final ISymbol NestWhileList

NumberQ
```
public static final ISymbol NumberQ
```

NumericQ
```
public static final ISymbol NumericQ
```

Position
```
public static final ISymbol Position
```

Prepend
```
public static final ISymbol Prepend
```

PrependTo
```
public static final ISymbol PrependTo
```

Print
```
public static final ISymbol Print
```

Quiet
```
public static final ISymbol Quiet
```

Reap
```
public static final ISymbol Reap
```

Rest
```
public static final ISymbol Rest
```

Return
```
public static final ISymbol Return
```

Riffle
```
public static final ISymbol Riffle
```

RotateLeft
```
public static final ISymbol RotateLeft
```

RotateRight

public static final ISymbol RotateRight

SetAttributes

public static final ISymbol SetAttributes

Sow
```
public static final ISymbol Sow
```

Switch
```
public static final ISymbol Switch
```

TimeConstrained

public static final ISymbol TimeConstrained

Throw
```
public static final ISymbol Throw
```

Unevaluated

public static final ISymbol Unevaluated

Unique
```
public static final ISymbol Unique
```

ValueQ
```
public static final ISymbol ValueQ
```

Which
```
public static final ISymbol Which
```

While
```
public static final ISymbol While
```

Abs
```
public static final ISymbol Abs
```

AddTo
```
public static final ISymbol AddTo
```

And
```
public static final ISymbol And
```

Apart
```
public static final ISymbol Apart
```

ArcCos
```
public static final ISymbol ArcCos
```

ArcCot
```
public static final ISymbol ArcCot
```

ArcSin
```
public static final ISymbol ArcSin
```

ArcTan
```
public static final ISymbol ArcTan
```

Arg
```
public static final ISymbol Arg
```

Binomial
```
public static final ISymbol Binomial
```

Boole
```
public static final ISymbol Boole
```

BooleanMinimize

public static final ISymbol BooleanMinimize

Cancel
```
public static final ISymbol Cancel
```

CartesianProduct

public static final ISymbol CartesianProduct

CatalanNumber

public static final ISymbol CatalanNumber

Ceiling
```
public static final ISymbol Ceiling
```

CharacteristicPolynomial

public static final ISymbol CharacteristicPolynomial

ChessboardDistance

public static final ISymbol ChessboardDistance

Chop
```
public static final ISymbol Chop
```

Coefficient

public static final ISymbol Coefficient

CoefficientList

public static final ISymbol CoefficientList

Collect
```
public static final ISymbol Collect
```

Complement
```
public static final ISymbol Complement
```

Complex
```
public static final ISymbol Complex
```

ComposeList

public static final ISymbol ComposeList

CompoundExpression

public static final ISymbol CompoundExpression

Conjugate
```
public static final ISymbol Conjugate
```

ConjugateTranspose

public static final ISymbol ConjugateTranspose

ConstantArray

public static final ISymbol ConstantArray

ContinuedFraction

public static final ISymbol ContinuedFraction

CoprimeQ
```
public static final ISymbol CoprimeQ
```

Cos
```
public static final ISymbol Cos
```

Cosh
```
public static final ISymbol Cosh
```

Cot
```
public static final ISymbol Cot
```

Coth
```
public static final ISymbol Coth
```

Count
```
public static final ISymbol Count
```

Cross
```
public static final ISymbol Cross
```

Csc
```
public static final ISymbol Csc
```

Csch
```
public static final ISymbol Csch
```

Curl
```
public static final ISymbol Curl
```

D
```
public static final ISymbol D
```

Decrement
```
public static final ISymbol Decrement
```

Default
```
public static final ISymbol Default
```

Denominator

public static final ISymbol Denominator

Derivative
```
public static final ISymbol Derivative
```

Det
```
public static final ISymbol Det
```

DiagonalMatrix

public static final ISymbol DiagonalMatrix

DigitQ
```
public static final ISymbol DigitQ
```

Dimensions
```
public static final ISymbol Dimensions
```

Discriminant

public static final ISymbol Discriminant

Distribute
```
public static final ISymbol Distribute
```

Divergence
```
public static final ISymbol Divergence
```

DivideBy
```
public static final ISymbol DivideBy
```

Dot
```
public static final ISymbol Dot
```

Eigenvalues

public static final ISymbol Eigenvalues

Eigenvectors

public static final ISymbol Eigenvectors

Equal
```
public static final ISymbol Equal
```

Erf
```
public static final ISymbol Erf
```

EuclidianDistance

public static final ISymbol EuclidianDistance

EulerPhi
```
public static final ISymbol EulerPhi
```

EvenQ
```
public static final ISymbol EvenQ
```

Exp
```
public static final ISymbol Exp
```

Expand
```
public static final ISymbol Expand
```

ExpandAll
```
public static final ISymbol ExpandAll
```

Exponent
```
public static final ISymbol Exponent
```

ExtendedGCD

public static final ISymbol ExtendedGCD

Extract
```
public static final ISymbol Extract
```

Factor
```
public static final ISymbol Factor
```

Factorial
```
public static final ISymbol Factorial
```

Factorial2
```
public static final ISymbol Factorial2
```

FactorInteger

public static final ISymbol FactorInteger

FactorSquareFree

public static final ISymbol FactorSquareFree

FactorSquareFreeList

public static final ISymbol FactorSquareFreeList

FactorTerms

public static final ISymbol FactorTerms

Fibonacci
```
public static final ISymbol Fibonacci
```

FindRoot
```
public static final ISymbol FindRoot
```

Fit
```
public static final ISymbol Fit
```

Floor
```
public static final ISymbol Floor
```

FractionalPart

public static final ISymbol FractionalPart

FrobeniusSolve

public static final ISymbol FrobeniusSolve

FromCharacterCode

public static final ISymbol FromCharacterCode

FromContinuedFraction

public static final ISymbol FromContinuedFraction

FullSimplify

public static final ISymbol FullSimplify

Function
```
public static final ISymbol Function
```

Gamma
```
public static final ISymbol Gamma
```

GCD
```
public static final ISymbol GCD
```

GeometricMean

public static final ISymbol GeometricMean

Greater
```
public static final ISymbol Greater
```

GreaterEqual

public static final ISymbol GreaterEqual

GroebnerBasis

public static final ISymbol GroebnerBasis

HarmonicNumber

public static final ISymbol HarmonicNumber

HilbertMatrix

public static final ISymbol HilbertMatrix

Hold
```
public static final ISymbol Hold
```

Horner
```
public static final ISymbol Horner
```

IdentityMatrix

public static final ISymbol IdentityMatrix

Im
```
public static final ISymbol Im
```

Increment
```
public static final ISymbol Increment
```

Inner
```
public static final ISymbol Inner
```

IntegerPart

public static final ISymbol IntegerPart

IntegerPartitions

public static final ISymbol IntegerPartitions

IntegerQ
```
public static final ISymbol IntegerQ
```

Integrate
```
public static final ISymbol Integrate
```

Intersection

public static final ISymbol Intersection

Inverse
```
public static final ISymbol Inverse
```

InverseErf
```
public static final ISymbol InverseErf
```

InverseFunction

public static final ISymbol InverseFunction

JacobiMatrix

public static final ISymbol JacobiMatrix

JacobiSymbol

public static final ISymbol JacobiSymbol

Join
```
public static final ISymbol Join
```

KOrderlessPartitions

public static final ISymbol KOrderlessPartitions

KPartitions

public static final ISymbol KPartitions

LCM
```
public static final ISymbol LCM
```

Less
```
public static final ISymbol Less
```

LessEqual
```
public static final ISymbol LessEqual
```

LetterQ
```
public static final ISymbol LetterQ
```

Level
```
public static final ISymbol Level
```

Limit
```
public static final ISymbol Limit
```

LinearProgramming

public static final ISymbol LinearProgramming

LinearSolve

public static final ISymbol LinearSolve

Log
```
public static final ISymbol Log
```

LowerCaseQ
```
public static final ISymbol LowerCaseQ
```

LUDecomposition

public static final ISymbol LUDecomposition

ManhattanDistance

public static final ISymbol ManhattanDistance

Map
```
public static final ISymbol Map
```

MapAll
```
public static final ISymbol MapAll
```

MapThread
```
public static final ISymbol MapThread
```

MatchQ
```
public static final ISymbol MatchQ
```

MatrixPower

public static final ISymbol MatrixPower

MatrixQ
```
public static final ISymbol MatrixQ
```

Max
```
public static final ISymbol Max
```

Mean
```
public static final ISymbol Mean
```

Median
```
public static final ISymbol Median
```

Min
```
public static final ISymbol Min
```

Mod
```
public static final ISymbol Mod
```

MoebiusMu
```
public static final ISymbol MoebiusMu
```

Most
```
public static final ISymbol Most
```

Multinomial

public static final ISymbol Multinomial

Negative
```
public static final ISymbol Negative
```

NextPrime
```
public static final ISymbol NextPrime
```

NFourierTransform

public static final ISymbol NFourierTransform

NIntegrate
```
public static final ISymbol NIntegrate
```

NonCommutativeMultiply

public static final ISymbol NonCommutativeMultiply

NonNegative

public static final ISymbol NonNegative

Norm
```
public static final ISymbol Norm
```

Not
```
public static final ISymbol Not
```

NRoots
```
public static final ISymbol NRoots
```

NSolve
```
public static final ISymbol NSolve
```

Numerator
```
public static final ISymbol Numerator
```

OddQ
```
public static final ISymbol OddQ
```

Or
```
public static final ISymbol Or
```

Order
```
public static final ISymbol Order
```

OrderedQ
```
public static final ISymbol OrderedQ
```

Out
```
public static final ISymbol Out
```

Outer
```
public static final ISymbol Outer
```

Package
```
public static final ISymbol Package
```

PadLeft
```
public static final ISymbol PadLeft
```

PadRight
```
public static final ISymbol PadRight
```

Part
```
public static final ISymbol Part
```

Partition
```
public static final ISymbol Partition
```

Pattern
```
public static final ISymbol Pattern
```

Permutations

public static final ISymbol Permutations

Plus
```
public static final ISymbol Plus
```

PolynomialExtendedGCD

public static final ISymbol PolynomialExtendedGCD

PolynomialGCD

public static final ISymbol PolynomialGCD

PolynomialLCM

public static final ISymbol PolynomialLCM

PolynomialQ

public static final ISymbol PolynomialQ

PolynomialQuotient

public static final ISymbol PolynomialQuotient

PolynomialQuotientRemainder

public static final ISymbol PolynomialQuotientRemainder

PolynomialRemainder

public static final ISymbol PolynomialRemainder

Positive
```
public static final ISymbol Positive
```

PossibleZeroQ

public static final ISymbol PossibleZeroQ

Power
```
public static final ISymbol Power
```

PowerExpand

public static final ISymbol PowerExpand

PowerMod
```
public static final ISymbol PowerMod
```

PreDecrement

public static final ISymbol PreDecrement

PreIncrement

public static final ISymbol PreIncrement

PrimeQ
```
public static final ISymbol PrimeQ
```

PrimitiveRoots

public static final ISymbol PrimitiveRoots

Product
```
public static final ISymbol Product
```

Quotient
```
public static final ISymbol Quotient
```

RandomInteger

public static final ISymbol RandomInteger

RandomReal
```
public static final ISymbol RandomReal
```

Range
```
public static final ISymbol Range
```

Rational
```
public static final ISymbol Rational
```

Rationalize

public static final ISymbol Rationalize

Re
```
public static final ISymbol Re
```

ReplaceAll
```
public static final ISymbol ReplaceAll
```

ReplacePart

public static final ISymbol ReplacePart

ReplaceRepeated

public static final ISymbol ReplaceRepeated

Resultant
```
public static final ISymbol Resultant
```

Reverse
```
public static final ISymbol Reverse
```

RootIntervals

public static final ISymbol RootIntervals

Roots
```
public static final ISymbol Roots
```

Round
```
public static final ISymbol Round
```

Rule
```
public static final ISymbol Rule
```

RuleDelayed

public static final ISymbol RuleDelayed

SameQ
```
public static final ISymbol SameQ
```

Scan
```
public static final ISymbol Scan
```

Sec
```
public static final ISymbol Sec
```

Sech
```
public static final ISymbol Sech
```

Select
```
public static final ISymbol Select
```

Set
```
public static final ISymbol Set
```

SetDelayed
```
public static final ISymbol SetDelayed
```

Sign
```
public static final ISymbol Sign
```

SignCmp
```
public static final ISymbol SignCmp
```

Simplify
```
public static final ISymbol Simplify
```

Sin
```
public static final ISymbol Sin
```

SingularValueDecomposition

public static final ISymbol SingularValueDecomposition

Sinh
```
public static final ISymbol Sinh
```

Solve
```
public static final ISymbol Solve
```

Sort
```
public static final ISymbol Sort
```

Sqrt
```
public static final ISymbol Sqrt
```

SquaredEuclidianDistance

public static final ISymbol SquaredEuclidianDistance

SquareFreeQ

public static final ISymbol SquareFreeQ

StirlingS2
```
public static final ISymbol StirlingS2
```

StringDrop
```
public static final ISymbol StringDrop
```

StringJoin
```
public static final ISymbol StringJoin
```

StringLength

public static final ISymbol StringLength

StringTake
```
public static final ISymbol StringTake
```

Subsets
```
public static final ISymbol Subsets
```

SubtractFrom

public static final ISymbol SubtractFrom

Sum
```
public static final ISymbol Sum
```

SyntaxLength

public static final ISymbol SyntaxLength

SyntaxQ
```
public static final ISymbol SyntaxQ
```

Table
```
public static final ISymbol Table
```

Take
```
public static final ISymbol Take
```

Tan
```
public static final ISymbol Tan
```

Tanh
```
public static final ISymbol Tanh
```

Taylor
```
public static final ISymbol Taylor
```

Thread
```
public static final ISymbol Thread
```

Through
```
public static final ISymbol Through
```

Times
```
public static final ISymbol Times
```

TimesBy
```
public static final ISymbol TimesBy
```

Timing
```
public static final ISymbol Timing
```

ToCharacterCode

public static final ISymbol ToCharacterCode

Together
```
public static final ISymbol Together
```

ToString
```
public static final ISymbol ToString
```

Total
```
public static final ISymbol Total
```

ToUnicode
```
public static final ISymbol ToUnicode
```

Tr
```
public static final ISymbol Tr
```

Trace
```
public static final ISymbol Trace
```

Transpose
```
public static final ISymbol Transpose
```

TrigExpand
```
public static final ISymbol TrigExpand
```

TrigReduce
```
public static final ISymbol TrigReduce
```

TrigToExp
```
public static final ISymbol TrigToExp
```

TrueQ
```
public static final ISymbol TrueQ
```

Unequal
```
public static final ISymbol Unequal
```

Union
```
public static final ISymbol Union
```

UnitStep
```
public static final ISymbol UnitStep
```

UnsameQ
```
public static final ISymbol UnsameQ
```

UpperCaseQ
```
public static final ISymbol UpperCaseQ
```

UpSet
```
public static final ISymbol UpSet
```

UpSetDelayed

public static final ISymbol UpSetDelayed

VandermondeMatrix

public static final ISymbol VandermondeMatrix

Variables
```
public static final ISymbol Variables
```

VectorQ
```
public static final ISymbol VectorQ
```

a
```
public static final ISymbol a
```

b
```
public static final ISymbol b
```

c
```
public static final ISymbol c
```

d
```
public static final ISymbol d
```

e
```
public static final ISymbol e
```

f
```
public static final ISymbol f
```

g
```
public static final ISymbol g
```

h
```
public static final ISymbol h
```

i
```
public static final ISymbol i
```

j
```
public static final ISymbol j
```

k
```
public static final ISymbol k
```

l
```
public static final ISymbol l
```

m
```
public static final ISymbol m
```

n
```
public static final ISymbol n
```

o
```
public static final ISymbol o
```

p
```
public static final ISymbol p
```

q
```
public static final ISymbol q
```

r
```
public static final ISymbol r
```

s
```
public static final ISymbol s
```

t
```
public static final ISymbol t
```

u
```
public static final ISymbol u
```

v
```
public static final ISymbol v
```

w
```
public static final ISymbol w
```

x
```
public static final ISymbol x
```

y
```
public static final ISymbol y
```

z
```
public static final ISymbol z
```

C0
```
public static final IInteger C0
```
* Constant integer "0"

C1
```
public static final IInteger C1
```
Constant integer "1"

C2
```
public static final IInteger C2
```
Constant integer "2"

C3
```
public static final IInteger C3
```
Constant integer "3"

C4
```
public static final IInteger C4
```
Constant integer "4"

C5
```
public static final IInteger C5
```
Constant integer "5"

CI
```
public static final IComplex CI
```
Complex imaginary unit. The parsed symbol "I" is converted on input to this constant.

CNI
```
public static final IComplex CNI
```
Complex negative imaginary unit.

C1D2
```
public static final IFraction C1D2
```
Constant fraction "1/2"

CN1D2
```
public static final IFraction CN1D2
```
Constant fraction "-1/2"

C1D3
```
public static final IFraction C1D3
```
Constant fraction "1/3"

CN1D3
```
public static final IFraction CN1D3
```
Constant fraction "-1/3"

C1D4
```
public static final IFraction C1D4
```
Constant fraction "1/4"

CN1D4
```
public static final IFraction CN1D4
```
Constant fraction "-1/4"

CD0
```
public static final INum CD0
```
Constant double "0.0"

CD1
```
public static final INum CD1
```
Constant double "1.0"

CInfinity
```
public static IAST CInfinity
```
Represents Infinity (i.e. Infinity->DirectedInfinity[1])

CNInfinity
```
public static IAST CNInfinity
```
Represents -Infinity (i.e. -Infinity->DirectedInfinity[-1])

CComplexInfinity
```
public static IAST CComplexInfinity
```
Represents ComplexInfinity (i.e. ComplexInfinity->DirectedInfinity[)

Slot1
```
public static IAST Slot1
```
Represents #1

Slot2
```
public static IAST Slot2
```
Represents #2

CN1
```
public static final IInteger CN1
```
Constant integer "-1"

CN2
```
public static final IInteger CN2
```
Constant integer "-2"

CN3
```
public static final IInteger CN3
```
Constant integer "-3"

CN4
```
public static final IInteger CN4
```
Constant integer "-4"

CN5
```
public static final IInteger CN5
```
Constant integer "-5"

Constructor Detail
- F
```
public F()
```

Method Detail

$
```
public static final IAST $(IExpr head,
                           IExpr... a)
```
Create a new abstract syntax tree (AST).

Parameters:

head - the header expression of the function. If the ast represents a function like f[x,y], Sin[x],..., the head will be an instance of type ISymbol.

a -

Returns:

$p
```
public static IPattern $p(ISymbol symbol)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

Returns:

IPattern

$p
```
public static IPattern $p(ISymbol symbol,
                          boolean def)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName -

check - additional condition which should be checked in pattern-matching

def - use a default value for this pattern if necessary

Returns:

IPattern

$p
```
public static IPattern $p(ISymbol symbol,
                          IExpr check)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

check - additional condition which should be checked in pattern-matching

Returns:

IPattern

$p
```
public static IPattern $p(ISymbol symbol,
                          IExpr check,
                          boolean def)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

check - additional condition which should be checked in pattern-matching

def - if true, the pattern can match to a default value associated with the AST's head the pattern is used in.

Returns:

IPattern

$p
```
public static IPattern $p(java.lang.String symbolName)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName -

Returns:

IPattern

$p
```
public static IPattern $p(java.lang.String symbolName,
                          boolean def)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName -

check - additional condition which should be checked in pattern-matching

def - use a default value for this pattern if necessary

Returns:

IPattern

$p
```
public static IPattern $p(java.lang.String symbolName,
                          IExpr check)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName -

check - additional condition which should be checked in pattern-matching

Returns:

IPattern

$p
```
public static IPattern $p(java.lang.String symbolName,
                          IExpr check,
                          boolean def)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName -

check - additional condition which should be checked in pattern-matching

def - use a default value for this pattern if necessary

Returns:

IPattern

$ps
```
public static IPatternSequence $ps(ISymbol symbol)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

Returns:

IPattern

$ps
```
public static IPatternSequence $ps(ISymbol symbol,
                                   IExpr check)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

check - additional condition which should be checked in pattern-matching

Returns:

IPattern

$ps
```
public static IPatternSequence $ps(ISymbol symbol,
                                   IExpr check,
                                   boolean def)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

check - additional condition which should be checked in pattern-matching

def - if true, the pattern can match to a default value associated with the AST's head the pattern is used in.

Returns:

IPattern

$ps
```
public static IPatternSequence $ps(java.lang.String symbolName)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName - the name of the pattrn symbol

Returns:

IPattern

$s
```
public static ISymbol $s(java.lang.String symbolName)
```
Get a global symbol which is retrieved from the global symbols map or created or retrieved from the thread local variables map.

Parameters:

symbolName -

Returns:

$s

public static ISymbol $s(java.lang.String symbolName,
                         boolean setEval)

Abs
```
public static IAST Abs(IExpr a0)
```

and

public static IExpr and(IExpr a,
                        java.lang.Integer i)

and

public static IExpr and(IExpr a,
                        java.math.BigInteger i)

and

public static IExpr and(java.lang.Integer i,
                        IExpr b)

and

public static IExpr and(java.math.BigInteger i,
                        IExpr b)

And

public static IAST And(IExpr a0,
                       IExpr a1)

Apart
```
public static IAST Apart(IExpr a0)
```

Apart

public static IAST Apart(IExpr a0,
                         IExpr a1)

Append

public static IAST Append(IExpr a0,
                          IExpr a1)

Apply

public static IAST Apply(IExpr a0,
                         IExpr a1)

ArcCos
```
public static IAST ArcCos(IExpr a0)
```

ArcCosh
```
public static IAST ArcCosh(IExpr a0)
```

ArcCot
```
public static IAST ArcCot(IExpr a0)
```

ArcCoth
```
public static IAST ArcCoth(IExpr a0)
```

ArcCsc
```
public static IAST ArcCsc(IExpr a0)
```

ArcCsch
```
public static IAST ArcCsch(IExpr a0)
```

ArcSec
```
public static IAST ArcSec(IExpr a0)
```

ArcSech
```
public static IAST ArcSech(IExpr a0)
```

ArcSin
```
public static IAST ArcSin(IExpr a0)
```

ArcSinh
```
public static IAST ArcSinh(IExpr a0)
```

ArcTan
```
public static IAST ArcTan(IExpr a0)
```

ArcTan

public static IAST ArcTan(IExpr a0,
                          IExpr a1)

ArcTanh
```
public static IAST ArcTanh(IExpr a0)
```

Arg
```
public static IAST Arg(IExpr a0)
```

ast
```
public static IAST ast(IAST f,
                       IExpr head,
                       boolean include,
                       int first,
                       int last)
```
Creates a new AST from the given ast and head. if include is set to true all arguments from index first to last-1 are copied in the new list if include is set to false all arguments excluded from index first to last-1 are copied in the new list

ast
```
public static final IAST ast(IExpr head)
```
Create a new abstract syntax tree (AST).

Parameters:

head - the header expression of the function. If the ast represents a function like f[x,y], Sin[x],..., the head will be an instance of type ISymbol.

ast
```
public static IAST ast(IExpr head,
                       int initialCapacity,
                       boolean initNull)
```
Create a new abstract syntax tree (AST).

Parameters:

head - the header expression of the function. If the ast represents a function like f[x,y], Sin[x],..., the head will be an instance of type ISymbol.

initialCapacity - the initial capacity (i.e. number of arguments without the header element) of the list.

initNull - initialize all elements with null.

Returns:

ast
```
public static IAST ast(IExpr[] arr,
                       IExpr head)
```
Create a new abstract syntax tree (AST).

Parameters:

arr -

head - the header expression of the function. If the ast represents a function like f[x,y], Sin[x],..., the head will be an instance of type ISymbol.

Returns:

AtomQ
```
public static IAST AtomQ(IExpr a)
```

BernoulliB

public static IAST BernoulliB(IExpr a0)

binary

public static final IAST binary(IExpr head,
                                IExpr a0,
                                IExpr a1)

Create a function with 2 arguments without evaluation.

Parameters:: head -; a0 -; a1 -
Returns:

Binomial

public static IAST Binomial(IExpr a0,
                            IExpr a1)

Block

public static IAST Block(IExpr a0,
                         IExpr a1)

bool
```
public static ISymbol bool(boolean value)
```
Gives symbols "True" or "False" (type ISymbol) depending on the boolean value.

Parameters:

value -

Returns:

Break
```
public static IAST Break()
```

Cancel
```
public static IAST Cancel(IExpr a)
```

cast

public static IExpr cast(java.lang.Object obj)

Converts a given object into a MathEclipse IExpr expression

 Java Object     -> MathEclipse object
 -------------------------------------
 null object          Null symbol
 IExpr                IExpr type
 Boolean              True or False symbol
 BigInteger           Integer value  
 java.math.BigInteger Integer value  
 BigDecimal           Double with doubleValue() value
 Double               Double with doubleValue() value
 Float                Double with doubleValue() value
 Number               Integer with longValue() value
 java.util.List       0-th element of the list gives the head of the function 
                      1..nth element of the list give the arguments of the function
 Object[]             a list of converted objects  
 int[]                a list of Integer values
 double[]             a list of Double values
 double[][]           a matrix (i.e. nested lists) of Double values
 boolean[]            a list of True or False symbols

Parameters:: obj -
Returns:

Catch
```
public static IAST Catch(IExpr a)
```

CC
```
public static IComplex CC(IFraction re)
```
Create a symbolic complex number

Parameters:

re -

Returns:

CC

public static IComplex CC(IFraction re,
                          IFraction im)

Create a symbolic complex number

Parameters:: re -; im -
Returns:

CC

public static IComplex CC(long real_numerator,
                          long real_denominator,
                          long imag_numerator,
                          long imag_denominator)

Create a symbolic complex number

Parameters:: re -; im -
Returns:

Ceiling
```
public static IAST Ceiling(IExpr a0)
```

Clear
```
public static IAST Clear(IExpr... a)
```

CNInfinity
```
public static IAST CNInfinity()
```

Coefficient

public static IAST Coefficient(IExpr a0,
                               IExpr a1,
                               IExpr a2)

CoefficientList

public static IAST CoefficientList(IExpr a0,
                                   IExpr a1)

Collect

public static IAST Collect(IExpr a0,
                           IExpr a1)

compareTo

public static int compareTo(IExpr a,
                            IExpr b)
                     throws java.lang.UnsupportedOperationException

Throws:: java.lang.UnsupportedOperationException

compareTo

public static int compareTo(IExpr a,
                            java.lang.Integer i)
                     throws java.lang.UnsupportedOperationException

Throws:: java.lang.UnsupportedOperationException

compareTo

public static int compareTo(IExpr a,
                            java.math.BigInteger i)
                     throws java.lang.UnsupportedOperationException

Throws:: java.lang.UnsupportedOperationException

compareTo

public static int compareTo(java.lang.Integer i,
                            IExpr b)
                     throws java.lang.UnsupportedOperationException

Throws:: java.lang.UnsupportedOperationException

compareTo

public static int compareTo(java.math.BigInteger i,
                            IExpr b)
                     throws java.lang.UnsupportedOperationException

Throws:: java.lang.UnsupportedOperationException

complex
```
public static IComplex complex(double realPart,
                               double imagPart)
```
Create a symbolic complex number

Parameters:

realPart - the real double value part which should be converted to a complex number

imagPart - the imaginary double value part which should be converted to a complex number

Returns:

IFraction

complex
```
public static IComplex complex(IFraction re)
```
Create a symbolic complex number

Parameters:

re -

Returns:

complex

public static IComplex complex(IFraction re,
                               IFraction im)

Create a symbolic complex number

Parameters:: re -; im -
Returns:

complex

public static IComplex complex(IInteger re,
                               IInteger im)

Create a symbolic complex number

Parameters:: re -; im -
Returns:

complex

public static IComplex complex(long real_numerator,
                               long real_denominator,
                               long imag_numerator,
                               long imag_denominator)

Create a symbolic complex number

Parameters:: re -; im -
Returns:

complexNum
```
public static IComplexNum complexNum(double r)
```
Create a complex numeric number with imaginary part = 0.0

Parameters:

r - the real part of the number

Returns:

complexNum

public static IComplexNum complexNum(double r,
                                     double i)

Create a complex numeric value

Parameters:: r - real part; i - imaginary part
Returns:

complexNum

public static IComplexNum complexNum(IComplex obj)

complexNum

public static IComplexNum complexNum(IFraction obj)

complexNum

public static IComplexNum complexNum(IInteger obj)

Chop
```
public static IAST Chop(IExpr a0)
```

Complex

public static IAST Complex(IExpr a0,
                           IExpr a1)

TODO: check if Complex is working in pattern matching?

Parameters:: a0 -; a1 -
Returns:

CompoundExpression

public static IAST CompoundExpression(IExpr... a)

Condition

public static IAST Condition(IExpr a0,
                             IExpr a1)

Conjugate

public static IAST Conjugate(IExpr a0)

Continue
```
public static IAST Continue()
```

CoprimeQ

public static IAST CoprimeQ(IExpr a0,
                            IExpr a1)

Cos
```
public static IAST Cos(IExpr a0)
```

Cosh
```
public static IAST Cosh(IExpr a0)
```

Cot
```
public static IAST Cot(IExpr a0)
```

Coth
```
public static IAST Coth(IExpr a0)
```

Count

public static IAST Count(IExpr a0,
                         IExpr a1,
                         IExpr a2)

Cross

public static IAST Cross(IExpr a0,
                         IExpr a1)

Csc
```
public static IAST Csc(IExpr a0)
```

Csch
```
public static IAST Csch(IExpr a0)
```

D
```
public static IAST D()
```

D

public static IAST D(IExpr a0,
                     IExpr a1)

Decrement

public static IAST Decrement(IExpr a)

Defer
```
public static IAST Defer(IExpr a0)
```

Delete

public static IAST Delete(IExpr a0,
                          IExpr a1)

DeleteCases

public static IAST DeleteCases(IExpr... a)

Denominator

public static IAST Denominator(IExpr a0)

Depth
```
public static IAST Depth(IExpr a0)
```

Derivative

public static IAST Derivative(IExpr a0)

Det
```
public static IAST Det(IExpr a0)
```

Discriminant

public static IAST Discriminant(IExpr a0,
                                IExpr a1)

Distribute

public static IAST Distribute(IExpr a)

Distribute

public static IAST Distribute(IExpr a0,
                              IExpr a1)

Distribute

public static IAST Distribute(IExpr a0,
                              IExpr a1,
                              IExpr a2)

div

public static IExpr div(IExpr a,
                        java.lang.Integer i)

div

public static IExpr div(IExpr a,
                        java.math.BigInteger i)

div

public static IExpr div(java.lang.Integer i,
                        IExpr b)

div

public static IExpr div(java.math.BigInteger i,
                        IExpr b)

Divide

public static IAST Divide(IExpr a0,
                          IExpr a1)

Do

public static IAST Do(IExpr a0,
                      IExpr a1)

Dot
```
public static IAST Dot(IExpr... a)
```

Dot

public static IAST Dot(IExpr a0,
                       IExpr a1)

Drop

public static IAST Drop(IExpr a0,
                        IExpr a1)

Equal
```
public static IAST Equal(IExpr... a)
```

Equal

public static IAST Equal(IExpr a0,
                         IExpr a1)

equals

public static boolean equals(IExpr a,
                             IExpr b)

equals

public static boolean equals(IExpr a,
                             java.lang.Integer i)

equals

public static boolean equals(IExpr a,
                             java.math.BigInteger i)

equals

public static boolean equals(java.lang.Integer i,
                             IExpr b)

equals

public static boolean equals(java.math.BigInteger i,
                             IExpr b)

Erf
```
public static IAST Erf(IExpr a)
```

eval
```
public static IExpr eval(IExpr a)
```
Evaluate an expression. If no evaluation was possible this method returns the given argument.

Parameters:

a - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.eval(IExpr)

eval

public static IExpr eval(ISymbol head,
                         IExpr a0)

Create a function with 1 argument and evaluate it.

Parameters:: head -; a0 -
Returns:: the evaluated object

eval

public static IExpr eval(ISymbol head,
                         IExpr a0,
                         IExpr a1)

Create a function with 2 arguments and evaluate it.

Parameters:: head -; a0 -; a1 -
Returns:: the evaluated object

eval

public static IExpr eval(ISymbol head,
                         IExpr a0,
                         IExpr a1,
                         IExpr a2)

Create a function with 3 arguments and evaluate it.

Parameters:: head -; a0 -; a1 -; a2 -
Returns:: the evaluated object

evalBlock
```
public static IExpr evalBlock(IExpr expr,
                              ISymbol symbol,
                              IExpr localValue)
```
Evaluate an expression for a local variable.

Parameters:

expr - the expression which should be evaluated for the given symbol

symbol - the symbol which should be evaluated as a local variable

localValue - the value

evalExpand
```
public static IExpr evalExpand(IExpr a)
```
Apply ExpandAll[] to the given expression and evaluate it. If no evaluation was possible this method returns the given argument.

Parameters:

a - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.eval(IExpr)

evalExpandAll
```
public static IExpr evalExpandAll(IExpr a)
```
Apply ExpandAll[] to the given expression and evaluate it. If no evaluation was possible this method returns the given argument.

Parameters:

a - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.eval(IExpr)

evaln
```
public static IExpr evaln(IExpr a0)
```
Evaluate the given expression in numeric mode

Parameters:

a0 -

Returns:

evalNull
```
public static IExpr evalNull(ISymbol head,
                             IExpr a0)
```
Create a function with 1 argument and evaluate it.

Parameters:

head -

a0 -

Returns:

the evaluated object or null if no evaluation was possible.

evalNull

public static IExpr evalNull(ISymbol head,
                             IExpr a0,
                             IExpr a1)

Create a function with 2 arguments and evaluate it.

Parameters:: head -; a0 -; a1 -
Returns:: the evaluated object or null if no evaluation was possible.

evalNull

public static IExpr evalNull(ISymbol head,
                             IExpr a0,
                             IExpr a1,
                             IExpr a2)

Create a function with 3 arguments and evaluate it.

Parameters:: head -; a0 -; a1 -; a2 -
Returns:: the evaluated object or null if no evaluation was possible.

evalTrue
```
public static boolean evalTrue(IExpr expr)
```
Evaluate the given expression and test if the result equals the symbol True.

Parameters:

expr -

Returns:

EvenQ
```
public static IAST EvenQ(IExpr a)
```

Exp
```
public static IAST Exp(IExpr a0)
```

Expand
```
public static IAST Expand(IExpr a0)
```

Expand

public static IAST Expand(IExpr a0,
                          IExpr a1)

ExpandAll

public static IAST ExpandAll(IExpr a0)

Exponent

public static IAST Exponent(IExpr a0,
                            IExpr a1)

Exponent

public static IAST Exponent(IExpr a0,
                            IExpr a1,
                            IExpr a2)

Factor
```
public static IAST Factor(IExpr a0)
```

Factorial

public static IAST Factorial(IExpr a0)

FactorInteger

public static IAST FactorInteger(IExpr a0)

FactorSquareFree

public static IAST FactorSquareFree(IExpr a)

FactorSquareFreeList

public static IAST FactorSquareFreeList(IExpr a)

Fibonacci

public static IAST Fibonacci(IExpr a0)

First
```
public static IAST First(IExpr a0)
```

Flatten

public static IAST Flatten(IExpr a0,
                           IExpr a1)

Floor
```
public static IAST Floor(IExpr a0)
```

fraction
```
public static IFraction fraction(BigFraction value)
```
Create a "fractional" number

Parameters:

value - the rational value which should be converted to a fractional number

Returns:

IFraction

fraction
```
public static IFraction fraction(java.math.BigInteger numerator,
                                 java.math.BigInteger denominator)
```
Create a "fractional" number

Parameters:

numerator - numerator of the fractional number

denominator - denumerator of the fractional number

Returns:

IFraction

fraction
```
public static IFraction fraction(double value)
```
Create a "fractional" number

Parameters:

value - the double value which should be converted to a fractional number

Returns:

IFraction

fraction
```
public static IFraction fraction(IInteger numerator,
                                 IInteger denominator)
```
Create a "fractional" number

Parameters:

numerator - numerator of the fractional number

denominator - denumerator of the fractional number

Returns:

IFraction

fraction
```
public static IFraction fraction(long numerator,
                                 long denominator)
```
Create a "fractional" number

Parameters:

numerator - numerator of the fractional number

denominator - denumerator of the fractional number

Returns:

IFraction

FractionalPart

public static IAST FractionalPart(IExpr a)

FreeQ

public static IAST FreeQ(IExpr a0,
                         IExpr a1)

FullForm

public static IAST FullForm(IExpr a0)

FullSimplify

public static IAST FullSimplify(IExpr a)

Function

public static IAST Function(IExpr a0)

Gamma
```
public static IAST Gamma(IExpr a0)
```

Gamma

public static IAST Gamma(IExpr a0,
                         IExpr a1)

GCD

public static IAST GCD(IExpr a0,
                       IExpr a1)

getNamespace

public static final Namespace getNamespace()

Get the namespace

Returns:

Graphics
```
public static IAST Graphics()
```

Greater

public static IAST Greater(IExpr a0,
                           IExpr a1)

GreaterEqual

public static IAST GreaterEqual(IExpr a0,
                                IExpr a1)

Head
```
public static IAST Head(IExpr a)
```

Hold
```
public static IAST Hold(IExpr a0)
```

If

public static IAST If(IExpr a0,
                      IExpr a1)

If

public static IAST If(IExpr a0,
                      IExpr a1,
                      IExpr a2)

Im
```
public static IAST Im(IExpr a0)
```

Increment

public static IAST Increment(IExpr a)

initFinalSymbol
```
public static ISymbol initFinalSymbol(java.lang.String symbolName)
```
Convert the symbolName to lowercase (if Config.PARSER_USE_LOWERCASE_SYMBOLS is set) and insert a new Symbol in the PREDEFINED_SYMBOLS_MAP. The symbol is created using the given upper case string to use it as associated class name in package org.matheclipse.core.reflection.system.

Parameters:

symbolName - the predefined symbol name in upper-case form

Returns:

initSymbols
```
public static void initSymbols()
```
Initialize the complete System. Calls initSymbols(String, ISymbolObserver, boolean) with parameters null, null.

initSymbols
```
public static void initSymbols(java.lang.String fileName,
                               ISymbolObserver symbolObserver,
                               boolean noPackageLoading)
```
Initialize the complete System

Parameters:

fileName - null or optional text filename, which includes the preloaded system rules

symbolObserver - the observer for newly created ISymbols

noPackageLoading - don't load any package at start up

integer

public static IInteger integer(java.math.BigInteger integerValue)

Create a large integer number.

Parameters:: integerValue -
Returns:

integer
```
public static IInteger integer(long integerValue)
```
Create a large integer number.

Parameters:

integerValue -

Returns:

integer
```
public static IInteger integer(java.lang.String integerString,
                               int numberFormat)
```
Create a large integer number.

Parameters:

integerString - the integer number represented as a String

numberFormat - the format of the number (usually 10)

Returns:

Object

Insert

public static IAST Insert(IExpr a0,
                          IExpr a1,
                          IExpr a2)

IntegerPart

public static IAST IntegerPart(IExpr a0)

IntegerQ
```
public static IAST IntegerQ(IExpr a)
```

Integrate

public static IAST Integrate(IExpr a0,
                             IExpr a1)

Inverse
```
public static IAST Inverse(IExpr a0)
```

InverseErf

public static IAST InverseErf(IExpr a0)

InverseFunction

public static IAST InverseFunction(IExpr a)

isNumEqualInteger

public static boolean isNumEqualInteger(double value,
                                        IInteger ii)
                                 throws java.lang.ArithmeticException

After a successful isCase() the symbols associated with the patterns contain the matched values on the local stack.

Parameters:: a -; b -
Returns:
Throws:: java.lang.ArithmeticException

isNumIntValue

public static boolean isNumIntValue(double value,
                                    int i)

isNumIntValue

public static boolean isNumIntValue(double value)

isNumIntValue

public static boolean isNumIntValue(double value,
                                    double epsilon)

isZero
```
public static boolean isZero(double value)
```
Test if the absolute value is less Config.DOUBLE_EPSILON.

Parameters:

value -

Returns:

isZero

public static boolean isZero(double value,
                             double epsilon)

Test if the absolute value is less than the given epsilon.

Parameters:: value -
Returns:

Join

public static IAST Join(IExpr a0,
                        IExpr a1)

Last
```
public static IAST Last(IExpr a0)
```

LCM

public static IAST LCM(IExpr a0,
                       IExpr a1)

LeafCount

public static IAST LeafCount(IExpr a0)

Length
```
public static IAST Length(IExpr a)
```

Less

public static IAST Less(IExpr a0,
                        IExpr a1)

LessEqual

public static IAST LessEqual(IExpr a0,
                             IExpr a1)

Limit

public static IAST Limit(IExpr a0,
                         IExpr a1)

Line
```
public static IAST Line()
```

LinearSolve

public static IAST LinearSolve(IExpr a0,
                               IExpr a1)

List
```
public static IAST List()
```

List

public static IAST List(double... numbers)

List
```
public static IAST List(IExpr a0)
```

List
```
public static IAST List(IExpr... a)
```

List

public static IAST List(IExpr a0,
                        IExpr a1)

List

public static IAST List(long... numbers)

local
```
public static ISymbol local(java.lang.String symbolName)
```
Create a local symbol which is created or retrieved from the eval engines thread local variables map and push a null value on the local stack;

Parameters:

symbolName - the name of the symbol

Returns:

local
```
public static ISymbol local(java.lang.String symbolName,
                            IExpr value)
```
Create a local symbol which is created or retrieved from the eval engines thread local variables map and push a value on the local stack;

Parameters:

symbolName - the name of the symbol

Returns:

Log
```
public static IAST Log(IExpr a0)
```

Map
```
public static IAST Map(IExpr a0)
```

Map

public static IAST Map(IExpr a0,
                       IExpr a1)

MapAll
```
public static IAST MapAll(IExpr a0)
```

MatchQ

public static IAST MatchQ(IExpr a0,
                          IExpr a1)

MatrixPower

public static IAST MatrixPower(IExpr a0)

Max
```
public static IAST Max()
```

Max
```
public static IAST Max(IExpr a0)
```

Max

public static IAST Max(IExpr a0,
                       IExpr a1)

MemberQ

public static IAST MemberQ(IExpr a0,
                           IExpr a1)

method

public static ISymbol method(java.lang.String symbolName,
                             java.lang.String className,
                             java.lang.String methodName)

method

public static ISymbol method(java.lang.String symbolName,
                             java.lang.String packageName,
                             java.lang.String className,
                             java.lang.String methodName)

Min
```
public static IAST Min()
```

Min
```
public static IAST Min(IExpr a0)
```

Min

public static IAST Min(IExpr a0,
                       IExpr a1)

minus

public static IExpr minus(IExpr a,
                          java.lang.Integer i)

minus

public static IExpr minus(IExpr a,
                          java.math.BigInteger i)

minus

public static IExpr minus(java.lang.Integer i,
                          IExpr b)

minus

public static IExpr minus(java.math.BigInteger i,
                          IExpr b)

mod

public static IExpr mod(IExpr a,
                        java.lang.Integer i)

mod

public static IExpr mod(IExpr a,
                        java.math.BigInteger i)

mod

public static IExpr mod(java.lang.Integer i,
                        IExpr b)

mod

public static IExpr mod(java.math.BigInteger i,
                        IExpr b)

Mod

public static IExpr Mod(IExpr a0,
                        IExpr a1)

Module

public static IAST Module(IExpr a0,
                          IExpr a1)

multiply

public static IExpr multiply(IExpr a,
                             java.lang.Integer i)

multiply

public static IExpr multiply(IExpr a,
                             java.math.BigInteger i)

multiply

public static IExpr multiply(java.lang.Integer i,
                             IExpr b)

multiply

public static IExpr multiply(java.math.BigInteger i,
                             IExpr b)

N
```
public static IAST N(IExpr a0)
```
Evaluate the given expression in numeric mode

Parameters:

a0 -

Returns:

Negate
```
public static IAST Negate(IExpr a)
```
Multiplies the given argument by -1.

Parameters:

a -

Returns:

Negative

public static IAST Negative(IExpr a0)

newInstance
```
public static IAST newInstance(int intialArgumentsCapacity,
                               IExpr head)
```
Create a new abstract syntax tree (AST).

Parameters:

intialArgumentsCapacity - the initial capacity of arguments of the AST.

head - the header expression of the function. If the ast represents a function like f[x,y], Sin[x],..., the head will be an instance of type ISymbol.

Returns:

Not
```
public static IAST Not(IExpr a)
```

num
```
public static INum num(double d)
```
Create a numeric value

Parameters:

d -

Returns:

num

public static INum num(IFraction obj)

num
```
public static INum num(IInteger obj)
```

num

public static INum num(java.lang.String doubleString)

Create a numeric value

Parameters:: d -
Returns:

NumberQ
```
public static IAST NumberQ(IExpr a0)
```

Numerator

public static IAST Numerator(IExpr a0)

NumericQ

public static IAST NumericQ(IExpr a0)

OddQ
```
public static IAST OddQ(IExpr a)
```

Options
```
public static IAST Options(IExpr a0)
```

or

public static IExpr or(IExpr a,
                       java.lang.Integer i)

or

public static IExpr or(IExpr a,
                       java.math.BigInteger i)

or

public static IExpr or(java.lang.Integer i,
                       IExpr b)

or

public static IExpr or(java.math.BigInteger i,
                       IExpr b)

Or

public static IAST Or(IExpr a0,
                      IExpr a1)

Order

public static IAST Order(IExpr a0,
                         IExpr a1)

OrderedQ
```
public static IAST OrderedQ(IExpr a)
```

Part
```
public static IAST Part()
```

Part
```
public static IAST Part(IExpr... a)
```

plus

public static IExpr plus(IExpr a,
                         java.lang.Integer i)

plus

public static IExpr plus(IExpr a,
                         java.math.BigInteger i)

plus

public static IExpr plus(java.lang.Integer i,
                         IExpr b)

plus

public static IExpr plus(java.math.BigInteger i,
                         IExpr b)

Plus
```
public static IAST Plus()
```

Plus
```
public static IAST Plus(IExpr a0)
```

Plus
```
public static IAST Plus(IExpr... a)
```

Plus

public static IAST Plus(IExpr a0,
                        IExpr a1)

PolynomialQ

public static IAST PolynomialQ(IExpr a0,
                               IExpr a1)

PolynomialQuotient

public static IAST PolynomialQuotient(IExpr a0,
                                      IExpr a1,
                                      IExpr a2)

PolynomialRemainder

public static IAST PolynomialRemainder(IExpr a0,
                                       IExpr a1,
                                       IExpr a2)

popLocal
```
public static void popLocal(ISymbol temp)
```
Pop the current top value from the symbols local variable stack.

Parameters:

temp -

Positive

public static IAST Positive(IExpr a0)

PossibleZeroQ

public static IAST PossibleZeroQ(IExpr a0)

Power
```
public static IAST Power()
```

Power

public static IAST Power(IExpr a0,
                         IExpr a1)

Power

public static IAST Power(IExpr a0,
                         long exp)

PowerExpand

public static IAST PowerExpand(IExpr a0)

predefinedSymbol
```
public static ISymbol predefinedSymbol(java.lang.String symbolName)
```
Create a "predefined" symbol for constants or function names.

Parameters:

symbolName -

Returns:

Prepend

public static IAST Prepend(IExpr a0,
                           IExpr a1)

PrimeQ
```
public static IAST PrimeQ(IExpr a0)
```

Print
```
public static IAST Print(IExpr... a)
```

Product

public static IAST Product(IExpr a0,
                           IExpr a1)

QQ
```
public static IFraction QQ(IInteger numerator,
                           IInteger denominator)
```
Create a "fractional" number

Parameters:

numerator - numerator of the fractional number

denominator - denumerator of the fractional number

Returns:

IFraction

QQ
```
public static IFraction QQ(long numerator,
                           long denominator)
```
Create a "fractional" number

Parameters:

numerator - numerator of the fractional number

denominator - denumerator of the fractional number

Returns:

IFraction

quaternary

public static final IAST quaternary(IExpr head,
                                    IExpr a0,
                                    IExpr a1,
                                    IExpr a2,
                                    IExpr a3)

quinary

public static final IAST quinary(IExpr head,
                                 IExpr a0,
                                 IExpr a1,
                                 IExpr a2,
                                 IExpr a3,
                                 IExpr a4)

Quiet
```
public static IAST Quiet(IExpr a0)
```

Quotient

public static IAST Quotient(IExpr a0,
                            IExpr a1)

Rational

public static IAST Rational(IExpr a0,
                            IExpr a1)

Re
```
public static IAST Re(IExpr a0)
```

Reap
```
public static IAST Reap(IExpr a)
```

ReplaceAll

public static IAST ReplaceAll(IExpr a0,
                              IExpr a1)

ReplacePart

public static IAST ReplacePart(IExpr a0,
                               IExpr a1)

ReplacePart

public static IAST ReplacePart(IExpr a0,
                               IExpr a1,
                               IExpr a2)

TODO: check if this function is necessary ???

Parameters:: a0 -; a1 -; a2 -
Returns:

Rest
```
public static IAST Rest(IExpr a0)
```

Return
```
public static IAST Return(IExpr a)
```

Reverse
```
public static IAST Reverse(IExpr a)
```

Roots
```
public static IAST Roots(IExpr a0)
```

Round
```
public static IAST Round(IExpr a0)
```

Rule

public static IAST Rule(IExpr a0,
                        IExpr a1)

RuleDelayed

public static IAST RuleDelayed(IExpr a0,
                               IExpr a1)

SameQ

public static IAST SameQ(IExpr a0,
                         IExpr a1)

Scan

public static IAST Scan(IExpr a0,
                        IExpr a1)

Sec
```
public static IAST Sec(IExpr a0)
```

Sech
```
public static IAST Sech(IExpr a0)
```

senary

public static final IAST senary(IExpr head,
                                IExpr a0,
                                IExpr a1,
                                IExpr a2,
                                IExpr a3,
                                IExpr a4,
                                IExpr a5)

Select

public static IAST Select(IExpr a0,
                          IExpr a1,
                          IExpr a2)

Sequence
```
public static IAST Sequence()
```

Sequence

public static IAST Sequence(IExpr a0)

Sequence

public static IAST Sequence(IExpr... a)

Set

public static IAST Set(IExpr a0,
                       IExpr a1)

SetAttributes

public static IAST SetAttributes(IExpr a0)

SetAttributes

public static IAST SetAttributes(IExpr a0,
                                 IExpr a1)

SetDelayed

public static IAST SetDelayed(IExpr a0,
                              IExpr a1)

Show
```
public static IAST Show(IExpr a0)
```

Sign
```
public static IAST Sign(IExpr a)
```

SignCmp
```
public static IAST SignCmp(IExpr a0)
```

Simplify

public static IAST Simplify(IExpr a0)

Sin
```
public static IAST Sin(IExpr a0)
```

Sinh
```
public static IAST Sinh(IExpr a0)
```

Slot
```
public static IAST Slot(IExpr a0)
```

Slot
```
public static IAST Slot(int i)
```

Sort

public static IAST Sort(IExpr a0,
                        IExpr a1)

Sow
```
public static IAST Sow(IExpr a)
```

Sqr
```
public static IAST Sqr(IExpr a0)
```

Sqrt
```
public static IAST Sqrt(IExpr a0)
```

StringJoin

public static IAST StringJoin(IExpr a)

stringx

public static final IStringX stringx(java.lang.String str)

Create a string expression

Parameters:: str -
Returns:

stringx

public static final IStringX stringx(java.lang.StringBuffer str)

Create a string expression

Parameters:: str -
Returns:

subst
```
public static IExpr subst(IExpr expr,
                          Function<IExpr,IExpr> function)
```
Substitute all (sub-) expressions with the given unary function. If no substitution matches, the method returns the given expr.

Parameters:

function - if the unary functions apply() method returns null the expression isn't substituted.

Returns:

the input expr if no substitution of a (sub-)expression was possible or the substituted expression.

subst
```
public static IExpr subst(IExpr expr,
                          IAST astRules)
```
Substitute all (sub-) expressions with the given rule set. If no substitution matches, the method returns the given expr.

Parameters:

astRules - rules of the form x->y or {a->b, c->d}; the left-hand-side of the rule can contain pattern objects.

Returns:

the input expr if no substitution of a (sub-)expression was possible or the substituted expression.

Subtract

public static IAST Subtract(IExpr a0,
                            IExpr a1)

Sum

public static IAST Sum(IExpr a0,
                       IExpr a1)

SurfaceGraphics
```
public static IAST SurfaceGraphics()
```

Take

public static IAST Take(IExpr a0,
                        IExpr a1)

Tan
```
public static IAST Tan(IExpr a0)
```

Tanh
```
public static IAST Tanh(IExpr a0)
```

Taylor

public static IAST Taylor(IExpr a0,
                          IExpr a1)

ternary

public static final IAST ternary(IExpr head,
                                 IExpr a0,
                                 IExpr a1,
                                 IExpr a2)

Throw
```
public static IAST Throw(IExpr a)
```

TimeConstrained

public static IAST TimeConstrained(IExpr a0,
                                   IExpr a1)

TimeConstrained

public static IAST TimeConstrained(IExpr a0,
                                   IExpr a1,
                                   IExpr a2)

Times
```
public static IAST Times()
```

Times
```
public static IAST Times(IExpr a0)
```

Times
```
public static IAST Times(IExpr... a)
```

Times

public static IAST Times(IExpr a0,
                         IExpr a1)

Together

public static IAST Together(IExpr a0)

Tr
```
public static IAST Tr(IExpr a0)
```

Trace
```
public static IAST Trace(IExpr a0)
```

Transpose

public static IAST Transpose(IExpr a0)

TrigExpand

public static IAST TrigExpand(IExpr a0)

TrigReduce

public static IAST TrigReduce(IExpr v)

TrigToExp

public static IAST TrigToExp(IExpr a0)

unary

public static final IAST unary(IExpr head,
                               IExpr a0)

Create a function with 1 argument without evaluation.

Parameters:: head -; a0 -
Returns:

Unequal

public static IAST Unequal(IExpr a0,
                           IExpr a1)

Unevaluated

public static IAST Unevaluated(IExpr a0)

Unique
```
public static IAST Unique(IExpr a0)
```

UnsameQ

public static IAST UnsameQ(IExpr a0,
                           IExpr a1)

UpSet

public static IAST UpSet(IExpr a0,
                         IExpr a1)

UpSetDelayed

public static IAST UpSetDelayed(IExpr a0,
                                IExpr a1)

While

public static IAST While(IExpr a0,
                         IExpr a1)

ZZ

public static IInteger ZZ(java.math.BigInteger integerValue)

Create a large integer number.

Parameters:: integerValue -
Returns:

ZZ
```
public static IInteger ZZ(long integerValue)
```
Create a large integer number.

Parameters:

integerValue -

Returns:

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

Class F

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

isSystemStarted

isSystemInitialized

PREDEFINED_INTERNAL_FORM_STRINGS

PREDEFINED_PATTERN_MAP

PREDEFINED_SYMBOLS_MAP

SYMBOL_OBSERVER

Catalan

ComplexInfinity

Degree

E

EulerGamma

Glaisher

GoldenRatio

I

Infinity

Khinchin

Pi

IntegerHead

SymbolHead

RealHead

PatternHead

BlankHead

StringHead

MethodHead

False

List

True

Null

Second

Indeterminate

DirectedInfinity

Listable

Constant

NumericFunction

Orderless

OneIdentity

Flat

HoldFirst

HoldRest

HoldAll

NHoldFirst

NHoldRest

NHoldAll

Line

BoxRatios

MeshRange

PlotRange

AxesStyle

Automatic

AxesOrigin

Axes

Background

White

Slot

SlotSequence

Options

Graphics

Graphics3D

Show

SurfaceGraphics

ArcCosh

ArcCoth

ArcCsc

ArcCsch

ArcSec

ArcSech

ArcSinh

ArcTanh

Plot

Plot3D

RootOf

Sequence

Append

AppendTo