F

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 IPattern`	`a_`
`static IPattern`	`A_`
`static IPattern`	`a_DEFAULT`
`static IPattern`	`A_DEFAULT`
`static IPattern`	`a_Symbol`
`static ISymbol`	`Aborted`
`static ISymbol`	`Abs`
`static ISymbol`	`AddTo`
`static ISymbol`	`Algebraics`
`static ISymbol`	`Alternatives`
`static ISymbol`	`And`
`static ISymbol`	`Apart`
`static ISymbol`	`AppellF1`
`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`	`ArrayQ`
`static ISymbol`	`Assumptions`
`static ISymbol`	`ASymbol`
`static ISymbol`	`AtomQ`
`static ISymbol`	`Attributes`
`static ISymbol`	`Automatic`
`static ISymbol`	`Axes`
`static ISymbol`	`AxesOrigin`
`static ISymbol`	`AxesStyle`
`static ISymbol`	`b`
`static IPattern`	`b_`
`static IPattern`	`B_`
`static IPattern`	`b_DEFAULT`
`static IPattern`	`B_DEFAULT`
`static IPattern`	`b_Symbol`
`static ISymbol`	`Background`
`static ISymbol`	`Begin`
`static ISymbol`	`BeginPackage`
`static ISymbol`	`Binomial`
`static ISymbol`	`Blank`
`static ISymbol`	`BlankHead`
`static ISymbol`	`Block`
`static ISymbol`	`Boole`
`static ISymbol`	`BooleanMinimize`
`static ISymbol`	`Booleans`
`static ISymbol`	`BoxRatios`
`static ISymbol`	`Break`
`static ISymbol`	`BSymbol`
`static ISymbol`	`c`
`static IPattern`	`c_`
`static IPattern`	`C_`
`static IPattern`	`c_DEFAULT`
`static IPattern`	`C_DEFAULT`
`static IPattern`	`c_Symbol`
`static IntegerSym`	`C0` Constant integer "0"
`static IntegerSym`	`C1` Constant integer "1"
`static IntegerSym`	`C10` Constant integer "10"
`static IFraction`	`C1D2` Constant fraction "1/2"
`static IFraction`	`C1D3` Constant fraction "1/3"
`static IFraction`	`C1D4` Constant fraction "1/4"
`static IAST`	`C1DSqrt10` Represents `1/Sqrt(10)`
`static IAST`	`C1DSqrt2` Represents `1/Sqrt(2)`
`static IAST`	`C1DSqrt3` Represents `1/Sqrt(3)`
`static IAST`	`C1DSqrt5` Represents `1/Sqrt(5)`
`static IAST`	`C1DSqrt6` Represents `1/Sqrt(6)`
`static IAST`	`C1DSqrt7` Represents `1/Sqrt(7)`
`static IntegerSym`	`C2` Constant integer "2"
`static IntegerSym`	`C3` Constant integer "3"
`static IntegerSym`	`C4` Constant integer "4"
`static IntegerSym`	`C5` Constant integer "5"
`static IntegerSym`	`C6` Constant integer "6"
`static IntegerSym`	`C7` Constant integer "7"
`static IntegerSym`	`C8` Constant integer "8"
`static IntegerSym`	`C9` Constant integer "9"
`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`	`ChebyshevT`
`static ISymbol`	`ChebyshevU`
`static ISymbol`	`ChessboardDistance`
`static ISymbol`	`Chop`
`static IComplex`	`CI` Complex imaginary unit.
`static IAST`	`CIInfinity` Represents `I*Infinity` (i.e.
`static IAST`	`CInfinity` Represents `Infinity` (i.e.
`static ISymbol`	`Clear`
`static ISymbol`	`ClearAll`
`static IntegerSym`	`CN1` Constant integer "-1"
`static IntegerSym`	`CN10` Constant integer "-10"
`static IFraction`	`CN1D2` Constant fraction "-1/2"
`static IFraction`	`CN1D3` Constant fraction "-1/3"
`static IFraction`	`CN1D4` Constant fraction "-1/4"
`static IntegerSym`	`CN2` Constant integer "-2"
`static IntegerSym`	`CN3` Constant integer "-3"
`static IntegerSym`	`CN4` Constant integer "-4"
`static IntegerSym`	`CN5` Constant integer "-5"
`static IntegerSym`	`CN6` Constant integer "-6"
`static IntegerSym`	`CN7` Constant integer "-7"
`static IntegerSym`	`CN8` Constant integer "-8"
`static IntegerSym`	`CN9` Constant integer "-9"
`static INum`	`CND1` Constant double "1.0"
`static IComplex`	`CNI` Complex negative imaginary unit.
`static IAST`	`CNIInfinity` Represents `-I*Infinity` (i.e.
`static IAST`	`CNInfinity` Represents `-Infinity` (i.e.
`static ISymbol`	`Coefficient`
`static ISymbol`	`CoefficientList`
`static ISymbol`	`Collect`
`static ISymbol`	`Colon`
`static ISymbol`	`Compile`
`static ISymbol`	`Complement`
`static ISymbol`	`Complex`
`static ISymbol`	`Complexes`
`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`	`CoshIntegral`
`static ISymbol`	`CosIntegral`
`static ISymbol`	`Cot`
`static ISymbol`	`Coth`
`static ISymbol`	`Count`
`static ISymbol`	`Cross`
`static ISymbol`	`Csc`
`static ISymbol`	`Csch`
`static IAST`	`CSqrt10` Represents `Sqrt(10)`
`static IAST`	`CSqrt2` Represents `Sqrt(2)`
`static IAST`	`CSqrt3` Represents `Sqrt(3)`
`static IAST`	`CSqrt5` Represents `Sqrt(5)`
`static IAST`	`CSqrt6` Represents `Sqrt(6)`
`static IAST`	`CSqrt7` Represents `Sqrt(7)`
`static ISymbol`	`CSymbol`
`static ISymbol`	`Curl`
`static ISymbol`	`d`
`static ISymbol`	`D`
`static IPattern`	`d_`
`static IPattern`	`d_DEFAULT`
`static IPattern`	`d_Symbol`
`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`	`Direction`
`static ISymbol`	`Discriminant`
`static ISymbol`	`Distribute`
`static ISymbol`	`Divergence`
`static ISymbol`	`DivideBy`
`static ISymbol`	`Divisible`
`static ISymbol`	`Do`
`static ISymbol`	`Dot`
`static ISymbol`	`Drop`
`static ISymbol`	`e`
`static ISymbol`	`E`
`static IPattern`	`e_`
`static IPattern`	`e_DEFAULT`
`static IPattern`	`e_Symbol`
`static ISymbol`	`Eigenvalues`
`static ISymbol`	`Eigenvectors`
`static ISymbol`	`Element`
`static ISymbol`	`EllipticE`
`static ISymbol`	`EllipticF`
`static ISymbol`	`EllipticPi`
`static ISymbol`	`End`
`static ISymbol`	`EndPackage`
`static ISymbol`	`Equal`
`static ISymbol`	`Equivalent`
`static ISymbol`	`Erf`
`static ISymbol`	`Erfc`
`static ISymbol`	`Erfi`
`static ISymbol`	`EuclidianDistance`
`static ISymbol`	`EulerGamma`
`static ISymbol`	`EulerPhi`
`static ISymbol`	`EvenQ`
`static ISymbol`	`Except`
`static ISymbol`	`Exp`
`static ISymbol`	`Expand`
`static ISymbol`	`ExpandAll`
`static ISymbol`	`ExpIntegralE`
`static ISymbol`	`ExpIntegralEi`
`static ISymbol`	`Exponent`
`static ISymbol`	`ExtendedGCD`
`static ISymbol`	`Extract`
`static ISymbol`	`f`
`static IPattern`	`f_`
`static IPattern`	`F_`
`static IPattern`	`f_DEFAULT`
`static IPattern`	`F_DEFAULT`
`static IPattern`	`f_Symbol`
`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`	`FresnelC`
`static ISymbol`	`FresnelS`
`static ISymbol`	`FrobeniusSolve`
`static ISymbol`	`FromCharacterCode`
`static ISymbol`	`FromContinuedFraction`
`static ISymbol`	`FSymbol`
`static ISymbol`	`FullForm`
`static ISymbol`	`FullSimplify`
`static ISymbol`	`g`
`static IPattern`	`g_`
`static IPattern`	`G_`
`static IPattern`	`g_DEFAULT`
`static IPattern`	`G_DEFAULT`
`static IPattern`	`g_Symbol`
`static ISymbol`	`Gamma`
`static ISymbol`	`GCD`
`static ISymbol`	`GeometricMean`
`static ISymbol`	`Get`
`static ISymbol`	`Glaisher`
`static java.util.HashMap<IExpr,ExprID>`	`GLOBAL_IDS_MAP` Global map of predefined constant expressions.
`static ISymbol`	`GoldenRatio`
`static ISymbol`	`Graphics`
`static ISymbol`	`Graphics3D`
`static ISymbol`	`Greater`
`static ISymbol`	`GreaterEqual`
`static ISymbol`	`GroebnerBasis`
`static ISymbol`	`GSymbol`
`static ISymbol`	`h`
`static IPattern`	`h_`
`static IPattern`	`h_DEFAULT`
`static IPattern`	`h_Symbol`
`static ISymbol`	`HarmonicNumber`
`static ISymbol`	`Head`
`static java.util.Map<java.lang.String,ISymbol>`	`HIDDEN_SYMBOLS_MAP`
`static ISymbol`	`HilbertMatrix`
`static ISymbol`	`Hold`
`static ISymbol`	`HoldAll`
`static ISymbol`	`HoldFirst`
`static ISymbol`	`HoldForm`
`static ISymbol`	`HoldRest`
`static ISymbol`	`Horner`
`static ISymbol`	`HurwitzZeta`
`static ISymbol`	`Hypergeometric2F1`
`static ISymbol`	`HypergeometricPFQ`
`static ISymbol`	`i`
`static ISymbol`	`I`
`static IPattern`	`i_`
`static IPattern`	`i_DEFAULT`
`static IPattern`	`i_Symbol`
`static ISymbol`	`Identity`
`static ISymbol`	`IdentityMatrix`
`static ISymbol`	`If`
`static ISymbol`	`Im`
`static ISymbol`	`Implies`
`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`	`Integers`
`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 IPattern`	`j_`
`static IPattern`	`j_DEFAULT`
`static IPattern`	`j_Symbol`
`static ISymbol`	`JacobiMatrix`
`static ISymbol`	`JacobiSymbol`
`static ISymbol`	`JavaForm`
`static ISymbol`	`Join`
`static ISymbol`	`k`
`static IPattern`	`k_`
`static IPattern`	`k_DEFAULT`
`static IPattern`	`k_Symbol`
`static ISymbol`	`Khinchin`
`static ISymbol`	`KOrderlessPartitions`
`static ISymbol`	`KPartitions`
`static ISymbol`	`l`
`static IPattern`	`l_`
`static IPattern`	`l_DEFAULT`
`static IPattern`	`l_Symbol`
`static ISymbol`	`LaplaceTransform`
`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`	`ListQ`
`static ISymbol`	`Literal`
`static ISymbol`	`Log`
`static ISymbol`	`LogGamma`
`static ISymbol`	`LogIntegral`
`static ISymbol`	`LowerCaseQ`
`static ISymbol`	`LUDecomposition`
`static ISymbol`	`m`
`static IPattern`	`m_`
`static IPattern`	`m_DEFAULT`
`static IPattern`	`m_Symbol`
`static ISymbol`	`ManhattanDistance`
`static ISymbol`	`Map`
`static ISymbol`	`MapAll`
`static ISymbol`	`MapThread`
`static ISymbol`	`MatchQ`
`static ISymbol`	`MathMLForm`
`static ISymbol`	`MatrixPower`
`static ISymbol`	`MatrixQ`
`static ISymbol`	`Max`
`static ISymbol`	`Mean`
`static ISymbol`	`Median`
`static ISymbol`	`MemberQ`
`static ISymbol`	`MeshRange`
`static ISymbol`	`MessageName`
`static ISymbol`	`MethodHead`
`static ISymbol`	`Min`
`static ISymbol`	`Mod`
`static ISymbol`	`Module`
`static ISymbol`	`Modulus`
`static ISymbol`	`MoebiusMu`
`static ISymbol`	`Most`
`static ISymbol`	`Multinomial`
`static ISymbol`	`n`
`static ISymbol`	`N`
`static IPattern`	`n_`
`static IPattern`	`n_DEFAULT`
`static IPattern`	`n_Symbol`
`static ISymbol`	`Nand`
`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 NILPointer`	`NIL` The constant object `NIL` (not in list) indicates in the evaluation process that no evaluation was possible (i.e. no further definition was found to create a new expression from the existing one).
`static ISymbol`	`NIntegrate`
`static ISymbol`	`NonCommutativeMultiply`
`static ISymbol`	`NonNegative`
`static ISymbol`	`Nor`
`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`	`O`
`static IPattern`	`o_`
`static IPattern`	`o_DEFAULT`
`static IPattern`	`o_Symbol`
`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 IPattern`	`p_`
`static IPattern`	`p_DEFAULT`
`static IPattern`	`p_Symbol`
`static ISymbol`	`Package`
`static ISymbol`	`PadLeft`
`static ISymbol`	`PadRight`
`static ISymbol`	`Part`
`static ISymbol`	`Partition`
`static ISymbol`	`Pattern`
`static ISymbol`	`PatternHead`
`static ISymbol`	`PatternTest`
`static ISymbol`	`Permutations`
`static ISymbol`	`Pi`
`static ISymbol`	`Piecewise`
`static ISymbol`	`Plot`
`static ISymbol`	`Plot3D`
`static ISymbol`	`PlotRange`
`static ISymbol`	`Plus`
`static ISymbol`	`PolyGamma`
`static ISymbol`	`PolyLog`
`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 ISymbol`	`PreIncrement`
`static ISymbol`	`Prepend`
`static ISymbol`	`PrependTo`
`static ISymbol`	`PrimeQ`
`static ISymbol`	`Primes`
`static ISymbol`	`PrimitiveRoots`
`static ISymbol`	`Print`
`static ISymbol`	`Product`
`static ISymbol`	`ProductLog`
`static ISymbol`	`q`
`static IPattern`	`q_`
`static IPattern`	`q_DEFAULT`
`static IPattern`	`q_Symbol`
`static ISymbol`	`Quiet`
`static ISymbol`	`Quotient`
`static ISymbol`	`r`
`static IPattern`	`r_`
`static IPattern`	`r_DEFAULT`
`static IPattern`	`r_Symbol`
`static ISymbol`	`RandomInteger`
`static ISymbol`	`RandomReal`
`static ISymbol`	`Range`
`static ISymbol`	`Rational`
`static ISymbol`	`Rationalize`
`static ISymbol`	`Rationals`
`static ISymbol`	`Re`
`static ISymbol`	`RealHead`
`static ISymbol`	`Reals`
`static ISymbol`	`Reap`
`static ISymbol`	`Refine`
`static ISymbol`	`Repeated`
`static ISymbol`	`RepeatedNull`
`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`	`RowReduce`
`static ISymbol`	`Rule`
`static ISymbol`	`RuleDelayed`
`static ISymbol`	`s`
`static IPattern`	`s_`
`static IPattern`	`s_DEFAULT`
`static IPattern`	`s_Symbol`
`static ISymbol`	`SameQ`
`static ISymbol`	`Scan`
`static ISymbol`	`Sec`
`static ISymbol`	`Sech`
`static ISymbol`	`Second`
`static ISymbol`	`Select`
`static ISymbol`	`Sequence`
`static ISymbol`	`Series`
`static ISymbol`	`SeriesData`
`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`	`Sinc`
`static ISymbol`	`SingularValueDecomposition`
`static ISymbol`	`Sinh`
`static ISymbol`	`SinhIntegral`
`static ISymbol`	`SinIntegral`
`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`	`Span`
`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`	`Subfactorial`
`static ISymbol`	`Subscript`
`static ISymbol`	`Subsets`
`static ISymbol`	`Subsuperscript`
`static ISymbol`	`SubtractFrom`
`static ISymbol`	`Sum`
`static ISymbol`	`Superscript`
`static ISymbol`	`Surd`
`static ISymbol`	`SurfaceGraphics`
`static ISymbol`	`Switch`
`static ISymbolObserver`	`SYMBOL_OBSERVER`
`static ISymbol`	`SymbolHead`
`static ISymbol`	`SyntaxLength`
`static ISymbol`	`SyntaxQ`
`static ISymbol`	`t`
`static IPattern`	`t_`
`static IPattern`	`t_DEFAULT`
`static IPattern`	`t_Symbol`
`static ISymbol`	`Table`
`static ISymbol`	`Take`
`static ISymbol`	`Tan`
`static ISymbol`	`Tanh`
`static ISymbol`	`Taylor`
`static ISymbol`	`TeXForm`
`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 IPattern`	`u_`
`static IPattern`	`u_DEFAULT`
`static IPattern`	`u_Symbol`
`static ISymbol`	`Unequal`
`static ISymbol`	`Unevaluated`
`static ISymbol`	`Union`
`static ISymbol`	`Unique`
`static ISymbol`	`UnitStep`
`static ISymbol`	`UnsameQ`
`static ISymbol`	`Unset`
`static ISymbol`	`UpperCaseQ`
`static ISymbol`	`UpSet`
`static ISymbol`	`UpSetDelayed`
`static ISymbol`	`v`
`static IPattern`	`v_`
`static IPattern`	`v_DEFAULT`
`static IPattern`	`v_Symbol`
`static ISymbol`	`ValueQ`
`static ISymbol`	`VandermondeMatrix`
`static ISymbol`	`Variables`
`static ISymbol`	`VectorQ`
`static ISymbol`	`w`
`static IPattern`	`w_`
`static IPattern`	`w_DEFAULT`
`static IPattern`	`w_Symbol`
`static ISymbol`	`Which`
`static ISymbol`	`While`
`static ISymbol`	`White`
`static ISymbol`	`x`
`static IPattern`	`x_`
`static IPattern`	`x_DEFAULT`
`static IPattern`	`x_Symbol`
`static ISymbol`	`Xor`
`static ISymbol`	`y`
`static IPattern`	`y_`
`static IPattern`	`y_DEFAULT`
`static IPattern`	`y_Symbol`
`static ISymbol`	`z`
`static IPattern`	`z_`
`static IPattern`	`z_DEFAULT`
`static IPattern`	`z_Symbol`
`static ISymbol`	`Zeta`

Constructor Summary

Constructors
Constructor and Description

F()

Constructors
Constructor and Description
`F()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static IAST`	`$(IExpr head, IExpr... a)` Create a new abstract syntax tree (AST).
`static IPattern`	`$b()` Create a `Blank[]` pattern object for pattern-matching and term rewriting
`static IPattern`	`$b(IExpr condition)` Create a `Blank[condition]` pattern object for pattern-matching and term rewriting
`static IPattern`	`$b(IExpr condition, boolean def)`
`static IPattern`	`$p(ISymbol symbol)` Create a `Pattern[]` 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, boolean zeroArgsAllowed)` 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 or create 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)` Get or create a global symbol which is retrieved from the global symbols map or created or retrieved from the thread local variables map.
`static IAST`	`Abs(IExpr a0)`
`static IAST`	`Alternatives(IExpr... a)`
`static IAST`	`And()`
`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`	`AppellF1(IExpr... a)`
`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`	`binaryAST2(IExpr head, IExpr a0, IExpr a1)` Create a function with 2 arguments as a `AST2` immutable object 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 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
`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`	`ChebyshevT(IExpr a0, IExpr a1)`
`static IAST`	`ChebyshevU(IExpr a0, IExpr a1)`
`static IAST`	`Chop(IExpr a0)`
`static IExpr`	`chopExpr(IExpr arg, double delta)`
`static INumber`	`chopNumber(INumber arg, double delta)` Set real or imaginary parts of a numeric argument to zero, those absolute value is less than a delta.
`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(IRational re)` Create a symbolic complex number
`static IComplex`	`complex(IRational re, IRational 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(org.apfloat.Apcomplex c)`
`static IComplexNum`	`complexNum(org.apfloat.Apfloat r)`
`static IComplexNum`	`complexNum(org.apfloat.Apfloat r, org.apfloat.Apfloat i)`
`static IComplexNum`	`complexNum(org.apache.commons.math4.complex.Complex c)`
`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 value)`
`static IComplexNum`	`complexNum(IFraction value)`
`static IComplexNum`	`complexNum(IInteger value)`
`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`	`CoshIntegral(IExpr a)`
`static IAST`	`CosIntegral(IExpr a)`
`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... a)`
`static IAST`	`Det(IExpr a0)`
`static IAST`	`DirectedInfinity(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)` The division `a0 / a1` will be represented by `Times(a0, Power(a1, -1))`.
`static IAST`	`Divisible(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`	`Element(IExpr a0, IExpr a1)`
`static IAST`	`EllipticE(IExpr a0, IExpr a1)`
`static IAST`	`EllipticF(IExpr a0, IExpr a1)`
`static IAST`	`EllipticPi(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Equal(IExpr... a)`
`static IAST`	`Equal(IExpr a0, IExpr a1)`
`static IAST`	`Erf(IExpr a)`
`static IAST`	`Erfc(IExpr a)`
`static IAST`	`Erfi(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)` Evaluate `Expand()` for the given expression. returns the given argument.
`static IExpr`	`evalExpandAll(IExpr a)` Apply `ExpandAll()` to the given expression if it's an `IAST`.
`static IExpr`	`evaln(IExpr a0)` Deprecated. use EvalEngine.get().evalN() instead
`static IExpr`	`evalQuiet(IExpr a)` Deprecated. use EvalEngine#evalQuiet();
`static IExpr`	`evalQuietNull(IExpr a)` Deprecated. use EvalEngine#evalQuietNull()
`static boolean`	`evalTrue(IExpr expr)` Deprecated. use EvalEngine#evalTrue()
`static IAST`	`EvenQ(IExpr a)`
`static IAST`	`Exp(IExpr a0)`
`static IAST`	`Expand(IExpr a0)`
`static IExpr`	`expand(IExpr a, boolean expandNegativePowers, boolean distributePlus)` Apply `Expand()` to the given expression if it's an `IAST`.
`static IAST`	`Expand(IExpr a0, IExpr a1)`
`static IAST`	`ExpandAll(IExpr a0)`
`static IExpr`	`expandAll(IExpr a, boolean expandNegativePowers, boolean distributePlus)` Apply `ExpandAll()` to the given expression if it's an `IAST`.
`static IAST`	`ExpIntegralE(IExpr a0, IExpr a1)`
`static IAST`	`ExpIntegralEi(IExpr a)`
`static IAST`	`Exponent(IExpr a0, IExpr a1)`
`static IAST`	`Exponent(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Extract(IExpr a0, IExpr a1)`
`static IAST`	`Factor(IExpr a0)`
`static IAST`	`Factorial(IExpr a0)`
`static IAST`	`Factorial2(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(org.apache.commons.math4.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 IRational`	`fraction(long numerator, long denominator)` Create a "fractional" number
`static IAST`	`FractionalPart(IExpr a)`
`static IAST`	`FreeQ(IExpr a0, IExpr a1)`
`static IAST`	`FresnelC(IExpr a)`
`static IAST`	`FresnelS(IExpr a)`
`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)`
`static IAST`	`GCD(IExpr a0, IExpr a1)`
`static Namespace`	`getNamespace()` Get the namespace
`static IAST`	`Graphics()`
`static IExpr`	`Greater(IExpr a0, IExpr a1)`
`static IExpr`	`GreaterEqual(IExpr a0, IExpr a1)`
`static IAST`	`HarmonicNumber(IExpr a)`
`static IAST`	`HarmonicNumber(IExpr a0, IExpr a1)`
`static IAST`	`Head(IExpr a)`
`static IAST`	`headAST0(IExpr head)` Create a new abstract syntax tree (AST).
`static IAST`	`Hold(IExpr a0)`
`static IAST`	`HoldForm(IExpr a0)`
`static IAST`	`HurwitzZeta(IExpr a0, IExpr a1)`
`static IAST`	`Hypergeometric2F1(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`HypergeometricPFQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Identity(IExpr a0)`
`static IAST`	`If(IExpr a0, IExpr a1)`
`static IAST`	`If(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`If(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`IInit(ISymbol sym, int[] sizes)`
`static IExpr`	`Im(IExpr a0)`
`static IAST`	`Increment(IExpr a)`
`static ISymbol`	`initFinalHiddenSymbol(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 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 ISymbol`	`initFinalSymbol(java.lang.String symbolName, IEvaluator evaluator)` Convert the symbolName to lowercase (if `Config.PARSER_USE_LOWERCASE_SYMBOLS` is set) and insert a new Symbol in the `PREDEFINED_SYMBOLS_MAP`.
`static IPattern`	`initPredefinedPattern(ISymbol symbol)`
`static void`	`initSymbols()` Initialize the complete System.
`static void`	`initSymbols(java.io.Reader reader, ISymbolObserver symbolObserver)`
`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 radix)` 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 IAST`	`ISet(IExpr lhs, IExpr rhs)` Assign the evaluated `rhs` to the `lhs`.
`static IAST`	`ISetDelayed(IExpr lhs, IExpr rhs)` Assign the unevaluated `rhs` to the `lhs`.
`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`	`isNumEqualRational(double value, IRational rational)`
`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`	`LaplaceTransform(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Last(IExpr a0)`
`static IAST`	`LCM(IExpr a0, IExpr a1)`
`static IAST`	`LeafCount(IExpr a0)`
`static IAST`	`Length(IExpr a)`
`static IExpr`	`Less(IExpr a0, IExpr a1)`
`static IExpr`	`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 IAST`	`ListC(int capacity)` Create a new `List` with the given `capacity`.
`static IAST`	`ListQ(IExpr a)`
`static ISymbol`	`local(java.lang.String symbolName, IExpr value)` Get 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`	`Log(IExpr a0, IExpr a1)`
`static IAST`	`Log10(IExpr a0)`
`static IAST`	`LogGamma(IExpr a0)`
`static IAST`	`LogIntegral(IExpr a)`
`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 IAST`	`MessageName(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 IExpr`	`Negate(IExpr x)` 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`	`Norm(IExpr a)`
`static IAST`	`Not(IExpr a)`
`static INum`	`num(org.apfloat.Apfloat af)`
`static INum`	`num(double d)` Create a numeric value
`static INum`	`num(IFraction value)`
`static INum`	`num(IInteger value)`
`static INum`	`num(java.lang.String valueString)` Create a numeric value from the input string.
`static IAST`	`NumberQ(IExpr a0)`
`static IAST`	`Numerator(IExpr a0)`
`static IAST`	`NumericQ(IExpr a0)`
`static IAST`	`O(IExpr a0)`
`static IAST`	`OddQ(IExpr a)`
`static IAST`	`Options(IExpr a0)`
`static IAST`	`Or()`
`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`	`Plus(long num, IExpr... a)`
`static IAST`	`PolyGamma(IExpr a0)`
`static IAST`	`PolyGamma(IExpr a0, IExpr a1)`
`static IAST`	`PolyLog(IExpr a0, IExpr a1)`
`static IAST`	`PolynomialQ(IExpr a0, IExpr a1)`
`static IAST`	`PolynomialQuotient(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialQuotientRemainder(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialRemainder(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Position(IExpr a0, IExpr a1)` Pop the current top value from the symbols local variable stack.
`static IAST`	`Positive(IExpr a0)`
`static IAST`	`PossibleZeroQ(IExpr a0)`
`static IAST`	`Power(IExpr a0, IExpr a1)`
`static IExpr`	`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 IAST`	`ProductLog(IExpr a0)`
`static IAST`	`ProductLog(IExpr a0, IExpr a1)`
`static IFraction`	`QQ(org.apache.commons.math4.fraction.BigFraction frac)` Create a "fractional" number
`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 IExpr`	`Re(IExpr a0)`
`static IAST`	`Reap(IExpr a)`
`static IAST`	`Refine(IExpr a0, IExpr a1)`
`static IAST`	`ReplaceAll(IExpr a0, IExpr a1)`
`static IAST`	`ReplacePart(IExpr a0, IExpr a1)`
`static IAST`	`ReplacePart(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Rest(IExpr a0)`
`static IAST`	`Resultant(IExpr a0, IExpr a1, IExpr a2)`
`static ISymbol`	`retrieveSymbol(java.lang.String symbolName)` Get or create a symbol which is retrieved from the eval engines context path.
`static IAST`	`Return(IExpr a)`
`static IAST`	`Reverse(IExpr a)`
`static IAST`	`Roots(IExpr a0)`
`static IAST`	`Roots(IExpr a0, IExpr a1)`
`static IAST`	`Round(IExpr a0)`
`static IAST`	`RowReduce(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`	`Series(IExpr... a)`
`static IAST`	`SeriesData(IExpr... a)`
`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`	`Sinc(IExpr a0)`
`static IAST`	`Sinh(IExpr a0)`
`static IAST`	`SinhIntegral(IExpr a)`
`static IAST`	`SinIntegral(IExpr a)`
`static IAST`	`Slot(IExpr a0)`
`static IAST`	`Slot(int i)`
`static IAST`	`Solve(IExpr a0, IExpr a1)`
`static IAST`	`Sort(IExpr a0, IExpr a1)`
`static IAST`	`Sow(IExpr a)`
`static IAST`	`Span(IExpr... a)`
`static IAST`	`Sqr(IExpr x)` Create a "square" expression: `Power(x, 2)`.
`static IAST`	`Sqrt(IExpr x)` Create a "square root" expression: `Power(x, 1/2)`.
`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 IAST`	`Subfactorial(IExpr a0)`
`static IExpr`	`subst(IExpr expr, java.util.function.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 IExpr`	`subst(IExpr expr, IExpr subExpr, IExpr replacementExpr)` Substitute all (sub-) expressions with the given replacement expression.
`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`	`ternaryAST3(IExpr head, IExpr a0, IExpr a1, IExpr a2)` Create a function with 3 arguments as a `AST3` immutable object without evaluation.
`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`	`Times(long num, IExpr... a)`
`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`	`unaryAST1(IExpr head, IExpr a0)` Create a function with 1 argument as a `AST1` immutable object 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`	`Unset(IExpr a0)`
`static IAST`	`UpSet(IExpr a0, IExpr a1)`
`static IAST`	`UpSetDelayed(IExpr a0, IExpr a1)`
`static IAST`	`While(IExpr a0, IExpr a1)`
`static IAST`	`Zeta(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
clone, equals, finalize, 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

HIDDEN_SYMBOLS_MAP

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

SYMBOL_OBSERVER

public static ISymbolObserver SYMBOL_OBSERVER

NIL
```
public static final NILPointer NIL
```
The constant object NIL (not in list) indicates in the evaluation process that no evaluation was possible (i.e. no further definition was found to create a new expression from the existing one).

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
```

Aborted
```
public static final ISymbol Aborted
```

Assumptions

public static final ISymbol Assumptions

Begin
```
public static final ISymbol Begin
```

BeginPackage

public static final ISymbol BeginPackage

End
```
public static final ISymbol End
```

EndPackage
```
public static final ISymbol EndPackage
```

Except
```
public static final ISymbol Except
```

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
```

PatternTest

public static final ISymbol PatternTest

Colon
```
public static final ISymbol Colon
```

Repeated
```
public static final ISymbol Repeated
```

RepeatedNull

public static final ISymbol RepeatedNull

Algebraics
```
public static final ISymbol Algebraics
```

Booleans
```
public static final ISymbol Booleans
```

Complexes
```
public static final ISymbol Complexes
```

Integers
```
public static final ISymbol Integers
```

Primes
```
public static final ISymbol Primes
```

Rationals
```
public static final ISymbol Rationals
```

Reals
```
public static final ISymbol Reals
```

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

Alternatives

public static final ISymbol Alternatives

Direction
```
public static final ISymbol Direction
```

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

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
```

Modulus
```
public static final ISymbol Modulus
```

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

Span
```
public static final ISymbol Span
```

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
```

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

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
```

ArrayQ
```
public static final ISymbol ArrayQ
```

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
```

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

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

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

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

Compile
```
public static final ISymbol Compile
```

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

CompoundExpression

public static final ISymbol CompoundExpression

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

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

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

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
```

DirectedInfinity

public static final ISymbol DirectedInfinity

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

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

Element
```
public static final ISymbol Element
```

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

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

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
```

Get
```
public static final ISymbol Get
```

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

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

HoldForm
```
public static final ISymbol HoldForm
```

Identity
```
public static final ISymbol Identity
```

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

Implies
```
public static final ISymbol Implies
```

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

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

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

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

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

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

ListQ
```
public static final ISymbol ListQ
```

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

MathMLForm
```
public static final ISymbol MathMLForm
```

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

MessageName

public static final ISymbol MessageName

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

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

Nand
```
public static final ISymbol Nand
```

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

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

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

NestWhileList

public static final ISymbol NestWhileList

Nor
```
public static final ISymbol Nor
```

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

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

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

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

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

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

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

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
```

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

Refine
```
public static final ISymbol Refine
```

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

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

RuleDelayed

public static final ISymbol RuleDelayed

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

SetAttributes

public static final ISymbol SetAttributes

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

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

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

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

TeXForm
```
public static final ISymbol TeXForm
```

TimeConstrained

public static final ISymbol TimeConstrained

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

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

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

Unevaluated

public static final ISymbol Unevaluated

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

Unset
```
public static final ISymbol Unset
```

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

UpSetDelayed

public static final ISymbol UpSetDelayed

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
```

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

ChebyshevT
```
public static final ISymbol ChebyshevT
```

ChebyshevU
```
public static final ISymbol ChebyshevU
```

ChessboardDistance

public static final ISymbol ChessboardDistance

Coefficient

public static final ISymbol Coefficient

CoefficientList

public static final ISymbol CoefficientList

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

ComposeList

public static final ISymbol ComposeList

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
```

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
```

Divisible
```
public static final ISymbol Divisible
```

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

Eigenvalues

public static final ISymbol Eigenvalues

Eigenvectors

public static final ISymbol Eigenvectors

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

Equivalent
```
public static final ISymbol Equivalent
```

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

Erfc
```
public static final ISymbol Erfc
```

Erfi
```
public static final ISymbol Erfi
```

EuclidianDistance

public static final ISymbol EuclidianDistance

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

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

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

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

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

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

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

HurwitzZeta

public static final ISymbol HurwitzZeta

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

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

LaplaceTransform

public static final ISymbol LaplaceTransform

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

Literal
```
public static final ISymbol Literal
```

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
```

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
```

O
```
public static final ISymbol O
```

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

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

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

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

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

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

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

Permutations

public static final ISymbol Permutations

Piecewise
```
public static final ISymbol Piecewise
```

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
```

ProductLog
```
public static final ISymbol ProductLog
```

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

RandomInteger

public static final ISymbol RandomInteger

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

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

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
```

RowReduce
```
public static final ISymbol RowReduce
```

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
```

Series
```
public static final ISymbol Series
```

SeriesData
```
public static final ISymbol SeriesData
```

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

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

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

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

Sinc
```
public static final ISymbol Sinc
```

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
```

Subfactorial

public static final ISymbol Subfactorial

Subscript
```
public static final ISymbol Subscript
```

Subsuperscript

public static final ISymbol Subsuperscript

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

SubtractFrom

public static final ISymbol SubtractFrom

Superscript

public static final ISymbol Superscript

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

Surd
```
public static final ISymbol Surd
```

SyntaxLength

public static final ISymbol SyntaxLength

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

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

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
```

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
```

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
```

VandermondeMatrix

public static final ISymbol VandermondeMatrix

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

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

Xor
```
public static final ISymbol Xor
```

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
```

ASymbol
```
public static final ISymbol ASymbol
```

BSymbol
```
public static final ISymbol BSymbol
```

CSymbol
```
public static final ISymbol CSymbol
```

FSymbol
```
public static final ISymbol FSymbol
```

GSymbol
```
public static final ISymbol GSymbol
```

a_
```
public static final IPattern a_
```

b_
```
public static final IPattern b_
```

c_
```
public static final IPattern c_
```

d_
```
public static final IPattern d_
```

e_
```
public static final IPattern e_
```

f_
```
public static final IPattern f_
```

g_
```
public static final IPattern g_
```

h_
```
public static final IPattern h_
```

i_
```
public static final IPattern i_
```

j_
```
public static final IPattern j_
```

k_
```
public static final IPattern k_
```

l_
```
public static final IPattern l_
```

m_
```
public static final IPattern m_
```

n_
```
public static final IPattern n_
```

o_
```
public static final IPattern o_
```

p_
```
public static final IPattern p_
```

q_
```
public static final IPattern q_
```

r_
```
public static final IPattern r_
```

s_
```
public static final IPattern s_
```

t_
```
public static final IPattern t_
```

u_
```
public static final IPattern u_
```

v_
```
public static final IPattern v_
```

w_
```
public static final IPattern w_
```

x_
```
public static final IPattern x_
```

y_
```
public static final IPattern y_
```

z_
```
public static final IPattern z_
```

A_
```
public static final IPattern A_
```

B_
```
public static final IPattern B_
```

C_
```
public static final IPattern C_
```

F_
```
public static final IPattern F_
```

G_
```
public static final IPattern G_
```

a_Symbol
```
public static final IPattern a_Symbol
```

b_Symbol
```
public static final IPattern b_Symbol
```

c_Symbol
```
public static final IPattern c_Symbol
```

d_Symbol
```
public static final IPattern d_Symbol
```

e_Symbol
```
public static final IPattern e_Symbol
```

f_Symbol
```
public static final IPattern f_Symbol
```

g_Symbol
```
public static final IPattern g_Symbol
```

h_Symbol
```
public static final IPattern h_Symbol
```

i_Symbol
```
public static final IPattern i_Symbol
```

j_Symbol
```
public static final IPattern j_Symbol
```

k_Symbol
```
public static final IPattern k_Symbol
```

l_Symbol
```
public static final IPattern l_Symbol
```

m_Symbol
```
public static final IPattern m_Symbol
```

n_Symbol
```
public static final IPattern n_Symbol
```

o_Symbol
```
public static final IPattern o_Symbol
```

p_Symbol
```
public static final IPattern p_Symbol
```

q_Symbol
```
public static final IPattern q_Symbol
```

r_Symbol
```
public static final IPattern r_Symbol
```

s_Symbol
```
public static final IPattern s_Symbol
```

t_Symbol
```
public static final IPattern t_Symbol
```

u_Symbol
```
public static final IPattern u_Symbol
```

v_Symbol
```
public static final IPattern v_Symbol
```

w_Symbol
```
public static final IPattern w_Symbol
```

x_Symbol
```
public static final IPattern x_Symbol
```

y_Symbol
```
public static final IPattern y_Symbol
```

z_Symbol
```
public static final IPattern z_Symbol
```

a_DEFAULT
```
public static final IPattern a_DEFAULT
```

b_DEFAULT
```
public static final IPattern b_DEFAULT
```

c_DEFAULT
```
public static final IPattern c_DEFAULT
```

d_DEFAULT
```
public static final IPattern d_DEFAULT
```

e_DEFAULT
```
public static final IPattern e_DEFAULT
```

f_DEFAULT
```
public static final IPattern f_DEFAULT
```

g_DEFAULT
```
public static final IPattern g_DEFAULT
```

h_DEFAULT
```
public static final IPattern h_DEFAULT
```

i_DEFAULT
```
public static final IPattern i_DEFAULT
```

j_DEFAULT
```
public static final IPattern j_DEFAULT
```

k_DEFAULT
```
public static final IPattern k_DEFAULT
```

l_DEFAULT
```
public static final IPattern l_DEFAULT
```

m_DEFAULT
```
public static final IPattern m_DEFAULT
```

n_DEFAULT
```
public static final IPattern n_DEFAULT
```

o_DEFAULT
```
public static final IPattern o_DEFAULT
```

p_DEFAULT
```
public static final IPattern p_DEFAULT
```

q_DEFAULT
```
public static final IPattern q_DEFAULT
```

r_DEFAULT
```
public static final IPattern r_DEFAULT
```

s_DEFAULT
```
public static final IPattern s_DEFAULT
```

t_DEFAULT
```
public static final IPattern t_DEFAULT
```

u_DEFAULT
```
public static final IPattern u_DEFAULT
```

v_DEFAULT
```
public static final IPattern v_DEFAULT
```

w_DEFAULT
```
public static final IPattern w_DEFAULT
```

x_DEFAULT
```
public static final IPattern x_DEFAULT
```

y_DEFAULT
```
public static final IPattern y_DEFAULT
```

z_DEFAULT
```
public static final IPattern z_DEFAULT
```

A_DEFAULT
```
public static final IPattern A_DEFAULT
```

B_DEFAULT
```
public static final IPattern B_DEFAULT
```

C_DEFAULT
```
public static final IPattern C_DEFAULT
```

F_DEFAULT
```
public static final IPattern F_DEFAULT
```

G_DEFAULT
```
public static final IPattern G_DEFAULT
```

C0
```
public static final IntegerSym C0
```
Constant integer "0"

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

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

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

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

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

C6
```
public static final IntegerSym C6
```
Constant integer "6"

C7
```
public static final IntegerSym C7
```
Constant integer "7"

C8
```
public static final IntegerSym C8
```
Constant integer "8"

C9
```
public static final IntegerSym C9
```
Constant integer "9"

C10
```
public static final IntegerSym C10
```
Constant integer "10"

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"

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

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))

CIInfinity
```
public static IAST CIInfinity
```
Represents I*Infinity (i.e. I*Infinity->DirectedInfinity(I))

CNIInfinity
```
public static IAST CNIInfinity
```
Represents -I*Infinity (i.e. -I*Infinity->DirectedInfinity(-I))

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

CSqrt2
```
public static IAST CSqrt2
```
Represents Sqrt(2)

CSqrt3
```
public static IAST CSqrt3
```
Represents Sqrt(3)

CSqrt5
```
public static IAST CSqrt5
```
Represents Sqrt(5)

CSqrt6
```
public static IAST CSqrt6
```
Represents Sqrt(6)

CSqrt7
```
public static IAST CSqrt7
```
Represents Sqrt(7)

CSqrt10
```
public static IAST CSqrt10
```
Represents Sqrt(10)

C1DSqrt2
```
public static IAST C1DSqrt2
```
Represents 1/Sqrt(2)

C1DSqrt3
```
public static IAST C1DSqrt3
```
Represents 1/Sqrt(3)

C1DSqrt5
```
public static IAST C1DSqrt5
```
Represents 1/Sqrt(5)

C1DSqrt6
```
public static IAST C1DSqrt6
```
Represents 1/Sqrt(6)

C1DSqrt7
```
public static IAST C1DSqrt7
```
Represents 1/Sqrt(7)

C1DSqrt10
```
public static IAST C1DSqrt10
```
Represents 1/Sqrt(10)

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

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

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

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

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

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

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

CN6
```
public static final IntegerSym CN6
```
Constant integer "-6"

CN7
```
public static final IntegerSym CN7
```
Constant integer "-7"

CN8
```
public static final IntegerSym CN8
```
Constant integer "-8"

CN9
```
public static final IntegerSym CN9
```
Constant integer "-9"

CN10
```
public static final IntegerSym CN10
```
Constant integer "-10"

AppellF1
```
public static final ISymbol AppellF1
```

CosIntegral

public static final ISymbol CosIntegral

EllipticE
```
public static final ISymbol EllipticE
```

EllipticF
```
public static final ISymbol EllipticF
```

EllipticPi
```
public static final ISymbol EllipticPi
```

FresnelC
```
public static final ISymbol FresnelC
```

FresnelS
```
public static final ISymbol FresnelS
```

HypergeometricPFQ

public static final ISymbol HypergeometricPFQ

Hypergeometric2F1

public static final ISymbol Hypergeometric2F1

SinIntegral

public static final ISymbol SinIntegral

CoshIntegral

public static final ISymbol CoshIntegral

SinhIntegral

public static final ISymbol SinhIntegral

ExpIntegralEi

public static final ISymbol ExpIntegralEi

LogIntegral

public static final ISymbol LogIntegral

PolyLog
```
public static final ISymbol PolyLog
```

LogGamma
```
public static final ISymbol LogGamma
```

Zeta
```
public static final ISymbol Zeta
```

PolyGamma
```
public static final ISymbol PolyGamma
```

ExpIntegralE

public static final ISymbol ExpIntegralE

GLOBAL_IDS_MAP

public static final java.util.HashMap<IExpr,ExprID> GLOBAL_IDS_MAP

Global map of predefined constant expressions.

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:

$b
```
public static IPattern $b()
```
Create a Blank[] pattern object for pattern-matching and term rewriting

Returns:

IPattern

$b
```
public static IPattern $b(IExpr condition)
```
Create a Blank[condition] pattern object for pattern-matching and term rewriting

Parameters:

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

Returns:

IPattern

$b

public static IPattern $b(IExpr condition,
                          boolean def)

$p
```
public static IPattern $p(ISymbol symbol)
```
Create a Pattern[] 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,
                                   boolean zeroArgsAllowed)
```
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.

zeroArgsAllowed - if true 0 argument sequences are allowed for this pattern

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 or create a global symbol which is retrieved from the global symbols map or created or retrieved from the thread local variables map.

Parameters:

symbolName - the name of the symbol

Returns:

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

Parameters:

symbolName - the name of the symbol

setEval - if true determine and assign the built-in evaluator object to the symbol.

Returns:

retrieveSymbol
```
public static ISymbol retrieveSymbol(java.lang.String symbolName)
```
Get or create a symbol which is retrieved from the eval engines context path.

Parameters:

symbolName - the name of the symbol

Returns:

the symbol object from the context path

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()
```

And

public static IAST And(IExpr a0,
                       IExpr a1)

Alternatives

public static IAST Alternatives(IExpr... a)

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.

headAST0
```
public static final IAST headAST0(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:

binaryAST2

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

Create a function with 2 arguments as a AST2 immutable object 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(IRational re)
```
Create a symbolic complex number

Parameters:

re -

Returns:

complex

public static IComplex complex(IRational re,
                               IRational 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(org.apache.commons.math4.complex.Complex c)

complexNum

public static IComplexNum complexNum(org.apfloat.Apfloat r,
                                     org.apfloat.Apfloat i)

complexNum

public static IComplexNum complexNum(org.apfloat.Apfloat r)

complexNum

public static IComplexNum complexNum(org.apfloat.Apcomplex c)

complexNum

public static IComplexNum complexNum(IComplex value)

complexNum

public static IComplexNum complexNum(IFraction value)

complexNum

public static IComplexNum complexNum(IInteger value)

ChebyshevT

public static IAST ChebyshevT(IExpr a0,
                              IExpr a1)

ChebyshevU

public static IAST ChebyshevU(IExpr a0,
                              IExpr a1)

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... a)

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

DirectedInfinity

public static IAST DirectedInfinity(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)
```
The division a0 / a1 will be represented by Times(a0, Power(a1, -1)).

Parameters:

a0 - numerator

a1 - denominator

Returns:

Divisible

public static IAST Divisible(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)

Element

public static IAST Element(IExpr a0,
                           IExpr a1)

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

Equal

public static IAST Equal(IExpr a0,
                         IExpr a1)

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.evaluate(IExpr)

evalQuiet
```
@Deprecated
public static IExpr evalQuiet(IExpr a)
```
Deprecated. use EvalEngine#evalQuiet();

Evaluate an expression in "quiet mode". If no evaluation was possible this method returns the given argument. In "quiet mode" all warnings would be suppressed.

Parameters:

a - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.evalQuiet(IExpr)

evalQuietNull
```
@Deprecated
public static IExpr evalQuietNull(IExpr a)
```
Deprecated. use EvalEngine#evalQuietNull()

Evaluate an expression in "quiet mode". If evaluation is not possible return null. In "quiet mode" all warnings would be suppressed.

Parameters:

expr - the expression which should be evaluated

Returns:

the evaluated object or F.NIL if no evaluation was possible

See Also:

EvalEngine.evalQuietNull(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)
```
Evaluate Expand() for the given expression. returns the given argument.

Parameters:

a - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

expand
```
public static IExpr expand(IExpr a,
                           boolean expandNegativePowers,
                           boolean distributePlus)
```
Apply Expand() to the given expression if it's an IAST. If expanding wasn't possible this method returns the given argument.

Parameters:

a - the expression which should be evaluated

expandNegativePowers - TODO

distributePlus - TODO

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

evalExpandAll
```
public static IExpr evalExpandAll(IExpr a)
```
Apply ExpandAll() to the given expression if it's an IAST. If expanding wasn't possible this method returns the given argument.

Parameters:

a - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

expandAll
```
public static IExpr expandAll(IExpr a,
                              boolean expandNegativePowers,
                              boolean distributePlus)
```
Apply ExpandAll() to the given expression if it's an IAST. If expanding wasn't possible this method returns the given argument.

Parameters:

a - the expression which should be evaluated

expandNegativePowers - TODO

distributePlus - TODO

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

evaln
```
@Deprecated
public static IExpr evaln(IExpr a0)
```
Deprecated. use EvalEngine.get().evalN() instead

Evaluate the given expression in numeric mode

Parameters:

a0 -

Returns:

evalTrue
```
@Deprecated
public static boolean evalTrue(IExpr expr)
```
Deprecated. use EvalEngine#evalTrue()

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)

Extract

public static IAST Extract(IExpr a0,
                           IExpr a1)

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

Factorial

public static IAST Factorial(IExpr a0)

Factorial2

public static IAST Factorial2(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(org.apache.commons.math4.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 IRational 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)
```

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 IExpr Greater(IExpr a0,
                            IExpr a1)

GreaterEqual

public static IExpr GreaterEqual(IExpr a0,
                                 IExpr a1)

HarmonicNumber

public static IAST HarmonicNumber(IExpr a)

HarmonicNumber

public static IAST HarmonicNumber(IExpr a0,
                                  IExpr a1)

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

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

HoldForm

public static IAST HoldForm(IExpr a0)

HurwitzZeta

public static IAST HurwitzZeta(IExpr a0,
                               IExpr a1)

Identity

public static IAST Identity(IExpr a0)

If

public static IAST If(IExpr a0,
                      IExpr a1)

If

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

If

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

Im
```
public static IExpr 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:

initFinalHiddenSymbol
```
public static ISymbol initFinalHiddenSymbol(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:

initFinalSymbol
```
public static ISymbol initFinalSymbol(java.lang.String symbolName,
                                      IEvaluator evaluator)
```
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:

initPredefinedPattern

public static IPattern initPredefinedPattern(ISymbol symbol)

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

initSymbols

public static void initSymbols(java.io.Reader reader,
                               ISymbolObserver symbolObserver)

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 radix)
```
Create a large integer number.

Parameters:

integerString - the integer number represented as a String

radix - the radix to be used while parsing

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

isNumEqualRational

public static boolean isNumEqualRational(double value,
                                         IRational rational)
                                  throws java.lang.ArithmeticException

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)

LaplaceTransform

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

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 IExpr Less(IExpr a0,
                         IExpr a1)

LessEqual

public static IExpr 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()
```

ListC
```
public static IAST ListC(int capacity)
```
Create a new List with the given capacity.

Parameters:

capacity - the assumed number of arguments (+ 1 for the header expression is added internally).

Returns:

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)

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

local
```
public static ISymbol local(java.lang.String symbolName,
                            IExpr value)
```
Get 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

value -

Returns:

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

Log

public static IAST Log(IExpr a0,
                       IExpr a1)

Log10
```
public static IAST Log10(IExpr a0)
```
Returns:

Log[10, 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)

MessageName

public static IAST MessageName(IExpr a0,
                               IExpr a1)

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 IExpr Negate(IExpr x)
```
Multiplies the given argument by -1. The IExpr#negate() method does evaluations, which don't agree with pattern matching assumptions (in left-hand-sige expressions). so it is only called called for INumber objects, otherwis a Times(CN1, x) AST would be created.

Parameters:

x - the expression which should be negated.

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:

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

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 value)

num

public static INum num(IInteger value)

num
```
public static INum num(java.lang.String valueString)
```
Create a numeric value from the input string.

Parameters:

valueString - the numeric value represented as a string.

Returns:

num

public static INum num(org.apfloat.Apfloat af)

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

Numerator

public static IAST Numerator(IExpr a0)

NumericQ

public static IAST NumericQ(IExpr a0)

O
```
public static IAST O(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()
```

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(long num,
                        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)

PolynomialQuotientRemainder

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

Position

public static IAST Position(IExpr a0,
                            IExpr a1)

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(IExpr a0,
                         IExpr a1)

Power

public static IExpr 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)

ProductLog

public static IAST ProductLog(IExpr a0)

ProductLog

public static IAST ProductLog(IExpr a0,
                              IExpr a1)

QQ
```
public static IFraction QQ(org.apache.commons.math4.fraction.BigFraction frac)
```
Create a "fractional" number

Parameters:

numerator - numerator of the fractional number

fDenominator - denumerator of the fractional number

Returns:

IFraction

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 IExpr Re(IExpr a0)
```

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

Refine

public static IAST Refine(IExpr a0,
                          IExpr a1)

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)

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

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

Resultant

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

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

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

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

Roots

public static IAST Roots(IExpr a0,
                         IExpr a1)

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

RowReduce

public static IAST RowReduce(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)

Series

public static IAST Series(IExpr... a)

SeriesData

public static IAST SeriesData(IExpr... a)

SetAttributes

public static IAST SetAttributes(IExpr a0)

SetAttributes

public static IAST SetAttributes(IExpr a0,
                                 IExpr a1)

Set

public static IAST Set(IExpr a0,
                       IExpr a1)

IInit

public static IAST IInit(ISymbol sym,
                         int[] sizes)

ISet
```
public static IAST ISet(IExpr lhs,
                        IExpr rhs)
```
Assign the evaluated rhs to the lhs.
Note: this method returns null.

Parameters:

lhs - left-hand-side of the assignment

rhs - right-hand-side of the assignment

Returns:

null

SetDelayed

public static IAST SetDelayed(IExpr a0,
                              IExpr a1)

ISetDelayed
```
public static IAST ISetDelayed(IExpr lhs,
                               IExpr rhs)
```
Assign the unevaluated rhs to the lhs.
Note: this method returns null.

Parameters:

lhs - left-hand-side of the assignment

rhs - right-hand-side of the assignment

Returns:

null

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)
```

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

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

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

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

Solve

public static IAST Solve(IExpr a0,
                         IExpr a1)

Sort

public static IAST Sort(IExpr a0,
                        IExpr a1)

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

Sqr
```
public static IAST Sqr(IExpr x)
```
Create a "square" expression: Power(x, 2).

Parameters:

x -

Returns:

Sqrt
```
public static IAST Sqrt(IExpr x)
```
Create a "square root" expression: Power(x, 1/2).

Parameters:

x -

Returns:

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

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,
                          IExpr subExpr,
                          IExpr replacementExpr)
```
Substitute all (sub-) expressions with the given replacement expression. If no (sub-) expression matches, the method returns the given expr.

Parameters:

expr -

subExpr -

replacementExpr -

Returns:

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

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

Parameters:

expr -

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:

expr -

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.

Subfactorial

public static IAST Subfactorial(IExpr a0)

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)

ternaryAST3

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

Create a function with 3 arguments as a AST3 immutable object without evaluation.

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

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(long num,
                         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:

unaryAST1

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

Create a function with 1 argument as a AST1 immutable object 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)

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

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:

chopNumber
```
public static INumber chopNumber(INumber arg,
                                 double delta)
```
Set real or imaginary parts of a numeric argument to zero, those absolute value is less than a delta.

Parameters:

arg - a numeric number

delta - the delta for which

Returns:

arg if the argument couldn't be chopped

chopExpr

public static IExpr chopExpr(IExpr arg,
                             double delta)

AppellF1

public static IAST AppellF1(IExpr... a)

CosIntegral

public static IAST CosIntegral(IExpr a)

EllipticE

public static IAST EllipticE(IExpr a0,
                             IExpr a1)

EllipticF

public static IAST EllipticF(IExpr a0,
                             IExpr a1)

EllipticPi

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

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

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

HypergeometricPFQ

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

Hypergeometric2F1

public static IAST Hypergeometric2F1(IExpr a0,
                                     IExpr a1,
                                     IExpr a2,
                                     IExpr a3)

SinIntegral

public static IAST SinIntegral(IExpr a)

CoshIntegral

public static IAST CoshIntegral(IExpr a)

SinhIntegral

public static IAST SinhIntegral(IExpr a)

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

ExpIntegralEi

public static IAST ExpIntegralEi(IExpr a)

LogIntegral

public static IAST LogIntegral(IExpr a)

PolyLog

public static IAST PolyLog(IExpr a0,
                           IExpr a1)

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

LogGamma

public static IAST LogGamma(IExpr a0)

Zeta

public static IAST Zeta(IExpr a0,
                        IExpr a1)

PolyGamma

public static IAST PolyGamma(IExpr a0)

PolyGamma

public static IAST PolyGamma(IExpr a0,
                             IExpr a1)

ExpIntegralE

public static IAST ExpIntegralE(IExpr a0,
                                IExpr a1)

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

HIDDEN_SYMBOLS_MAP

SYMBOL_OBSERVER

NIL

Catalan

ComplexInfinity

Degree

E

EulerGamma

Glaisher

GoldenRatio

I

Infinity

Khinchin

Pi

Aborted

Assumptions

Begin

BeginPackage

End

EndPackage

Except

IntegerHead

SymbolHead

RealHead

PatternHead

BlankHead

StringHead

MethodHead

PatternTest

Colon

Repeated

RepeatedNull

Algebraics

Booleans

Complexes

Integers

Primes

Rationals

Reals

False

Alternatives

Direction

List

True

Null

Second

Indeterminate

Listable

Constant

NumericFunction

Orderless

OneIdentity

Flat

HoldFirst

HoldRest

HoldAll

NHoldFirst

NHoldRest

NHoldAll

Line

BoxRatios

Modulus

MeshRange

PlotRange

AxesStyle

Automatic

AxesOrigin

Axes

Background

White