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

```
public class F
extends S
```
Factory for creating Symja predefined function expression objects (interface IAST).

Field Summary

Fields
Modifier and Type	Field	Description
`static IPattern`	`a_`	Used to represent a formal pattern `a_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`A_`
`static IPattern`	`a_DEFAULT`
`static IPattern`	`A_DEFAULT`
`static IPattern`	`a_Symbol`
`static IPattern`	`b_`	Used to represent a formal pattern `b_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`B_`
`static IPattern`	`b_DEFAULT`
`static IPattern`	`B_DEFAULT`
`static IPattern`	`b_Symbol`
`static IPattern`	`c_`	Used to represent a formal pattern `c_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`C_`
`static IPattern`	`c_DEFAULT`
`static IPattern`	`C_DEFAULT`
`static IPattern`	`c_Symbol`
`static IInteger`	`C0`	Constant integer "0"
`static IInteger`	`C1`	Constant integer "1"
`static IInteger`	`C10`	Constant integer "10"
`static IInteger`	`C100`	Constant integer "100"
`static IInteger`	`C1000`	Constant integer "1000"
`static IFraction`	`C1D2`	Constant fraction "1/2"
`static IFraction`	`C1D3`	Constant fraction "1/3"
`static IFraction`	`C1D4`	Constant fraction "1/4"
`static IFraction`	`C1D5`	Constant fraction "1/5"
`static IFraction`	`C1D6`	Constant fraction "1/6"
`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 IInteger`	`C2`	Constant integer "2"
`static IFraction`	`C2D3`	Constant fraction "2/3"
`static IAST`	`C2Pi`	Represents `2*Pi` as Symja expression `Times(C2, Pi)`
`static IInteger`	`C3`	Constant integer "3"
`static IFraction`	`C3D2`	Constant fraction "3/2"
`static IFraction`	`C3D4`	Constant fraction "3/4"
`static IInteger`	`C4`	Constant integer "4"
`static IInteger`	`C5`	Constant integer "5"
`static IFraction`	`C5D2`	Constant fraction "5/2"
`static IInteger`	`C6`	Constant integer "6"
`static IInteger`	`C7`	Constant integer "7"
`static IInteger`	`C8`	Constant integer "8"
`static IInteger`	`C9`	Constant integer "9"
`static IAST`	`CComplexInfinity`	Represents `ComplexInfinity` (i.e.
`static Num`	`CD0`	Constant double "0.0"
`static Num`	`CD1`	Constant double "1.0"
`static IComplexNum`	`CDI`	Complex numerical imaginary unit.
`static IComplexNum`	`CDNI`	Complex negative numerical imaginary unit.
`static IAST`	`CEmptyInterval`	Represents `Interval()` (i.e.
`static IAST`	`CEmptyIntervalData`	Represents `Interval()` (i.e.
`static IAST`	`CEmptyList`	Represents `List()` (i.e.
`static IAST`	`CEmptySequence`	Represents `Sequence()` (i.e.
`static IStringX`	`CEmptyString`	Represents the empty Smyja string `""`
`static IComplex`	`CI`	Complex imaginary unit "0 + I".
`static IAST`	`CIInfinity`	Represents `I*Infinity` (i.e.
`static IAST`	`CInfinity`	Represents `Infinity` (i.e.
`static IAST`	`CListC0`	Represents `List(0)`
`static IAST`	`CListC0C0`	Represents `List(0,0)`
`static IAST`	`CListC1`	Represents `List(1)`
`static IAST`	`CListC1C1`	Represents `List(1,1)`
`static IAST`	`CListC1C2`	Represents `List(1,2)`
`static IAST`	`CListC2`	Represents `List(2)`
`static IAST`	`CListC2C1`	Represents `List(2,1)`
`static IAST`	`CListC2C2`	Represents `List(2,2)`
`static IAST`	`CListCN1`	Represents `List(-1)`.
`static IAST`	`CMissingNotFound`	Represents `Missing("NotFound")`
`static IInteger`	`CN1`	Constant integer "-1"
`static IInteger`	`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 IFraction`	`CN1D5`	Constant fraction "-1/5"
`static IFraction`	`CN1D6`	Constant fraction "-1/6"
`static IInteger`	`CN2`	Constant integer "-2"
`static IFraction`	`CN2D3`	Constant fraction "-2/3"
`static IAST`	`CN2Pi`	Represents `-2*Pi` as Symja expression `Times(CN2, Pi)`
`static IInteger`	`CN3`	Constant integer "-3"
`static IFraction`	`CN3D2`	Constant fraction "-3/2"
`static IInteger`	`CN4`	Constant integer "-4"
`static IInteger`	`CN5`	Constant integer "-5"
`static IInteger`	`CN6`	Constant integer "-6"
`static IInteger`	`CN7`	Constant integer "-7"
`static IInteger`	`CN8`	Constant integer "-8"
`static IInteger`	`CN9`	Constant integer "-9"
`static Num`	`CND1`	Constant double "-1.0"
`static IComplex`	`CNI`	Complex negative imaginary unit "0 - I".
`static IAST`	`CNIInfinity`	Represents `-I*Infinity` (i.e.
`static IAST`	`CNInfinity`	Represents `-Infinity` (i.e.
`static IAST`	`CNPi`	Represents `-Pi` as Symja expression `Times(CN1, Pi)`
`static IAST`	`CNPiHalf`	Represents `-Pi/2` as Symja expression `Times(CN1D2, Pi)`
`static IAST`	`CNPiQuarter`	Represents `-Pi/4` as Symja expression `Times(CN1D4, Pi)`
`static IAST`	`CNPiThird`	Represents `-Pi/3` as Symja expression `Times(CN1D3, Pi)`
`static IAST`	`CPiHalf`	Represents `Pi/2` as Symja expression `Times(C1D2, Pi)`
`static IAST`	`CPiQuarter`	Represents `Pi/4` as Symja expression `Times(C1D4, Pi)`
`static IAST`	`CPiThird`	Represents `Pi/3` as Symja expression `Times(C1D3, Pi)`
`static IAST`	`CReturnFalse`	Represents `Return(False)`
`static IAST`	`CReturnTrue`	Represents `Return(True)`
`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 IAST`	`CSqrtPi`	Represents `Sqrt(Pi)`
`static IAST`	`CThrowFalse`	Represents `Throw(False)`
`static IAST`	`CThrowTrue`	Represents `Throw(True)`
`static IPattern`	`d_`	Used to represent a formal pattern `d_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`d_DEFAULT`
`static IPattern`	`d_Symbol`
`static List<ISymbol>`	`DENOMINATOR_NUMERATOR_SYMBOLS`
`static List<IExpr>`	`DENOMINATOR_TRIG_TRUE_EXPRS`
`static IPattern`	`e_`	Used to represent a formal pattern `e_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`e_DEFAULT`
`static IPattern`	`e_Symbol`
`static org.hipparchus.Field<IExpr>`	`EXPR_FIELD`
`static IPattern`	`f_`	Used to represent a formal pattern `f_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`F_`
`static IPattern`	`f_DEFAULT`
`static IPattern`	`F_DEFAULT`
`static IPattern`	`f_Symbol`
`static IPattern`	`g_`	Used to represent a formal pattern `g_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`G_`
`static IPattern`	`g_DEFAULT`
`static IPattern`	`G_DEFAULT`
`static IPattern`	`g_Symbol`
`static IPattern`	`h_`	Used to represent a formal pattern `h_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`h_DEFAULT`
`static IPattern`	`h_Symbol`
`static IPattern`	`i_`	Used to represent a formal pattern `i_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`i_DEFAULT`
`static IPattern`	`i_Symbol`
`static AbstractAST.NILPointer`	`INVALID`
`static IPattern`	`j_`	Used to represent a formal pattern `j_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`j_DEFAULT`
`static IPattern`	`j_Symbol`
`static IPattern`	`k_`	Used to represent a formal pattern `k_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`k_DEFAULT`
`static IPattern`	`k_Symbol`
`static IPattern`	`l_`	Used to represent a formal pattern `l_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`l_DEFAULT`
`static IPattern`	`l_Symbol`
`static IPattern`	`m_`	Used to represent a formal pattern `m_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`m_DEFAULT`
`static IPattern`	`m_Integer`
`static IPattern`	`m_Symbol`
`static IPattern`	`n_`	Used to represent a formal pattern `n_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`n_DEFAULT`
`static IPattern`	`n_Integer`
`static IPattern`	`n_Symbol`
`static AbstractAST.NILPointer`	`NIL`	The constant object `NIL` (not in list) indicates in the evaluation process that no evaluation was possible (i.e.
`static IAST`	`Noo`	Alias for CNInfinity.
`static List<ISymbol>`	`NUMERATOR_NUMERATOR_SYMBOLS`
`static List<IExpr>`	`NUMERATOR_TRIG_TRUE_EXPRS`
`static IPattern`	`o_`	Used to represent a formal pattern `o_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`o_DEFAULT`
`static IPattern`	`o_Symbol`
`static IAST`	`oo`	Alias for CInfinity.
`static IPattern`	`p_`	Used to represent a formal pattern `p_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`P_`
`static IPattern`	`p_DEFAULT`
`static IPattern`	`P_DEFAULT`
`static IPattern`	`p_Symbol`
`static Map<String,String>`	`PREDEFINED_INTERNAL_FORM_STRINGS`	The map for predefined strings for the `IExpr.internalFormString(boolean, int)` method.
`static IPattern`	`q_`	Used to represent a formal pattern `q_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`Q_`
`static IPattern`	`q_DEFAULT`
`static IPattern`	`Q_DEFAULT`
`static IPattern`	`q_Symbol`
`static IPattern`	`r_`	Used to represent a formal pattern `r_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`r_DEFAULT`
`static IPattern`	`r_Symbol`
`static com.google.common.cache.Cache<IAST,IExpr>`	`REMEMBER_INTEGER_CACHE`	In computing, memoization or memoisation is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.
`static IPattern`	`s_`	Used to represent a formal pattern `s_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`s_DEFAULT`
`static IPattern`	`s_Symbol`
`static IAST`	`Slot1`	Represents `#1`, the first argument of a pure function.
`static IAST`	`Slot2`	Represents `#2`, the second argument of a pure function.
`static IAST`	`Slot3`	Represents `#3`, the third argument of a pure function.
`static ISymbolObserver`	`SYMBOL_OBSERVER`
`static IPattern`	`t_`	Used to represent a formal pattern `t_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`t_DEFAULT`
`static IPattern`	`t_Symbol`
`static IPattern`	`u_`	Used to represent a formal pattern `u_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`u_DEFAULT`
`static IPattern`	`u_Symbol`
`static IPattern`	`v_`	Used to represent a formal pattern `v_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`v_DEFAULT`
`static IPattern`	`v_Symbol`
`static IPattern`	`w_`	Used to represent a formal pattern `w_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPattern`	`w_DEFAULT`
`static IPattern`	`w_Symbol`
`static IPattern`	`x_`	Used to represent a formal pattern `x_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPatternSequence`	`x__`	Used to represent a formal pattern sequence `x__` that will be used only for predefined pattern-matching rules and can match any sequence of one or more expressions.
`static IPatternSequence`	`x___`	Used to represent a formal null pattern sequence `x___` that will be used only for predefined pattern-matching rules and can match any sequence of zero or more expressions.
`static IPattern`	`x_DEFAULT`
`static IPattern`	`x_Symbol`
`static IPattern`	`y_`	Used to represent a formal pattern `y_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPatternSequence`	`y__`	Used to represent a formal pattern sequence `y__` that will be used only for predefined pattern-matching rules and can match any sequence of one or more expressions.
`static IPatternSequence`	`y___`	Used to represent a formal null pattern sequence `y___` that will be used only for predefined pattern-matching rules and can match any sequence of zero or more expressions.
`static IPattern`	`y_DEFAULT`
`static IPattern`	`y_Symbol`
`static IPattern`	`z_`	Used to represent a formal pattern `z_` that will be used only for predefined pattern-matching rules and can match one expression.
`static IPatternSequence`	`z__`	Used to represent a formal pattern sequence `z__` that will be used only for predefined pattern-matching rules and can match any sequence of one or more expressions.
`static IPatternSequence`	`z___`	Used to represent a formal null pattern sequence `z___` that will be used only for predefined pattern-matching rules and can match any sequence of zero or more expressions.
`static IPattern`	`z_DEFAULT`
`static IPattern`	`z_Symbol`

Fields inherited from class org.matheclipse.core.expression.S
$Aborted, $Assumptions, $BaseDirectory, $Cancel, $CharacterEncoding, $Context, $ContextPath, $CreationDate, $DisplayFunction, $Failed, $HistoryLength, $HomeDirectory, $IdentityMatrix, $Input, $InputFileName, $IterationLimit, $Line, $MachineEpsilon, $MachinePrecision, $MaxMachineNumber, $MessageList, $MinMachineNumber, $Notebooks, $OperatingSystem, $OutputSizeLimit, $Packages, $Path, $PathnameSeparator, $PrePrint, $PreRead, $RecursionLimit, $RootDirectory, $Scaling, $ScriptCommandLine, $SingleEntryMatrix, $SystemCharacterEncoding, $SystemMemory, $TemporaryDirectory, $UserBaseDirectory, $UserName, $Version, a, AASTriangle, Abort, Abs, AbsArg, AbsoluteCorrelation, AbsoluteTime, AbsoluteTiming, Accumulate, AddSides, AddTo, AddToClassPath, AdjacencyMatrix, Adjugate, AiryAi, AiryAiPrime, AiryBi, AiryBiPrime, AlgebraicNumber, Algebraics, All, AllowedHeads, AllowShortContext, AllTrue, Alphabet, Alternatives, AmbientLight, And, AngleVector, Annotation, Annuity, AnnuityDue, AntihermitianMatrixQ, AntiSymmetric, AntisymmetricMatrixQ, AnyTrue, Apart, AppellF1, Append, AppendTo, Apply, ApplySides, ArcCos, ArcCosh, ArcCot, ArcCoth, ArcCsc, ArcCsch, ArcLength, ArcSec, ArcSech, ArcSin, ArcSinh, ArcTan, ArcTanh, Area, Arg, ArgMax, ArgMin, ArithmeticGeometricMean, Array, ArrayDepth, ArrayFlatten, ArrayPad, ArrayPlot, ArrayQ, ArrayReshape, ArrayRules, Arrays, Arrow, Arrowheads, ASATriangle, AspectRatio, AssociateTo, Association, AssociationMap, AssociationQ, AssociationThread, Assuming, Assumptions, ASymbol, AtomQ, Attributes, Automatic, AvogadroConstant, Axes, AxesLabel, AxesOrigin, AxesStyle, Axis, b, Background, Ball, BarChart, BarOrigin, BartlettWindow, BaseDecode, BaseEncode, BaseForm, Beep, Begin, BeginPackage, BeginTestSection, BellB, BellY, BernoulliB, BernoulliDistribution, BernoulliProcess, BernsteinBasis, BesselI, BesselJ, BesselJZero, BesselK, BesselY, BesselYZero, Beta, BetaDistribution, BetaRegularized, BetweennessCentrality, BezierFunction, BinaryDeserialize, BinaryDistance, BinaryRead, BinarySerialize, BinaryWrite, BinCounts, Binomial, BinomialDistribution, BinomialProcess, BioSequence, BioSequenceQ, BioSequenceTranscribe, BioSequenceTranslate, BitLength, Black, BlackmanHarrisWindow, BlackmanNuttallWindow, BlackmanWindow, Blank, BlankNullSequence, BlankSequence, Block, Blue, BohrRadius, Boole, BooleanConvert, BooleanFunction, BooleanMaxterms, BooleanMinimize, BooleanMinterms, BooleanQ, Booleans, BooleanTable, BooleanVariables, Bottom, Boxed, BoxRatios, BoxWhiskerChart, BrayCurtisDistance, Break, Brown, BrownianBridgeProcess, BSplineFunction, BSymbol, Button, Byte, ByteArray, ByteArrayQ, ByteArrayToString, ByteCount, c, C, CanberraDistance, Cancel, CancelButton, CarlsonRC, CarlsonRD, CarlsonRF, CarlsonRG, CarlsonRJ, CarmichaelLambda, CartesianProduct, Cases, Catalan, CatalanNumber, Catch, Catenate, CauchyDistribution, CDF, Ceiling, Center, CenterDot, CentralMoment, CForm, Character, CharacterEncoding, CharacteristicPolynomial, CharacterRange, Characters, ChebyshevT, ChebyshevU, Check, CheckAbort, ChessboardDistance, ChineseRemainder, ChiSquareDistribution, CholeskyDecomposition, Chop, Circle, CircleDot, CirclePoints, CircleTimes, Clear, ClearAll, ClearAttributes, ClebschGordan, Clip, Close, ClosenessCentrality, CMYColor, Coefficient, CoefficientArrays, CoefficientList, CoefficientRules, Cofactor, Collect, CollinearPoints, Colon, ColorData, ColorFunction, Column, Commonest, CompatibleUnitQ, Compile, CompiledFunction, CompilePrint, Complement, CompleteGraph, Complex, Complexes, ComplexExpand, ComplexInfinity, ComplexityFunction, ComplexPlot3D, ComposeList, ComposeSeries, CompositeQ, Composition, CompoundExpression, Condition, ConditionalExpression, Cone, Conjugate, ConjugateTranspose, ConnectedGraphQ, Constant, ConstantArray, ContainsAll, ContainsAny, ContainsExactly, ContainsNone, ContainsOnly, Context, Continue, ContinuedFraction, ContourPlot, Convergents, ConvexHullMesh, CoordinateBoundingBox, CoordinateBounds, CoplanarPoints, CoprimeQ, Correlation, CorrelationDistance, Cos, Cosh, CoshIntegral, CosineDistance, CosIntegral, Cot, Coth, Count, CountDistinct, Counts, Covariance, CreateDirectory, CreateFile, Cross, Csc, Csch, CSymbol, Cube, CubeRoot, Cuboid, Curl, Cyan, CycleGraph, Cycles, Cyclotomic, Cylinder, d, D, Dashed, Dashing, DataRange, Dataset, DateObject, DateString, DateValue, Decrement, DedekindNumber, Default, DefaultButton, DefaultValue, Defer, Definition, Degree, DegreeLexicographic, DegreeReverseLexicographic, Delete, DeleteCases, DeleteDuplicates, DeleteDuplicatesBy, DeleteMissing, Delimiters, Denominator, DensityHistogram, DensityPlot, Depth, Derivative, DesignMatrix, Det, Diagonal, DiagonalMatrix, DiagonalMatrixQ, DialogInput, DialogNotebook, DialogReturn, DiceDissimilarity, DifferenceDelta, Differences, DigitCharacter, DigitCount, DigitQ, Dimensions, DiracDelta, DirectedEdge, DirectedEdges, DirectedInfinity, Direction, DirectionalLight, Directive, DirichletEta, DirichletWindow, DiscreteDelta, DiscretePlot, DiscreteUniformDistribution, Discriminant, DisjointQ, Disk, Dispatch, DisplayForm, DisplayFunction, Disputed, DistanceFunction, Distribute, Distributed, Div, Divide, DivideBy, DivideSides, Divisible, Divisors, DivisorSigma, DivisorSum, Do, Dodecahedron, Dot, DotDashed, Dotted, DownValues, Drop, DSolve, Dt, DuplicateFreeQ, Dynamic, e, E, EasterSunday, Echo, EchoFunction, EdgeCount, EdgeForm, EdgeLabels, EdgeList, EdgeQ, EdgeRules, EdgeShapeFunction, EdgeStyle, EdgeWeight, EditDistance, EffectiveInterest, Eigensystem, Eigenvalues, EigenvectorCentrality, Eigenvectors, Element, ElementData, Eliminate, EliminationOrder, Ellipsoid, EllipticE, EllipticF, EllipticK, EllipticPi, EllipticTheta, End, EndOfFile, EndOfLine, EndOfString, EndPackage, EndTestSection, Entity, Entropy, Equal, EqualTo, Equivalent, Erf, Erfc, Erfi, ErlangDistribution, EuclideanDistance, EulerE, EulerGamma, EulerianGraphQ, EulerPhi, Evaluate, EvenQ, ExactNumberQ, Except, Exists, Exit, Exp, Expand, ExpandAll, Expectation, ExpIntegralE, ExpIntegralEi, Exponent, ExponentialDistribution, Export, ExportString, Expression, ExpToTrig, ExtendedGCD, Extension, Extract, f, f1, f2, f3, f4, Factor, Factorial, Factorial2, FactorialPower, FactorInteger, FactorSquareFree, FactorSquareFreeList, FactorTerms, FactorTermsList, False, Fibonacci, File, FileFormat, FileHash, FileNameJoin, FileNames, FileNameTake, FilePrint, Filling, FillingStyle, FilterRules, FindClusters, FindCycle, FindEdgeCover, FindEulerianCycle, FindFit, FindGraphCommunities, FindGraphIsomorphism, FindHamiltonianCycle, FindIndependentEdgeSet, FindIndependentVertexSet, FindInstance, FindLinearRecurrence, FindMaximum, FindMinimum, FindPermutation, FindRoot, FindShortestPath, FindShortestTour, FindSpanningTree, FindVertexCover, First, FirstCase, FirstPosition, Fit, FittedModel, FiveNum, FixedPoint, FixedPointList, Flat, Flatten, FlattenAt, FlatTopWindow, Float, Floor, Fold, FoldList, For, ForAll, FormBox, Fourier, FourierDCT, FourierDCTMatrix, FourierDST, FourierDSTMatrix, FourierMatrix, FractionalPart, FractionBox, FRatioDistribution, FrechetDistribution, FreeQ, FresnelC, FresnelS, FrobeniusNumber, FrobeniusSolve, FromCharacterCode, FromContinuedFraction, FromDigits, FromLetterNumber, FromPolarCoordinates, FromRomanNumeral, FromSphericalCoordinates, FSymbol, Full, FullForm, FullSimplify, Function, FunctionDomain, FunctionExpand, FunctionRange, FunctionURL, g, Gamma, GammaDistribution, GammaRegularized, Gather, GatherBy, GaussianIntegers, GaussianMatrix, GaussianWindow, GCD, GegenbauerC, General, GenerateConditions, GeodesyData, GeoDistance, GeometricDistribution, GeometricMean, GeometricTransformation, GeoPosition, Get, Glaisher, GoldenAngle, GoldenRatio, GompertzMakehamDistribution, Grad, Graph, GraphCenter, GraphComplement, GraphData, GraphDiameter, GraphDifference, GraphDisjointUnion, Graphics, Graphics3D, Graphics3DJSON, GraphicsComplex, GraphicsGroup, GraphicsJSON, GraphIntersection, GraphPeriphery, GraphQ, GraphRadius, GraphUnion, Gray, GrayLevel, Greater, GreaterEqual, GreaterEqualThan, GreaterThan, Green, GroebnerBasis, GroupBy, GSymbol, Gudermannian, GumbelDistribution, h, HamiltonianGraphQ, HammingDistance, HammingWindow, HankelH1, HankelH2, HannWindow, HarmonicMean, HarmonicNumber, Haversine, Head, Heads, HeavisideTheta, HermiteH, HermitianMatrixQ, HessenbergDecomposition, HexidecimalCharacter, HilbertMatrix, Histogram, HodgeDual, Hold, HoldAll, HoldAllComplete, HoldComplete, HoldFirst, HoldForm, HoldPattern, HoldRest, Horner, HornerForm, Hue, HurwitzLerchPhi, HurwitzZeta, HypercubeGraph, Hyperfactorial, Hypergeometric0F1, Hypergeometric1F1, Hypergeometric1F1Regularized, Hypergeometric2F1, Hypergeometric2F1Regularized, HypergeometricDistribution, HypergeometricPFQ, HypergeometricPFQRegularized, HypergeometricU, i, I, Icosahedron, Identity, IdentityMatrix, If, IgnoreCase, Im, Image, ImageChannels, ImageColorSpace, ImageCrop, ImageData, ImageDimensions, ImageQ, ImageResize, ImageRotate, ImageScaled, ImageSize, ImageType, ImplicitD, Implies, Import, ImportString, In, Increment, Indeterminate, IndexGraph, Inequality, InexactNumberQ, Infinity, Infix, Information, Inherited, Inner, Input, InputField, InputForm, InputStream, InputString, Insert, InsertionFunction, InstallJava, InstanceOf, Integer, IntegerDigits, IntegerExponent, IntegerLength, IntegerName, IntegerPart, IntegerPartitions, IntegerQ, Integers, Integrate, InterpolatingFunction, InterpolatingPolynomial, Interpolation, InterpolationOrder, InterquartileRange, Interrupt, IntersectingQ, Intersection, Interval, IntervalComplement, IntervalData, IntervalIntersection, IntervalMemberQ, IntervalUnion, Inverse, InverseBetaRegularized, InverseCDF, InverseErf, InverseErfc, InverseFourier, InverseFunction, InverseGammaRegularized, InverseGudermannian, InverseHaversine, InverseJacobiCD, InverseJacobiCN, InverseJacobiDC, InverseJacobiDN, InverseJacobiNC, InverseJacobiND, InverseJacobiSC, InverseJacobiSD, InverseJacobiSN, InverseLaplaceTransform, InverseSeries, InverseWeierstrassP, InverseZTransform, IsomorphicGraphQ, j, JaccardDissimilarity, JacobiAmplitude, JacobiCD, JacobiCN, JacobiDC, JacobiDN, JacobiEpsilon, JacobiMatrix, JacobiNC, JacobiND, JacobiP, JacobiSC, JacobiSD, JacobiSN, JacobiSymbol, JacobiZeta, JavaClass, JavaForm, JavaNew, JavaObject, JavaObjectQ, JavaShow, Join, Joined, JSForm, JSFormData, k, KelvinBei, KelvinBer, Key, KeyAbsent, KeyExistsQ, Keys, KeySelect, KeySort, KeyTake, Khinchin, KleinInvariantJ, KnownUnitQ, KolmogorovSmirnovTest, KOrderlessPartitions, KPartitions, KroneckerDelta, KroneckerProduct, Kurtosis, l, Labeled, LabelingFunction, LabelingSize, LaguerreL, LambertW, LaplaceTransform, Large, Last, LCM, LeafCount, LeastSquares, Left, LegendreP, LegendreQ, Length, LengthWhile, LerchPhi, Less, LessEqual, LessEqualThan, LessThan, LetterCharacter, LetterCounts, LetterNumber, LetterQ, Level, LevelQ, LeviCivitaTensor, Lexicographic, LHS_HEAD, LightBlue, LightBrown, LightCyan, LightGray, LightGreen, Lighting, LightMagenta, LightOrange, LightPink, LightPurple, LightRed, LightYellow, Limit, Line, LinearModelFit, LinearOptimization, LinearProgramming, LinearRecurrence, LinearSolve, LinearSolveFunction, LineGraph, LiouvilleLambda, List, Listable, ListContourPlot, ListConvolve, ListCorrelate, ListDensityPlot, ListLinePlot, ListLinePlot3D, ListLogLinearPlot, ListLogLogPlot, ListLogPlot, ListPlot, ListPlot3D, ListPointPlot3D, ListPolarPlot, ListQ, ListStreamPlot, ListVectorPlot, Literal, LoadJavaClass, Locked, Log, Log10, Log2, LogGamma, LogicalExpand, LogIntegral, LogisticSigmoid, LogLinearPlot, LogLogPlot, LogNormalDistribution, LogPlot, Longest, LongForm, Lookup, LowerCaseQ, LowerTriangularize, LowerTriangularMatrixQ, LucasL, LUDecomposition, m, MachineNumberQ, Magenta, MakeBoxes, MangoldtLambda, ManhattanDistance, Manipulate, MantissaExponent, Map, MapAll, MapAt, MapIndexed, MapThread, MatchingDissimilarity, MatchQ, MathMLForm, Matrices, MatrixD, MatrixExp, MatrixForm, MatrixFunction, MatrixLog, MatrixMinimalPolynomial, MatrixPlot, MatrixPower, MatrixQ, MatrixRank, Max, MaxFilter, Maximize, MaxIterations, MaxMemoryUsed, MaxPoints, Mean, MeanDeviation, MeanFilter, Median, MedianFilter, Medium, MeijerG, MemberQ, MemoryAvailable, MemoryInUse, MersennePrimeExponent, MersennePrimeExponentQ, Mesh, MeshRange, Message, MessageName, Messages, Method, Min, MinFilter, MinimalPolynomial, Minimize, MinMax, Minor, Minors, Minus, Missing, MissingQ, Mod, ModularInverse, Module, Modulus, MoebiusMu, MonomialList, MonomialOrder, Most, Multinomial, MultiplicativeOrder, MultiplySides, n, N, NakagamiDistribution, NameQ, Names, Nand, ND, NDSolve, Nearest, NearestTo, Needs, Negative, NegativeDegreeLexicographic, NegativeDegreeReverseLexicographic, NegativeIntegers, NegativeLexicographic, NegativeRationals, NegativeReals, Nest, NestList, NestWhile, NestWhileList, NewLimit, NextPrime, NFourierTransform, NHoldAll, NHoldFirst, NHoldRest, NIntegrate, NMaximize, NMinimize, NonCommutativeMultiply, None, NoneTrue, Nonexistent, NonNegative, NonNegativeIntegers, NonNegativeRationals, NonNegativeReals, NonPositive, Nor, Norm, Normal, NormalDistribution, Normalize, NormalMatrixQ, Not, NotApplicable, NotAvailable, NotElement, Nothing, NotListQ, Now, NRoots, NSolve, Null, NullSpace, Number, NumberFieldRootsOfUnity, NumberLinePlot, NumberQ, NumberString, Numerator, NumericalOrder, NumericalSort, NumericArray, NumericArrayQ, NumericArrayType, NumericFunction, NumericQ, NuttallWindow, o, O, Octahedron, OddQ, Off, On, OneIdentity, Opacity, OpenAppend, OpenRead, OpenWrite, Operate, OptimizeExpression, Optional, Options, OptionsPattern, OptionValue, Or, Orange, Order, OrderedQ, Ordering, Orderless, Orthogonalize, OrthogonalMatrixQ, Out, Outer, OutputForm, OutputStream, Overflow, Overlaps, Overscript, OverscriptBox, OwnValues, p, Package, PadeApproximant, PadLeft, PadRight, ParallelMap, ParametricPlot, Parenthesis, ParetoDistribution, Part, Partition, PartitionsP, PartitionsQ, ParzenWindow, PathGraph, PathGraphQ, Pattern, PatternOrder, PatternTest, PauliMatrix, Pause, PDF, PearsonChiSquareTest, PearsonCorrelationTest, PerfectNumber, PerfectNumberQ, Perimeter, PermutationCycles, PermutationCyclesQ, PermutationList, PermutationListQ, PermutationReplace, Permutations, Permute, PetersenGraph, Pi, Pick, Piecewise, PiecewiseExpand, PieChart, Pink, PlanarGraph, PlanarGraphQ, Plot, Plot3D, PlotLegends, PlotRange, PlotStyle, Plus, PlusMinus, Pochhammer, Point, PointLight, PointSize, PoissonDistribution, PoissonProcess, PolarPlot, PolyGamma, Polygon, PolygonalNumber, Polyhedron, PolyLog, PolynomialExtendedGCD, PolynomialGCD, PolynomialLCM, PolynomialQ, PolynomialQuotient, PolynomialQuotientRemainder, PolynomialRemainder, Position, Positive, PositiveIntegers, PositiveRationals, PositiveReals, PossibleZeroQ, Postfix, Power, PowerExpand, PowerMod, PrecedenceForm, Precision, PrecisionGoal, PreDecrement, Prefix, PreIncrement, Prepend, PrependTo, Prime, PrimeOmega, PrimePi, PrimePowerQ, PrimeQ, Primes, PrimitiveRoot, PrimitiveRootList, PrincipalComponents, Print, PrintableASCIIQ, Prism, Probability, Product, ProductLog, Projection, Protect, Protected, PseudoInverse, PSymbol, Purple, Put, Pyramid, q, QRDecomposition, QSymbol, QuadraticIrrationalQ, Quantile, Quantity, QuantityDistribution, QuantityMagnitude, QuantityQ, QuantityUnit, QuarticSolve, Quartiles, Quiet, Quit, Quotient, QuotientRemainder, r, RadicalBox, Ramp, RamseyNumber, RandomChoice, RandomComplex, RandomGraph, RandomInteger, RandomPermutation, RandomPrime, RandomReal, RandomSample, RandomVariate, Range, RankedMax, RankedMin, Rational, Rationalize, Rationals, RawBoxes, Re, Read, ReadList, ReadProtected, ReadString, Real, RealAbs, RealDigits, Reals, RealSign, RealValuedNumberQ, RealValuedNumericQ, Reap, Record, RecordSeparators, Rectangle, Red, Reduce, Refine, RegularExpression, ReIm, ReleaseHold, Remove, RemoveDiacritics, Repeated, RepeatedNull, RepeatedTiming, Replace, ReplaceAll, ReplaceList, ReplacePart, ReplaceRepeated, Rescale, Rest, Resultant, Return, Reverse, RGBColor, RiccatiSolve, Riffle, Right, RightComposition, RogersTanimotoDissimilarity, RomanNumeral, Root, RootIntervals, RootOf, RootReduce, Roots, RotateLeft, RotateRight, RotationMatrix, RotationTransform, Round, Row, RowBox, RowReduce, RSolve, RSolveValue, Rule, RuleDelayed, RussellRaoDissimilarity, s, SameObjectQ, SameQ, SameTest, SASTriangle, SatisfiabilityCount, SatisfiabilityInstances, SatisfiableQ, SawtoothWave, Scale, Scaled, ScalingFunctions, ScalingTransform, Scan, SchurDecomposition, Sec, Sech, Second, SeedRandom, Select, SelectFirst, SemanticImport, SemanticImportString, Sequence, SequenceCases, SequenceHold, SequenceReplace, SequenceSplit, Series, SeriesCoefficient, SeriesData, Set, SetAttributes, SetDelayed, SetSystemOptions, Share, ShearingTransform, Short, Shortest, Show, Sign, Signature, SignCmp, Simplex, Simplify, Sin, Sinc, SingularValueDecomposition, SingularValueList, Sinh, SinhIntegral, SinIntegral, SixJSymbol, Skewness, Slot, SlotAbsent, SlotSequence, Small, SokalSneathDissimilarity, Solve, Sort, SortBy, Sow, Span, SparseArray, Specularity, Sphere, SphericalBesselJ, SphericalBesselY, SphericalHankelH1, SphericalHankelH2, SphericalHarmonicY, Split, SplitBy, SpotLight, Sqrt, SqrtBox, SquaredEuclideanDistance, SquareFreeQ, SquareMatrixQ, SSSTriangle, Stack, StackBegin, StandardDeviation, StandardForm, Standardize, StarGraph, StartOfLine, StartOfString, StaticsVisible, StieltjesGamma, StirlingS1, StirlingS2, StreamPlot, Strict, String, StringCases, StringContainsQ, StringCount, StringDrop, StringExpression, StringForm, StringFormat, StringFreeQ, StringInsert, StringJoin, StringLength, StringMatchQ, StringPart, StringPosition, StringQ, StringRepeat, StringReplace, StringReverse, StringRiffle, StringSplit, StringTake, StringTemplate, StringToByteArray, StringToStream, StringTrim, Structure, StruveH, StruveL, StudentTDistribution, Style, StyleForm, Subdivide, Subfactorial, Subscript, SubscriptBox, SubsetQ, Subsets, Subsuperscript, SubsuperscriptBox, Subtract, SubtractFrom, SubtractSides, Sum, Summary, Superscript, SuperscriptBox, Surd, SurfaceArea, SurfaceGraphics, SurvivalFunction, Switch, Symbol, SymbolName, SymbolQ, Symmetric, SymmetricMatrixQ, SyntaxLength, SyntaxQ, SystemDialogInput, SystemOptions, t, Table, TableAlignments, TableDepth, TableDirections, TableForm, TableHeadings, TableSpacing, TagSet, TagSetDelayed, Take, TakeLargest, TakeLargestBy, TakeSmallest, TakeSmallestBy, TakeWhile, Tally, Tan, Tanh, TargetFunctions, TautologyQ, Taylor, TemplateApply, TemplateExpression, TemplateIf, TemplateSlot, TensorDimensions, TensorProduct, TensorRank, TensorSymmetry, TestID, TestReport, TestReportObject, TestResultObject, Tetrahedron, TeXForm, Text, TextCell, TextElement, TextString, TextStructure, Thickness, Thread, ThreeJSymbol, Through, Throw, Ticks, TicksStyle, TimeConstrained, TimeObject, TimeRemaining, Times, TimesBy, TimeValue, Timing, Tiny, ToBoxes, ToCharacterCode, Today, ToeplitzMatrix, ToExpression, Together, ToIntervalData, ToLowerCase, TooLarge, Top, ToPolarCoordinates, ToRadicals, ToSphericalCoordinates, ToString, Total, ToUnicode, ToUpperCase, Tr, Trace, TraceForm, TraditionalForm, TransformationFunction, TranslationTransform, Transliterate, Transpose, TreeForm, Triangle, Trig, TrigExpand, TrigReduce, TrigSimplifyFu, TrigToExp, True, TrueQ, TTest, Tube, TukeyWindow, Tuples, TwoWayRule, u, Undefined, Underflow, Underoverscript, UnderoverscriptBox, Underscript, UnderscriptBox, UndirectedEdge, Unequal, UnequalTo, Unevaluated, UniformDistribution, Union, Unique, UnitaryMatrixQ, UnitConvert, Unitize, UnitStep, UnitTriangle, UnitVector, UniverseAge, Unknown, Unprotect, UnsameQ, Unset, UpperCaseQ, UpperTriangularize, UpperTriangularMatrixQ, UpSet, UpSetDelayed, UpTo, UpValues, URLFetch, UseTypeChecking, v, ValueQ, Values, VandermondeMatrix, Variable, Variables, Variance, VectorAngle, VectorGreater, VectorGreaterEqual, VectorLess, VectorLessEqual, VectorPlot, VectorQ, Vectors, Verbatim, VerificationTest, VertexEccentricity, VertexLabels, VertexList, VertexQ, VertexShapeFunction, VertexSize, VertexStyle, ViewPoint, Volume, w, WeaklyConnectedGraphQ, WeberE, WeibullDistribution, WeierstrassHalfPeriods, WeierstrassInvariants, WeierstrassP, WeierstrassPPrime, WeightedAdjacencyMatrix, WeightedData, WeightedGraphQ, WheelGraph, Which, While, White, Whitespace, WhitespaceCharacter, WhittakerM, WhittakerW, With, Word, WordBoundary, WordCharacter, WordSeparators, Write, WriteString, x, Xnor, Xor, y, Yellow, YuleDissimilarity, z, ZeroSymmetric, ZeroTest, Zeta, ZTransform

Constructor Summary

Constructors
Constructor Description

F()

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static IASTMutable`	`$(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)`	Create a `Blank[condition]` pattern object for pattern-matching and term rewriting
`static PatternSequence`	`$bns(IExpr condition)`	Create a `BlankNullSequence[condition]` pattern object for pattern-matching and term rewriting
`static PatternSequence`	`$bs(IExpr condition)`	Create a `BlankSequence[condition]` pattern object for pattern-matching and term rewriting
`static IPatternSequence`	`$OptionsPattern()`
`static IPatternSequence`	`$OptionsPattern(ISymbol symbol)`
`static IPatternSequence`	`$OptionsPattern(ISymbol symbol, IExpr defaultOptions)`
`static IPattern`	`$p(String symbolName)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(String symbolName, boolean def)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(String symbolName, IExpr check)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(String symbolName, IExpr check, boolean def)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol)`	Create a `Pattern[]` pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol, boolean matchDefaultValue)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol, IExpr headerCheck)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`$p(ISymbol symbol, IExpr headerCheck, boolean matchDefaultValue)`	Create a pattern for pattern-matching and term rewriting
`static IPatternSequence`	`$ps(String symbolName)`	Create a pattern for pattern-matching and term rewriting
`static IPatternSequence`	`$ps(ISymbol symbol)`	Create a new PatternSequence `BlankSequence`.
`static IPatternSequence`	`$ps(ISymbol symbol, boolean zeroArgsAllowed)`	Create a new PatternSequence `BlankSequence` or `BlankNullSequence`.
`static IPatternSequence`	`$ps(ISymbol symbol, IExpr check)`	Create a new PatternSequence `BlankSequence` or `BlankNullSequence`.
`static IPatternSequence`	`$ps(ISymbol symbol, IExpr check, boolean def, boolean zeroArgsAllowed)`	Create a new PatternSequence `BlankSequence` or `BlankNullSequence`.
`static IPatternSequence`	`$Repeated(IExpr patternExpr, int min, int max, EvalEngine engine)`
`static ISymbol`	`$rubi(String symbolName)`
`static ISymbol`	`$rubi(String symbolName, IEvaluator evaluator)`
`static ISymbol`	`$s(String symbolName)`	Get or create a global predefined symbol which is retrieved from the SYSTEM context map or created or retrieved from the SYSTEM context variables map.
`static IStringX`	`$str(char ch)`
`static IStringX`	`$str(String str)`	Create a string expression
`static IStringX`	`$str(String str, short mimeType)`
`static IAST`	`Abs(IExpr z)`
`static IAST`	`AbsoluteCorrelation(IExpr a0, IExpr a1)`
`static IASTMutable`	`AddSides(IExpr equationOrInequality, IExpr a1)`
`static IAST`	`AiryAi(IExpr a0)`
`static IAST`	`AiryAiPrime(IExpr a0)`
`static IAST`	`AiryBi(IExpr a0)`
`static IAST`	`AiryBiPrime(IExpr a0)`
`static int`	`allocLevel1(IAST ast, Predicate<IExpr> predicate)`	Calulate the allocation size for a new `IAST` object.
`static int`	`allocMax16(IAST ast)`	Determine the maximum of the `ast` `IAST.argSize()` and integer number 15,
`static int`	`allocMax32(IAST ast)`	Determine the maximum of the `ast` `IAST.argSize()` and integer number 31,
`static int`	`allocMax64(IAST ast)`	Determine the maximum of the `ast` `IAST.argSize()` and integer number 63,
`static int`	`allocMax8(IAST ast)`	Determine the maximum of the `ast` `IAST.argSize()` and integer number 7,
`static int`	`allocMin16(int size)`	Determine the minimum of the `size` and integer number 15
`static int`	`allocMin16(IAST ast)`	Determine the minimum of the `ast` `IAST.argSize()` and integer number 15
`static int`	`allocMin32(int size)`	Determine the minimum of the `size` and integer number 31
`static int`	`allocMin32(IAST ast)`	Determine the minimum of the `ast` `IAST.argSize()` and integer number 31,
`static int`	`allocMin64(IAST ast)`	Determine the minimum of the `ast` `IAST.argSize()` and integer number 63,
`static int`	`allocMin8(int size)`	Determine the minimum of the `size` and integer number 7
`static int`	`allocMin8(IAST ast)`	Determine the minimum of the `ast` `IAST.argSize()` and integer number 7
`static IAST`	`Alternatives(IExpr... a)`
`static IASTMutable`	`AmbientLight(IExpr color)`
`static IExpr`	`and(Integer i, IExpr b)`
`static IExpr`	`and(BigInteger i, IExpr b)`
`static IExpr`	`and(IExpr a, Integer i)`
`static IExpr`	`and(IExpr a, BigInteger i)`
`static IASTAppendable`	`And()`
`static IAST`	`And(IExpr... expr)`	`expr1 && expr2 && expr3 ...` evaluates each expression in turn, returning `S.False` as soon as an expression evaluates to `S.False`.
`static IAST`	`And(IExpr expr1, IExpr expr2)`	`expr1 && expr2` evaluates each expression in turn, returning `S.False` as soon as an expression evaluates to `S.False`.
`static IAST`	`And(IExpr expr1, IExpr expr2, IExpr expr3)`	`expr1 && expr2 && expr3` evaluates each expression in turn, returning `S.False` as soon as an expression evaluates to `S.False`.
`static IAST`	`AngleVector(IExpr a0)`
`static IAST`	`AntiSymmetric(IExpr a0)`
`static IAST`	`Apart(IExpr a0)`
`static IAST`	`Apart(IExpr a0, IExpr a1)`
`static IAST`	`AppellF1(IExpr a, IExpr b1, IExpr b2, IExpr c, IExpr z1, IExpr z2)`
`static IAST`	`Append(IExpr a0, IExpr a1)`
`static IAST`	`AppendTo(IExpr a0, IExpr a1)`
`static IASTMutable`	`Apply(IExpr a0, IExpr a1)`	Operator `@@`
`static IASTMutable`	`ApplyListC1(IExpr a0, IExpr a1)`	Operator `@@@`
`static IASTMutable`	`ApplySides(IExpr a0, IExpr equationOrInequality)`
`static IAST`	`ArcCos(IExpr z)`
`static IAST`	`ArcCosh(IExpr z)`
`static IAST`	`ArcCot(IExpr z)`
`static IAST`	`ArcCoth(IExpr z)`
`static IAST`	`ArcCsc(IExpr z)`
`static IAST`	`ArcCsch(IExpr z)`
`static IAST`	`ArcSec(IExpr z)`
`static IAST`	`ArcSech(IExpr z)`
`static IAST`	`ArcSin(IExpr z)`
`static IAST`	`ArcSinh(IExpr z)`
`static IAST`	`ArcTan(IExpr z)`
`static IAST`	`ArcTan(IExpr x, IExpr y)`
`static IAST`	`ArcTanh(IExpr z)`
`static IAST`	`Arg(IExpr z)`
`static IAST`	`ArithmeticGeometricMean(IExpr a0, IExpr a1)`
`static IAST`	`Array(IExpr a0, IExpr a1)`
`static IAST`	`ArrayQ(IExpr a0)`	'ArrayQ(expr)
`static IAST`	`Arrays(IAST dimension)`	The domain of arrays.
`static IAST`	`Arrays(IAST dimension, ISymbol domain)`	The domain of arrays.
`static IAST`	`Arrays(IAST dimension, ISymbol domain, IAST symmetry)`	The domain of arrays.
`static IAST`	`Arrays(IExpr a0)`
`static IAST`	`Arrays(IExpr a0, IExpr a1)`
`static IAST`	`Arrays(IExpr a0, IExpr a1, IExpr a2)`
`static IAssociation`	`assoc()`
`static IAssociation`	`assoc(IAssociation templateAssociation, Map<IExpr,IASTMutable> mapOfRules)`	Create an association data structure `<\| x0->y0, x1->y1, ...`
`static IAssociation`	`assoc(IAST listOfRules)`	Create an association data structure `<\| x0->y0, x1->y1, ...`
`static IAST`	`ast(IAST f, IExpr head, boolean include, int first, int last)`	Creates a new AST from the given `ast` and `head`.
`static IASTAppendable`	`ast(IExpr head)`	Create a new abstract syntax tree (AST).
`static IASTAppendable`	`ast(IExpr[] arr, IExpr head)`	Create a new function expression (AST - abstract syntax tree).
`static IASTAppendable`	`ast(IExpr head, int initialCapacity)`	Create a new abstract syntax tree (AST).
`static IASTAppendable`	`ast(IExpr head, int initialCapacity, boolean initNull)`	Deprecated. use `ast(IExpr, int)` or `astMutable(IExpr, int)`
`static IASTAppendable`	`ast(IExpr head, Collection<? extends IExpr> collection)`	Create a new abstract syntax tree (AST).
`static IASTAppendable`	`ast(IExpr head, Collection<? extends IExpr> collection, int initialCapacity)`
`static IASTAppendable`	`ast(ISymbol head, boolean evalComplex, org.hipparchus.complex.Complex[] arr)`	Create a new function expression (AST - abstract syntax tree), where all arguments are Java `ComplexNum` values.
`static IASTAppendable`	`ast(ISymbol head, int[] arr)`	Create a new function expression (AST - abstract syntax tree), where all arguments are Java `int` values.
`static IASTAppendable`	`ast(ISymbol head, org.hipparchus.complex.Complex[] arr)`	Create a new function expression (AST - abstract syntax tree), where all arguments are Java `org.hipparchus.complex.Complex` values.
`static IASTMutable`	`astMutable(IExpr head, int initialCapacity)`	Create a new abstract syntax tree (AST) with pre- allocated elements set to `null`.
`static IAST`	`AtomQ(IExpr a)`	AtomQ(x)
`static IAST`	`Attributes(IExpr a)`
`static void`	`await()`	Causes the current thread to wait until the main initialization has finished.
`static IAST`	`BaseForm(IExpr a0, IExpr a1)`
`static IAST`	`BellB(IExpr a0)`	Bell number.
`static IAST`	`BellB(IExpr a0, IExpr a1)`	Bell polynomial.
`static IAST`	`BellY(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`BernoulliB(IExpr a0)`
`static IAST`	`BernoulliB(IExpr a0, IExpr a1)`
`static IAST`	`BernoulliDistribution(IExpr a0)`
`static IAST`	`BesselI(IExpr a0, IExpr a1)`
`static IAST`	`BesselJ(IExpr a0, IExpr a1)`
`static IAST`	`BesselK(IExpr a0, IExpr a1)`
`static IAST`	`BesselY(IExpr a0, IExpr a1)`
`static IAST`	`Beta(IExpr a0, IExpr a1)`
`static IAST`	`Beta(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`BetaRegularized(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`BetaRegularized(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IASTAppendable`	`binary(IExpr head, IExpr arg1, IExpr arg2)`	Create a function `head(arg1, arg2)` with 2 arguments without evaluation.
`static IASTMutable`	`binaryAST2(IExpr head, String arg1, String arg2)`
`static IASTMutable`	`binaryAST2(IExpr head, String arg1, IExpr arg2)`
`static IASTMutable`	`binaryAST2(IExpr head, IExpr arg1, IExpr arg2)`	Create a function `head(arg1, arg2)` with 2 argument as an `AST2` mutable object without evaluation.
`static IAST`	`Binomial(int a0, int a1)`
`static IAST`	`Binomial(IExpr a0, IExpr a1)`
`static IAST`	`BinomialDistribution(IExpr a0, IExpr a1)`
`static IAST`	`BlankSequence()`
`static IAST`	`Block(IExpr a0, IExpr a1)`
`static ISymbol`	`bool(boolean value)`	Deprecated. use `booleSymbol(boolean)` instead
`static IAST`	`Boole(IExpr a)`
`static IAST`	`BooleanConvert(IExpr a0, IExpr a1)`
`static IAST`	`BooleanMinimize(IExpr a)`
`static IAST`	`BooleanQ(IExpr a)`	BooleanQ(expr)
`static IAST`	`BooleanTable(IExpr a0, IExpr a1)`
`static IAST`	`BooleanVariables(IExpr a0)`
`static IInteger`	`booleInteger(boolean value)`	Returns integers 1 or 0 (type ISymbol) depending on the boolean value `true` or `false`.
`static ISymbol`	`booleSymbol(boolean value)`	Returns symbol "True" or "False" (type ISymbol) depending on the boolean value.
`static IAST`	`Break()`
`static IAST`	`BrownianBridgeProcess(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`C(int index)`
`static IAST`	`Cancel(IExpr a)`
`static IAST`	`CancelButton()`
`static IAST`	`CarlsonRC(IExpr a0, IExpr a1)`
`static IAST`	`CarlsonRD(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`CarlsonRF(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`CarlsonRG(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`CarmichaelLambda(IExpr a0)`
`static IExpr`	`cast(Object obj)`	Converts a given object into a MathEclipse IExpr expression
`static IAST`	`CatalanNumber(IExpr a)`
`static IAST`	`Catch(IExpr a)`
`static IAST`	`CauchyDistribution(IExpr a0, IExpr a1)`
`static IComplex`	`CC(long real, long imag)`	Create a symbolic complex number `real + I * imag`.
`static IComplex`	`CC(long realNumerator, long realDenominator, long imagNumerator, long imagDenominator)`	Create a symbolic complex number `(realNumerator/realDenominator) + I * (imagNumerator/imagDenominator)`
`static IComplex`	`CC(IFraction re)`	Create a symbolic complex number `re + I * 0`
`static IComplex`	`CC(IRational real, IRational imag)`	Create a symbolic complex number `real + I * imag`
`static IAST`	`CDF(IExpr distribution)`
`static IAST`	`CDF(IExpr distribution, IExpr a1)`
`static IAST`	`Ceiling(IExpr z)`
`static IAST`	`CentralMoment(IExpr a0, IExpr a1)`
`static IAST`	`CharacteristicPolynomial(IExpr matrix, IExpr variable)`	CharacteristicPolynomial(matrix, var) - computes the characteristic polynomial of a `matrix` for the variable `var`.
`static IAST`	`ChebyshevT(IExpr a0, IExpr a1)`
`static IAST`	`ChebyshevU(IExpr a0, IExpr a1)`
`static IAST`	`Chop(IExpr a0)`
`static org.hipparchus.complex.Complex`	`chopComplex(org.hipparchus.complex.Complex arg)`	Set real or imaginary parts of a numeric argument to zero, those absolute value is less than `Config.DEFAULT_CHOP_DELTA`
`static org.hipparchus.complex.Complex`	`chopComplex(org.hipparchus.complex.Complex arg, double delta)`	Set real or imaginary parts of a numeric argument to zero, those absolute value is less than a delta.
`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`	`Circle(IAST originList)`
`static IAST`	`Clear(IExpr... a)`
`static IAST`	`ClearAttributes(IExpr a0, IExpr a1)`
`static IAST`	`ClebschGordan(IExpr arg1, IExpr arg2, IExpr arg3)`
`static IAST`	`Clip(IExpr a0)`
`static IAST`	`Clip(IExpr a0, IExpr a1)`
`static IAST`	`Coefficient(IExpr a0, IExpr a1)`
`static IAST`	`Coefficient(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`CoefficientList(IExpr a0, IExpr a1)`
`static IAST`	`Collect(IExpr a0, IExpr a1)`
`static IAST`	`Colon(IExpr a0, IExpr a1)`
`static int`	`compareTo(Integer i, IExpr b)`
`static int`	`compareTo(BigInteger i, IExpr b)`
`static int`	`compareTo(IExpr a, Integer i)`
`static int`	`compareTo(IExpr a, BigInteger i)`
`static int`	`compareTo(IExpr a, IExpr b)`
`static IAST`	`Compile(IExpr a0, IExpr a1)`
`static IAST`	`CompilePrint(IExpr a0, IExpr a1)`
`static IAST`	`Complement(IExpr a0, IExpr a1)`
`static IComplex`	`complex(double realPart, double imagPart)`	Create a symbolic complex number
`static IComplex`	`complex(double realPart, double imagPart, double epsilon)`	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 IComplex`	`complex(IRational re)`	Create a symbolic complex number
`static IComplex`	`complex(IRational re, IRational im)`	Create a symbolic complex number
`static IAST`	`Complex(IExpr a0, IExpr a1)`	Create a `Complex(a, b)` AST symbolic expression.
`static IComplex`	`complexConvergent(double realPart, double imagPart)`	Create a symbolic complex number.
`static IComplexNum`	`complexNum(double r)`	Create a complex numeric number with imaginary part = 0.0
`static IComplexNum`	`complexNum(double r, double i)`	Create a complex numeric value
`static IComplexNum`	`complexNum(String realPart, String imaginaryPart, long precision)`	Return a `ApcomplexNum` which wraps two `Apfloat` arbitrary precision floating-point numbers for the real and imaginary part.
`static IComplexNum`	`complexNum(org.apfloat.Apcomplex c)`	Return a `ApcomplexNum` which wraps a `Apcomplex` arbitrary precision floating-point complex number.
`static IComplexNum`	`complexNum(org.apfloat.Apfloat realPart)`	Return a `ApcomplexNum` which wraps two `Apfloat` arbitrary precision floating-point numbers for the real and imaginary part with imaginary part set to `0`.
`static IComplexNum`	`complexNum(org.apfloat.Apfloat realPart, org.apfloat.Apfloat imaginaryPart)`	Return a `ApcomplexNum` which wraps two `Apfloat` arbitrary precision floating-point numbers for the real and imaginary part.
`static IComplexNum`	`complexNum(org.hipparchus.complex.Complex c)`	Return a `ComplexNum` which wraps a `Complex` number with Java double values for the real and imaginary part.
`static IComplexNum`	`complexNum(IComplex value)`
`static IComplexNum`	`complexNum(IFraction value)`
`static IComplexNum`	`complexNum(IInteger value)`
`static IAST`	`CompoundExpression(IExpr... expr)`	Evaluates its arguments in turn, returning the last result.
`static IAST`	`Condition(IExpr pattern, IExpr test)`	Places an additional constraint on `pattern` that only allows it to match if `test` evaluates to `S.True`.
`static IAST`	`ConditionalExpression(IExpr expr, IExpr condition)`
`static IAST`	`Cone(IExpr matrix)`
`static IAST`	`Cone(IExpr matrix, IExpr radius)`
`static IAST`	`Conjugate(IExpr a0)`
`static IAST`	`ConjugateTranspose(IExpr a0)`
`static IASTAppendable`	`constantArray(IExpr value, int copies)`	Create a new `List()` with `copies` number of arguments, which are set to `value`.
`static IASTAppendable`	`constantArray(IExpr head, IExpr value, int copies)`	Create a new abstract syntax tree (AST) with a `head` and `copies` number of arguments, which are set to `value`.
`static IAST`	`ConstantArray(IExpr a0, IExpr a1)`
`static IAST`	`Continue()`
`static IAST`	`ContinuedFraction(IExpr a0)`
`static IAST`	`CoordinateBoundingBox(IExpr a0)`
`static IAST`	`CoordinateBounds(IExpr a0)`
`static IAST`	`CoplanarPoints(IExpr a0)`
`static IAST`	`CoprimeQ(IExpr a0, IExpr a1)`
`static IAST`	`Cos(IExpr z)`	Returns the cosine of `z` (measured in Radians).
`static IAST`	`Cosh(IExpr z)`
`static IAST`	`CoshIntegral(IExpr z)`
`static IAST`	`CosIntegral(IExpr z)`
`static IAST`	`Cot(IExpr z)`	Returns the cotangent of `z` (measured in Radians).
`static IAST`	`Coth(IExpr z)`
`static IAST`	`Count(IExpr a0, IExpr a1)`
`static IAST`	`Count(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Covariance(IExpr a0, IExpr a1)`
`static IAST`	`Cross(IExpr a0, IExpr a1)`
`static IAST`	`Csc(IExpr z)`
`static IAST`	`Csch(IExpr z)`
`static IAST`	`cse(IExpr expr)`	Perform "common subexpression elimination" (CSE) on an expression.
`static IAST`	`cse(IExpr expr, Supplier<String> variablePrefix)`	Perform "common subexpression elimination" (CSE) on an expression.
`static void`	`cseAsJava(IExpr expr, StringBuilder buf)`	Perform "common subexpression elimination" (CSE) on an expression and create Java source code in the given `StringBuilder`.
`static void`	`cseAsJava(IExpr expr, Supplier<String> variablePrefix, StringBuilder buf)`	Perform "common subexpression elimination" (CSE) on an expression and create Java source code in the given `StringBuilder`.
`static IAST`	`Cube(IExpr center, IExpr length)`
`static IAST`	`CubeRoot(IExpr arg)`
`static IAST`	`Cuboid(IExpr pMin, IExpr pMax)`
`static IAST`	`Cycles(IExpr a0)`
`static IAST`	`Cylinder(IExpr matrix)`
`static IAST`	`Cylinder(IExpr matrix, IExpr radius)`
`static IAST`	`D()`
`static IAST`	`D(IExpr f, IExpr x)`
`static IAST`	`Dashing(IExpr a)`
`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 expr)`
`static IAST`	`Depth(IExpr a0)`
`static IAST`	`Derivative(IExpr... a)`
`static IAST`	`DesignMatrix(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Det(IExpr a0)`
`static IAST`	`DiagonalMatrix(IExpr a0)`
`static IAST`	`DiagonalMatrix(IExpr a0, IExpr a1)`
`static IAST`	`DiagonalMatrixQ(IExpr a0)`
`static IAST`	`DiagonalMatrixQ(IExpr a0, IExpr a1)`
`static IAST`	`DialogReturn()`
`static IAST`	`DialogReturn(IExpr a0)`
`static IAST`	`DigitQ(IExpr a0)`	DigitQ(str)
`static IAST`	`Dimensions(IExpr a0)`	Dimensions(expr)
`static IAST`	`DiracDelta(IExpr a0)`
`static IAST`	`DirectedEdge(IExpr a, IExpr b)`	`DirectedEdge` is a directed edge from vertex `a`b
`static IAST`	`DirectedInfinity(IExpr a0)`
`static IASTMutable`	`DirectionalLight(IExpr color, IExpr point)`
`static IAST`	`DiscreteDelta(IExpr a)`
`static IAST`	`DiscreteUniformDistribution(IExpr a)`
`static IAST`	`Discriminant(IExpr a0, IExpr a1)`
`static IAST`	`Disk(IAST originList)`
`static IAST`	`Distribute(IExpr a)`
`static IAST`	`Distribute(IExpr a0, IExpr a1)`
`static IAST`	`Distribute(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Distributed(IExpr x, IAST distribution)`	Create a `Distributed(x, <distribution>)` AST.
`static IExpr`	`div(Integer i, IExpr b)`
`static IExpr`	`div(BigInteger i, IExpr b)`
`static IExpr`	`div(IExpr a, Integer i)`
`static IExpr`	`div(IExpr a, BigInteger i)`
`static IExpr`	`Divide(int numerator, IExpr denominator)`	The division `numerator / denominator` will be represented by `numerator * denominator^(-1)`.
`static IExpr`	`Divide(IExpr numerator, int denominator)`	The division `numerator / denominator` will be represented by `numerator * denominator^(-1)`.
`static IExpr`	`Divide(IExpr numerator, IExpr denominator)`	The division `numerator / denominator` will be represented by `numerator * denominator^(-1)`.
`static IASTMutable`	`DivideSides(IExpr equationOrInequality)`
`static IASTMutable`	`DivideSides(IExpr equationOrInequality, IExpr a1)`
`static IAST`	`Divisible(IExpr a0, IExpr a1)`
`static IAST`	`Divisors(IExpr a0)`
`static IAST`	`DivisorSigma(IExpr a0, IExpr a1)`
`static IAST`	`Do(IExpr a0, IExpr a1)`
`static IAST`	`Dot(IExpr... a)`
`static IAST`	`Dot(IExpr a, IExpr b)`
`static IAST`	`Dot(IExpr a, IExpr b, IExpr c)`
`static IAST`	`Drop(IExpr list, IExpr a1)`
`static IAST`	`Drop(IExpr list, IExpr a1, IExpr a2)`
`static IAST`	`DSolve(IExpr a0, IExpr a1, IExpr a2)`
`static ISymbol`	`Dummy()`	Create a unique dummy symbol with prefix "$", which is retrieved from the evaluation engines DUMMY context.
`static ISymbol`	`Dummy(char symbolName)`	Create a unique dummy symbol which is retrieved from the evaluation engines DUMMY context.
`static ISymbol`	`Dummy(String symbolName)`	Create a unique dummy symbol which is retrieved from the evaluation engines DUMMY context.
`static IAST`	`Eigensystem(IExpr m)`
`static IAST`	`Eigenvalues(IExpr m)`
`static IAST`	`Eigenvectors(IExpr m)`
`static IAST`	`Element(IExpr variable, IExpr domain)`	Set a domain as an assumption for a variable.
`static IAST`	`ElementData(IExpr name, IExpr property)`	Property of a `name` chemical element.
`static IAST`	`Eliminate(IExpr a0, IExpr a1)`
`static IAST`	`EllipticE(IExpr m)`
`static IAST`	`EllipticE(IExpr phi, IExpr m)`
`static IAST`	`EllipticF(IExpr phi, IExpr m)`
`static IAST`	`EllipticK(IExpr m)`
`static IAST`	`EllipticPi(IExpr n, IExpr m)`
`static IAST`	`EllipticPi(IExpr n, IExpr phi, IExpr m)`
`static IAST`	`Equal(IExpr... a)`
`static IAST`	`Equal(IExpr lhs, int rhs)`	Yields `S.True` if `lhs` and `rhs` are known to be equal, or `S.False` if `lhs` and `rhs` are known to be unequal.
`static IAST`	`Equal(IExpr lhs, IExpr rhs)`	Yields `S.True` if `lhs` and `rhs` are known to be equal, or `S.False` if `lhs` and `rhs` are known to be unequal.
`static IAST`	`Equivalent(IExpr lhs, IExpr rhs)`
`static IAST`	`Erf(IExpr a)`
`static IAST`	`Erfc(IExpr a)`
`static IAST`	`Erfi(IExpr a)`
`static IAST`	`ErlangDistribution(IExpr a0, IExpr a1)`
`static IAST`	`EuclideanDistance(IExpr a0, IExpr a1)`
`static IAST`	`EulerE(IExpr n)`
`static IAST`	`EulerE(IExpr n, IExpr x)`
`static IAST`	`EulerPhi(IExpr a0)`
`static IExpr`	`eval(String str)`	Parse and evaluate a string expression.
`static IExpr`	`eval(IExpr a)`	Evaluate an expression.
`static IExpr`	`evalCollect(IExpr expr, IExpr x)`
`static IExpr`	`evalExpand(IExpr expr)`	Evaluate `Expand()` for the given expression.
`static IExpr`	`evalExpandAll(IExpr a)`	Apply `ExpandAll()` to the given expression if it's an `IAST`.
`static IExpr`	`evalExpandAll(IExpr a, EvalEngine engine)`	Apply `ExpandAll()` to the given expression if it's an `IAST`.
`static IExpr`	`evaln(IExpr a0)`	Deprecated. use `EvalEngine.evalN(IExpr)` instead
`static IExpr`	`evalQuiet(IExpr a)`	Deprecated. use EvalEngine#evalQuiet();
`static IExpr`	`evalQuietNull(IExpr a)`	Deprecated. use EvalEngine#evalQuietNull()
`static IExpr`	`evalSimplify(IExpr expr)`
`static boolean`	`evalTrue(IExpr expr)`	Deprecated. use EvalEngine#evalTrue()
`static IAST`	`EvenQ(IExpr x)`	EvenQ(x)
`static IAST`	`ExactNumberQ(IExpr expr)`	ExactNumberQ(expr)
`static IAST`	`Exists(IExpr a0, IExpr a1)`
`static IAST`	`Exists(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Exp(int z)`
`static IAST`	`Exp(IExpr z)`	The exponential function `E^z`.
`static IExpr`	`expand(IExpr a, boolean expandNegativePowers, boolean distributePlus, boolean evalParts)`	Apply `Expand()` to the given expression if it's an `IAST`.
`static IAST`	`Expand(IExpr expr)`	Expands out positive rational powers and products of sums in `expr`.
`static IAST`	`Expand(IExpr expr, IExpr pattern)`	Expands out positive rational powers and products of sums in `expr`.
`static IExpr`	`expandAll(IExpr a, boolean expandNegativePowers, boolean distributePlus)`	Apply `ExpandAll()` to the given expression if it's an `IAST`.
`static IAST`	`ExpandAll(IExpr a0)`
`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`	`ExponentialDistribution(IExpr a0)`
`static IAST`	`ExportString(IExpr a0, IExpr a1)`
`static IReal`	`expr(Number number)`	depending on the derived class of the given `Number`, the value is encoded as `IInteger`, `INum`
`static IAST`	`ExpToTrig(IExpr a0)`
`static IAST`	`Extract(IExpr a0, IExpr a1)`
`static IAST`	`f1(IExpr... a)`
`static IAST`	`f2(IExpr... a)`
`static IAST`	`f3(IExpr... a)`
`static IAST`	`f4(IExpr... a)`
`static IAST`	`Factor(IExpr poly)`
`static IAST`	`Factorial(int a0)`
`static IAST`	`Factorial(IExpr a0)`
`static IAST`	`Factorial2(IExpr a0)`
`static IAST`	`FactorialPower(IExpr x, IExpr n)`
`static IAST`	`FactorialPower(IExpr x, IExpr n, IExpr h)`
`static IAST`	`FactorInteger(IExpr a0)`
`static IAST`	`FactorSquareFree(IExpr a)`
`static IAST`	`FactorSquareFreeList(IExpr a)`
`static IAST`	`FactorTerms(IExpr poly)`
`static IAST`	`Fibonacci(IExpr a0)`
`static IAST`	`Fibonacci(IExpr a0, IExpr a1)`
`static IAST`	`FindFit(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FindMaximum(IExpr f, IExpr x)`
`static IAST`	`FindMinimum(IExpr f, IExpr x)`
`static IAST`	`FindRoot(IExpr f, IExpr x)`
`static IAST`	`FindShortestPath(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FindShortestTour(IExpr a0)`
`static IAST`	`FindSpanningTree(IExpr a0)`
`static IAST`	`First(IExpr a0)`
`static IAST`	`Fit(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FiveNum(IExpr a)`
`static IAST`	`Flatten(IExpr a0)`
`static IAST`	`Flatten(IExpr a0, IExpr a1)`
`static IAST`	`flattenSequence(IAST list)`	Iterate over the arguments of `list` and flatten the arguments of `Sequence(...)` expressions.
`static IAST`	`Floor(IExpr z)`
`static IAST`	`Fold(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ForAll(IExpr a0, IExpr a1)`
`static IAST`	`ForAll(IExpr a0, IExpr a1, IExpr a2)`
`static IFraction`	`fraction(double value)`	Create a "fractional" number from a double number with `Config.DOUBLE_EPSILON` maximum error allowed.
`static IFraction`	`fraction(double value, double epsilon)`	Create a "fractional" number from a double number.
`static IRational`	`fraction(long numerator, long denominator)`	Create a "fractional" number
`static IFraction`	`fraction(BigInteger numerator, BigInteger denominator)`	Create a "fractional" number
`static IFraction`	`fraction(org.hipparchus.fraction.BigFraction value)`	Create a "fractional" number
`static IFraction`	`fraction(IInteger numerator, IInteger denominator)`	Create a "fractional" number
`static IAST`	`FractionalPart(IExpr a)`
`static IAST`	`FractionBox(IExpr a0, IExpr a1)`
`static IFraction`	`fractionConvergent(double value)`	Create a "fractional" number from a double number.
`static IExpr`	`fractionExact(double value, boolean attemptNiceFraction)`	Create a "fractional" expression that exactly represents the given double number.
`static IAST`	`FrechetDistribution(IExpr a0, IExpr a1)`
`static IAST`	`FreeQ(IExpr expr, IExpr form)`	Returns `S.True` if `expr` does not contain the pattern `form`.
`static IAST`	`FresnelC(IExpr a)`
`static IAST`	`FresnelS(IExpr a)`
`static IAST`	`FromPolarCoordinates(IExpr a)`
`static IAST`	`FromSphericalCoordinates(IExpr a)`
`static IExpr`	`fromString(String string)`	Parses a given string to an instance of `IExpr`
`static IAST`	`FullForm(IExpr a0)`
`static IAST`	`FullSimplify(IExpr a)`
`static IASTMutable`	`function(IExpr head, IExpr... a)`	Create a new abstract syntax tree (AST).
`static IAST`	`Function(IExpr a0)`
`static IAST`	`Function(IExpr a0, IExpr a1)`
`static IAST`	`FunctionDomain(IExpr a0, IExpr a1)`
`static IAST`	`FunctionDomain(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionExpand(IExpr a0)`
`static IAST`	`FunctionExpand(IExpr a0, IExpr a1)`
`static IAST`	`FunctionRange(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionRange(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FunctionURL(IExpr a0)`
`static IAST`	`Gamma(IExpr a0)`
`static IAST`	`Gamma(IExpr a0, IExpr a1)`
`static IAST`	`Gamma(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`GammaDistribution(IExpr a0, IExpr a1)`
`static IAST`	`GammaDistribution(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`GammaRegularized(IExpr a0, IExpr a1)`
`static IAST`	`GammaRegularized(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Gather(IExpr a0, IExpr a1)`
`static IAST`	`GatherBy(IExpr a0, IExpr a1)`
`static IAST`	`GCD(IExpr a0)`
`static IAST`	`GCD(IExpr a0, IExpr a1)`
`static IAST`	`GegenbauerC(IExpr a0, IExpr a1)`
`static IAST`	`GegenbauerC(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`GeoDistance(IExpr a0, IExpr a1)`
`static IAST`	`GeometricMean(IExpr a0)`
`static IAST`	`Get(String str)`
`static IAST`	`Get(IExpr a0)`
`static String`	`getPredefinedInternalFormString(String key)`
`static IPattern`	`getPredefinedPattern(String key)`
`static IPatternSequence`	`getPredefinedPatternSequence(String key)`
`static IExpr`	`getUnaryInverseFunction(IExpr symbol)`
`static IAST`	`Grad(IExpr a0, IExpr a1)`
`static IAST`	`Graph(IExpr a0)`
`static IAST`	`Graph(IExpr a0, IExpr a1)`
`static IAST`	`Graph(IExpr a0, IExpr a1, IExpr a2)`
`static IASTAppendable`	`Graphics()`
`static IASTAppendable`	`Graphics(IExpr graphicPrimitives)`
`static IASTAppendable`	`Graphics(IExpr graphicPrimitives, IAST... optionRules)`
`static IASTAppendable`	`Graphics3D(IExpr graphicPrimitives)`
`static IAST`	`Graphics3D(IExpr graphicPrimitives, IExpr option)`
`static IAST`	`Greater(IExpr x, int y)`	Yields `S.True` if `x` is known to be greater than `y`.
`static IAST`	`Greater(IExpr x, IExpr y)`	Yields `S.True` if `x` is known to be greater than `y`.
`static IAST`	`GreaterEqual(IExpr x, int y)`	Yields `S.True` if `x` is known to be greater equal than `y`.
`static IAST`	`GreaterEqual(IExpr x, IExpr y)`	Yields `S.True` if `x` is known to be greater equal than `y`.
`static IAST`	`Gudermannian(IExpr a0)`
`static IAST`	`GumbelDistribution()`
`static IAST`	`GumbelDistribution(IExpr a0, IExpr a1)`
`static IAST`	`HankelH1(IExpr a0, IExpr a1)`
`static IAST`	`HankelH2(IExpr a0, IExpr a1)`
`static IAST`	`HarmonicMean(IExpr a0)`
`static IAST`	`HarmonicNumber(IExpr a)`
`static IAST`	`HarmonicNumber(IExpr a0, IExpr a1)`
`static boolean`	`hasSymbol(String symbolName, EvalEngine engine)`	Test if the `symbolName` is defined in the one of the contexts available on the context path.
`static IAST`	`Haversine(IExpr a)`
`static IAST`	`Head(IExpr a)`
`static IASTMutable`	`headAST0(IExpr head)`	Create a new abstract syntax tree (AST).
`static IExpr`	`heaviside(IExpr a0, IExpr defaultValue, EvalEngine engine)`
`static IAST`	`HeavisideTheta(IExpr a0)`
`static IAST`	`HermiteH(IExpr a0, IExpr a1)`
`static IAST`	`HermitianMatrixQ(IExpr a0)`
`static IAST`	`HilbertMatrix(IExpr a0)`
`static IAST`	`Histogram(IExpr a)`
`static IAST`	`Hold(IExpr a0)`
`static IAST`	`HoldComplete(IExpr a0)`
`static IAST`	`HoldForm(IExpr a0)`
`static IAST`	`HoldPattern(IExpr a0)`
`static IAST`	`HurwitzLerchPhi(IExpr z, IExpr s, IExpr a)`
`static IAST`	`HurwitzZeta(IExpr a0, IExpr a1)`
`static IAST`	`Hyperfactorial(IExpr a0)`
`static IAST`	`Hypergeometric0F1(IExpr a0, IExpr a1)`
`static IAST`	`Hypergeometric1F1(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Hypergeometric1F1Regularized(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Hypergeometric2F1(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Hypergeometric2F1Regularized(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`HypergeometricPFQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`HypergeometricPFQRegularized(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`HypergeometricU(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Identity(IExpr a0)`
`static IAST`	`IdentityMatrix(int dim)`
`static IAST`	`IdentityMatrix(IExpr a0)`
`static IAST`	`If(IExpr condition, IExpr trueExpr)`	Returns `trueExpr` if `condition` evaluates to `S.True`.
`static IAST`	`If(IExpr condition, IExpr trueExpr, IExpr falseExpr)`	Returns `trueExpr` if `condition` evaluates to `S.True` and `falseExpr` if it evaluates to `S.False`.
`static IAST`	`If(IExpr condition, IExpr trueExpr, IExpr falseExpr, IExpr undefinedExpr)`	Returns `trueExpr` if `condition` evaluates to `S.True` and `falseExpr` if it evaluates to `S.False` or `undefinedExpr` if condition don't evakluate to `S.True` or `S.False`.
`static IAST`	`IInit(ISymbol sym, int[] sizes)`
`static IExpr`	`IIntegrate(int priority, IAST lhs, IExpr rhs)`
`static IExpr`	`Im(IExpr a0)`
`static IAST`	`Implies(IExpr a0, IExpr a1)`
`static IAST`	`In(IExpr a0)`
`static IAST`	`Increment(IExpr a)`
`static IAST`	`Inequality(IExpr... a)`
`static IAST`	`InexactNumberQ(IExpr a)`	InexactNumberQ(expr)
`static IAST`	`Information(IExpr a)`
`static IAST`	`Information(IExpr a0, IExpr a1)`
`static IPattern`	`initPredefinedPattern(ISymbol symbol)`
`static IPatternSequence`	`initPredefinedPatternSequence(ISymbol symbol)`
`static IPatternSequence`	`initPredefinedPatternSequence(ISymbol symbol, boolean zeroArgsAllowed)`
`static void`	`initSymbols()`	Initialize the complete System
`static IAST`	`Insert(IExpr a0, IExpr a1, IExpr a2)`
`static IInteger`	`integer(long integerValue)`	Deprecated. use ZZ()
`static IInteger`	`integer(String integerString, int radix)`	Deprecated. use ZZ()
`static IInteger`	`integer(BigInteger integerValue)`	Deprecated. use ZZ()
`static IAST`	`IntegerName(IExpr a0)`
`static IAST`	`IntegerName(IExpr a0, IExpr a1)`
`static IAST`	`IntegerPart(IExpr a0)`
`static IAST`	`IntegerQ(IExpr expr)`	IntegerQ(expr)
`static IAST`	`Integrate(IExpr f, IExpr x)`	Integrates `f` with respect to `x`.
`static IAST`	`InterpolatingPolynomial(IExpr a0, IExpr a1)`
`static IAST`	`Interpolation(IExpr list)`
`static IAST`	`InterquartileRange(IExpr a)`
`static IAST`	`Intersection(IExpr a0, IExpr a1)`
`static IAST`	`Interval(IExpr list)`	Create an "interval" expression: `Interval(list)`.
`static IAST`	`Interval(IExpr min, IExpr max)`	Create an "interval" expression: `Interval(List(from, to))`.
`static IASTAppendable`	`IntervalAlloc(int capacity)`	Create a new `List` with the given `capacity`.
`static IAST`	`IntervalComplement(IExpr a1, IExpr a2)`
`static IAST`	`IntervalData(IAST list)`	Intervals will be represented by objects with head `S.IntervalData` wrapped around a sequence of quadruples of the form, e.g., `{a,Less,LessEqual,b}` representing the half open interval `(a,b]`.
`static IAST`	`IntervalData(IAST... lists)`	Intervals will be represented by objects with head `S.IntervalData` wrapped around a sequence of quadruples of the form, e.g., `{a,Less,LessEqual,b}` representing the half open interval `(a,b]`.
`static IASTAppendable`	`IntervalDataAlloc(int capacity)`
`static IAST`	`IntervalIntersection(IExpr... intervals)`	IntervalIntersection(interval_1, interval_2, ...) - compute the intersection of the intervals `interval_1, interval_2, ...`
`static IAST`	`IntervalMemberQ(IExpr interval, IExpr expr)`
`static IAST`	`IntervalUnion(IExpr... intervals)`	IntervalUnion(interval_1, interval_2, ...) - compute the union of the intervals `interval_1, interval_2, ...`
`static IAST`	`intIterator(ISymbol head, Function<IExpr,IExpr> function, int from, int to, int step)`	Iterate over an integer range `from <= i <= to` with the step `step/code>.`
`static IAST`	`intIterator(ISymbol head, Function<IExpr,IExpr> function, IAST list)`
`static IAST`	`intIterator(ISymbol head, IntFunction<IExpr> function, int from, int to, int step)`	Iterate over an integer range `from <= i <= to` with the step `step/code>.`
`static IExpr`	`intProduct(Function<IInteger,IExpr> function, int from, int to, int step)`	Iterate over an integer range `from <= i <= to` with the step `step/code> and evaluate the S.Product`
`static IExpr`	`intSum(Function<IInteger,IExpr> function, int from, int to, int step)`	Iterate over an integer range `from <= i <= to` with the step `step/code> and evaluate the S.Sum`
`static IExpr`	`intSum(Function<IInteger,IExpr> function, int from, int to, int step, boolean expand)`	Iterate over an integer range `from <= i <= to` with the step `step/code> and evaluate the S.Sum`
`static IExpr`	`intSum(IntFunction<IExpr> function, int iMin, int iMax)`	Calculate `Sum(function(k), {k, iMin, iMax})`
`static IAST`	`Inverse(IExpr a0)`
`static IAST`	`InverseBetaRegularized(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`InverseBetaRegularized(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`InverseCDF(IExpr distribution, IExpr q)`
`static IAST`	`InverseErf(IExpr a0)`
`static IAST`	`InverseErfc(IExpr a0)`
`static IAST`	`InverseFunction(IExpr a)`
`static IAST`	`InverseGammaRegularized(IExpr a0, IExpr a1)`
`static IAST`	`InverseGammaRegularized(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`InverseGudermannian(IExpr a0)`
`static IAST`	`InverseHaversine(IExpr a)`
`static IAST`	`InverseJacobiCD(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiCN(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiDC(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiDN(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiNC(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiND(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiSC(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiSD(IExpr a0, IExpr a1)`
`static IAST`	`InverseJacobiSN(IExpr a0, IExpr a1)`
`static IAST`	`InverseLaplaceTransform(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`InverseZTransform(IExpr expr, IExpr z, IExpr n)`
`static boolean`	`isAlmostSame(double a, double b)`	Test if `a` and `b` are almost the same values by comparing the `Double.doubleToLongBits(double)` values.
`static boolean`	`isEqual(double x, double y)`	Check difference is less than a constant
`static boolean`	`isEqual(org.hipparchus.complex.Complex x, org.hipparchus.complex.Complex y)`
`static IAST`	`ISet(IExpr lhs, IExpr rhs)`	Assign the evaluated `rhs` to the `lhs`. Note: this method returns `F.NIL`.
`static IAST`	`ISetDelayed(int priority, IExpr lhs, IExpr rhs)`
`static IAST`	`ISetDelayed(IExpr lhs, IExpr rhs)`	Assign the unevaluated `rhs` to the `lhs`. Note: this method returns `NIL`.
`static boolean`	`isFuzzyEquals(double a, double b, double tolerance)`	Returns `true` if `a` and `b` are within `tolerance` (exclusive) of each other.
`static boolean`	`isFuzzyEquals(org.hipparchus.complex.Complex x, org.hipparchus.complex.Complex y, double tolerance)`
`static boolean`	`isNumEqualInteger(double value, IInteger ii)`
`static boolean`	`isNumEqualRational(double value, IRational rational)`	Test if `rational.doubleValue()` equals `value` within the tolerance `Config.DOUBLE_TOLERANCE`.
`static boolean`	`isNumIntValue(double value)`	Test if the value is a Java `int` value within the tolerance `Config.DOUBLE_TOLERANCE`.
`static boolean`	`isNumIntValue(double value, double epsilon)`	Test if the value is a Java `int` value within the given tolerance `epsilon`.
`static boolean`	`isNumIntValue(double value, int i)`
`static boolean`	`isSystemInitialized()`
`static boolean`	`isZero(double value)`	Test if the absolute value is less `Config.DOUBLE_EPSILON`.
`static boolean`	`isZero(double x, double epsilon)`	Test if the absolute value is less than the given epsilon.
`static boolean`	`isZero(org.apfloat.Apcomplex x, double epsilon)`
`static boolean`	`isZero(org.apfloat.Apcomplex x, org.apfloat.Apfloat epsilon)`
`static boolean`	`isZero(org.apfloat.Apfloat x, double epsilon)`
`static boolean`	`isZero(org.apfloat.Apfloat x, org.apfloat.Apfloat epsilon)`
`static boolean`	`isZero(org.hipparchus.complex.Complex value)`	Test if the absolute value is less `Config.MACHINE_EPSILON`.
`static boolean`	`isZero(org.hipparchus.complex.Complex x, double epsilon)`	Test if the absolute value is less `Config.MACHINE_EPSILON`.
`static IAST`	`JacobiAmplitude(IExpr a0, IExpr a1)`
`static IAST`	`JacobiCD(IExpr a0, IExpr a1)`
`static IAST`	`JacobiCN(IExpr a0, IExpr a1)`
`static IAST`	`JacobiDC(IExpr a0, IExpr a1)`
`static IAST`	`JacobiDN(IExpr a0, IExpr a1)`
`static IAST`	`JacobiEpsilon(IExpr a0, IExpr a1)`
`static IAST`	`JacobiNC(IExpr a0, IExpr a1)`
`static IAST`	`JacobiND(IExpr a0, IExpr a1)`
`static IAST`	`JacobiP(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`JacobiSC(IExpr a0, IExpr a1)`
`static IAST`	`JacobiSD(IExpr a0, IExpr a1)`
`static IAST`	`JacobiSN(IExpr a0, IExpr a1)`
`static IAST`	`JavaForm(IExpr a0, IExpr a1)`
`static IAST`	`Join(IExpr a0, IExpr a1)`
`static IAST`	`JSFormData(String plainJavaScript, String format)`	Create JavaScript form data in the given format.
`static IAST`	`KelvinBei(IExpr a0, IExpr a1)`
`static IAST`	`KelvinBer(IExpr a0, IExpr a1)`
`static IAST`	`Key(IExpr a0)`
`static IAST`	`KleinInvariantJ(IExpr a0)`
`static IAST`	`KroneckerDelta(IExpr a0)`
`static IAST`	`KroneckerDelta(IExpr a0, IExpr a1)`
`static IAST`	`LaguerreL(IExpr a0, IExpr a1)`
`static IAST`	`LaguerreL(IExpr a0, IExpr a1, IExpr a2)`
`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 expr)`
`static IAST`	`LegendreP(IExpr a0, IExpr a1)`
`static IAST`	`LegendreP(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`LegendreQ(IExpr a0, IExpr a1)`
`static IAST`	`LegendreQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Length(IExpr expr)`
`static IAST`	`LerchPhi(IExpr z, IExpr s, IExpr a)`
`static IAST`	`Less(IExpr x, int y)`	Yields `S.True` if `x` is known to be less than `y`.
`static IAST`	`Less(IExpr x, IExpr y)`	Yields `S.True` if `x` is known to be less than `y`.
`static IAST`	`Less(IExpr x1, IExpr x2, IExpr x3)`	Yields `S.True` if `x1` is known to be less than `x2` and `x2` is known to be less than `x3`.
`static IAST`	`Less(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Less(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`LessEqual(IExpr x, int y)`	Yields `S.True` if `x` is known to be less equal than `y`.
`static IAST`	`LessEqual(IExpr x, IExpr y)`	Yields `S.True` if `x` is known to be less equal than `y`.
`static IAST`	`LessEqual(IExpr x1, IExpr x2, IExpr x3)`	Yields `S.True` if `x1` is known to be less equal than `x2` and `x2` is known to be less equal than `x3`.
`static IAST`	`LessEqual(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`LeviCivitaTensor(IExpr d)`
`static IAST`	`Limit(IExpr f, IExpr rule)`
`static IAST`	`Limit(IExpr f, IExpr rule, IExpr direction)`
`static IASTAppendable`	`Line()`
`static IAST`	`Line(IExpr listOfPoints)`
`static IAST`	`LinearModelFit(IExpr a0)`
`static IAST`	`LinearModelFit(IExpr a0, IExpr a1)`
`static IAST`	`LinearModelFit(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`LinearModelFit(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`LinearProgramming(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`LinearSolve(IExpr a0, IExpr a1)`
`static IAST`	`list(IExpr expr)`	Return a single value as a `List()`
`static IAST`	`list(IExpr x1, IExpr x2)`	Return a pair of values as a `List()`
`static IAST`	`list(IExpr x1, IExpr x2, IExpr x3)`	Return a triple of values as a `List()`
`static IAST`	`List()`	Create an empty immutable list `{ }` (i.e.
`static IASTMutable`	`List(double... numbers)`
`static IASTMutable`	`List(int... numbers)`
`static IAST`	`List(long... numbers)`
`static IASTMutable`	`List(String... strs)`
`static IAST`	`List(IExpr... a)`	Create an immutable list `{ }`.
`static IASTAppendable`	`ListAlloc()`	Create an appendable list `{ }`.
`static IASTAppendable`	`ListAlloc(int initialCapacity)`	Create a new `List` with the given `initial capacity`.
`static IASTAppendable`	`ListAlloc(Collection<? extends IExpr> collection)`	Create a new `List` with the capacity `collection.size()` and append the elements of the collection.
`static IASTAppendable`	`ListAlloc(Collection<? extends IExpr> collection, int capacity)`	Create a new `List` with the capacity `collection.size() + capacity` and append the elements of the collection.
`static IASTAppendable`	`ListAlloc(IntStream stream)`
`static IASTAppendable`	`ListAlloc(Stream<? extends IExpr> stream)`	Constructs a list that holds the expressions of the input stream.
`static IASTAppendable`	`ListAlloc(IExpr... a)`	Create an appendable list `{ }`.
`static IAST`	`ListConvolve(IExpr a0, IExpr a1)`
`static IAST`	`listOfObjects(Object... objects)`	Create an immutable list `{ }` by converting the `Object`s expression types into `IExpr` types.
`static IAST`	`ListPlot(IExpr a)`
`static IAST`	`ListPlot3D(IExpr a)`
`static IAST`	`ListPointPlot3D(IExpr a)`
`static IAST`	`ListQ(IExpr a)`	ListQ(expr)
`static IAST`	`Literal(IExpr a0)`	Deprecated. use HoldPattern
`static IBuiltInSymbol`	`localBiFunction(String symbolName, BinaryOperator<IExpr> function)`
`static IBuiltInSymbol`	`localBiPredicate(String symbolName, BiPredicate<IExpr,IExpr> function)`
`static IBuiltInSymbol`	`localFunction(String symbolName, UnaryOperator<IExpr> function)`
`static IBuiltInSymbol`	`localFunction(String symbolName, IEvaluator evaluator)`
`static IBuiltInSymbol`	`localPredicate(String symbolName, Predicate<IExpr> function)`
`static IAST`	`Log(int z)`	Returns the natural logarithm of `z`.
`static IAST`	`Log(int z, int base)`	Returns the logarithm of `z` for the `base`.
`static IAST`	`Log(IExpr z)`	Returns the natural logarithm of `z`.
`static IAST`	`Log(IExpr z, int base)`	Returns the logarithm of `z` for the `base`.
`static IAST`	`Log(IExpr z, IExpr base)`	Returns the logarithm of `z` for the `base`.
`static IAST`	`Log10(IExpr a0)`	`Log[10, a0]`.
`static IAST`	`LogGamma(IExpr a0)`
`static IAST`	`LogIntegral(IExpr a)`
`static IAST`	`LogisticSigmoid(IExpr a)`
`static IAST`	`LogNormalDistribution(IExpr a0, IExpr a1)`
`static IAST`	`LucasL(IExpr a)`
`static IAST`	`LucasL(IExpr a, IExpr b)`
`static IAST`	`MachineNumberQ(IExpr a0)`	MachineNumberQ(expr)
`static IAST`	`Manipulate(IExpr a0)`
`static IAST`	`Manipulate(IExpr a0, IExpr a1)`
`static IAST`	`Map(IExpr f)`
`static IAST`	`Map(IExpr f, IExpr expr)`
`static IAST`	`Map(IExpr f, IExpr expr, IExpr levelspec)`
`static IAST`	`MapAll(IExpr a0)`
`static <T> IASTAppendable`	`mapFunction(IExpr head, List<T> list, Function<T,IExpr> function)`	Iterates over the lists elements and calls the function.
`static <T> IASTAppendable`	`mapFunction(IExpr head, List<T> list, Function<T,IExpr> function, Predicate<T> predicate)`
`static IASTAppendable`	`mapFunction(IExpr head, IAST ast)`
`static <T extends IExpr> IASTAppendable`	`mapFunction(IExpr head, IAST ast, int start, int end, Function<T,IExpr> function)`
`static <T extends IExpr> IASTAppendable`	`mapFunction(IExpr head, IAST ast, int start, int end, Function<T,IExpr> function, Predicate<T> predicate)`
`static <T extends IExpr> IASTAppendable`	`mapFunction(IExpr head, IAST ast, Function<T,IExpr> function)`	Iterates over the `ast` elements and calls the function.
`static <T extends IExpr> IASTAppendable`	`mapFunction(IExpr head, IAST ast, Function<T,IExpr> function, Predicate<T> predicate)`
`static IASTAppendable`	`mapFunction(IExpr head, IAST ast, ObjIntFunction<IExpr,IExpr> function)`	Iterates over the lists elements and calls the function.
`static IASTAppendable`	`mapList(List<IExpr> list, Function<IExpr,IExpr> function, Predicate<IExpr> predicate)`
`static <T extends IExpr> IASTAppendable`	`mapList(List<T> list, Function<T,IExpr> function)`	Iterates over the lists elements and calls the function.
`static <T extends IExpr> IASTAppendable`	`mapList(IAST ast, Function<T,IExpr> function)`	Iterates over the lists elements and calls the function.
`static <T extends IExpr> IASTAppendable`	`mapList(IAST ast, Function<T,IExpr> function, Predicate<T> predicate)`
`static IASTAppendable`	`mapList(IAST ast, ObjIntFunction<IExpr,IExpr> function)`	Iterates over the lists elements and calls the function.
`static IASTAppendable`	`mapMap(Map<? extends IExpr,? extends IExpr> map, BiFunction<IExpr,IExpr,IExpr> biFunction)`	Iterates over the maps (key, value) pairs and calls the function.
`static <T extends IExpr> IASTAppendable`	`mapRange(int iMin, int iMax, IntFunction<T> function)`	Create an integer range between `iMin` (inclusive) and `iMax` (exclusive) and call the function with the elements of the created range.
`static <T extends IExpr> IASTAppendable`	`mapRange(IExpr head, int iMin, int iMax, IntFunction<T> function)`	Create an integer range between `iMin` (inclusive) and `iMax` (exclusive) and call the function with the elements of the created range.
`static IASTAppendable`	`mapSet(Set<? extends IExpr> exprSet, Function<IExpr,IExpr> function)`	Iterates over the set elements and calls the function.
`static IAST`	`MapThread(IExpr f, IExpr expr)`
`static IAST`	`MatchQ(IExpr expr, IExpr form)`
`static IAST`	`MathMLForm(IExpr expr)`
`static IAST`	`Matrices(IExpr a0)`
`static IAST`	`Matrices(IExpr a0, IExpr a1)`
`static IAST`	`Matrices(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`matrix(BiIntFunction<? extends IExpr> biFunction, int n, int m)`	Generate a `n x m` matrix.
`static IAST`	`MatrixD(IExpr expr, IExpr x)`
`static IAST`	`MatrixExp(IExpr a0)`
`static IAST`	`MatrixForm(IExpr a0)`
`static IAST`	`MatrixLog(IExpr a0)`
`static IAST`	`MatrixPower(IExpr matrix, IExpr n)`
`static IASTAppendable`	`Max()`
`static IAST`	`Max(IExpr a0)`
`static IAST`	`Max(IExpr a0, IExpr a1)`
`static IAST`	`Max(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Max(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Maximize(IExpr a0, IExpr a1)`
`static IAST`	`Mean(IExpr list)`
`static IAST`	`MeanDeviation(IExpr list)`
`static IAST`	`Median(IExpr list)`
`static IAST`	`MeijerG(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`MemberQ(IExpr list, IExpr form)`	Returns `S.True` if `form` matches any element of `list`, or `S.False` otherwise.
`static IAST`	`MessageName(IExpr a0, IExpr a1)`
`static IAST`	`MessageName(ISymbol symbol, String str)`
`static IASTAppendable`	`Min()`
`static IAST`	`Min(IExpr a0)`
`static IAST`	`Min(IExpr a0, IExpr a1)`
`static IAST`	`Min(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Min(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Minimize(IExpr a0, IExpr a1)`
`static IExpr`	`minus(Integer i, IExpr b)`
`static IExpr`	`minus(BigInteger i, IExpr b)`
`static IExpr`	`minus(IExpr a, Integer i)`
`static IExpr`	`minus(IExpr a, BigInteger i)`
`static IAST`	`Missing(String reason)`
`static IAST`	`Missing(IExpr reason)`
`static IAST`	`Missing(IExpr a0, IExpr a1)`
`static IAST`	`MissingQ(IExpr a0)`	MissingQ(expr)
`static IExpr`	`mod(Integer i, IExpr b)`
`static IExpr`	`mod(BigInteger i, IExpr b)`
`static IExpr`	`mod(IExpr a, Integer i)`
`static IExpr`	`mod(IExpr a, BigInteger i)`
`static IExpr`	`Mod(IExpr a0, IExpr a1)`
`static IAST`	`Module(IExpr listOfLocalVariables, IExpr expr)`	Evaluates `expr` for the `listOfLocalVariables` by first renaming the local variables in `expr`.
`static IAST`	`MoebiusMu(IExpr a0)`
`static IAST`	`Most(IExpr a0)`
`static IAST`	`Multinomial(IExpr... a)`
`static IAST`	`MultiplicativeOrder(IExpr a0, IExpr a1)`
`static IExpr`	`multiply(Integer i, IExpr b)`
`static IExpr`	`multiply(BigInteger i, IExpr b)`
`static IExpr`	`multiply(IExpr a, Integer i)`
`static IExpr`	`multiply(IExpr a, BigInteger i)`
`static IASTMutable`	`MultiplySides(IExpr equationOrInequality, IExpr x)`
`static IAST`	`N(IExpr symbolicExpr)`	Evaluate the given (symbolic) expression in numeric mode.
`static IAST`	`N(IExpr symbolicExpr, IExpr precision)`	Evaluate the given (symbolic) expression in numeric mode with `precision` digits .
`static IAST`	`NakagamiDistribution(IExpr a0, IExpr a1)`
`static IAST`	`NameQ(String str)`
`static IAST`	`NameQ(IExpr a0)`
`static IAST`	`Needs(IExpr a0)`
`static IExpr`	`Negate(IExpr x)`	Multiplies the given argument by `-1`.
`static IAST`	`Negative(IExpr x)`
`static IAST`	`Nest(IExpr a0, IExpr a1, int n)`
`static IAST`	`Nest(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`newInstance(int intialArgumentsCapacity, IExpr head)`	Create a new abstract syntax tree (AST).
`static IAST`	`NewLimit(IExpr f, IExpr rule)`
`static IAST`	`NewLimit(IExpr f, IExpr rule, IExpr direction)`
`static IAST`	`NMaximize(IExpr a0, IExpr a1)`
`static IAST`	`NMinimize(IExpr a0, IExpr a1)`
`static IAST`	`NonCommutativeMultiply(IExpr... a)`
`static IAST`	`Norm(IExpr a)`
`static IAST`	`NormalDistribution()`
`static IAST`	`NormalDistribution(IExpr a0, IExpr a1)`
`static IAST`	`Normalize(IExpr a)`
`static IAST`	`Not(IExpr expr)`	Logical Not function (negation).
`static IAST`	`NotElement(IExpr x, IExpr domain)`
`static IAST`	`NRoots(IExpr a0, IExpr a1)`
`static IAST`	`NullSpace(IExpr a0)`
`static Num`	`num(double value)`	Return a `Num` which wraps a Java double number.
`static INum`	`num(String valueString)`	Create a numeric value from the input string.
`static INum`	`num(String numberStr, long precision)`	Return a `ApfloatNum` which wraps a `Apfloat` arbitrary precision floating-point number.
`static INum`	`num(org.apfloat.Apfloat af)`	Return a `ApfloatNum` which wraps a `Apfloat` arbitrary precision floating-point number.
`static INum`	`num(IFraction value)`
`static INum`	`num(IInteger value)`
`static IAST`	`NumberQ(IExpr a0)`	NumberQ(expr)
`static IAST`	`Numerator(IExpr expr)`
`static IAST`	`NumericalOrder(IExpr a0, IExpr a1)`
`static IAST`	`NumericalSort(IExpr a0)`
`static IAST`	`NumericQ(IExpr a0)`	NumericQ(expr)
`static IAST`	`O(IExpr a0)`
`static IAST`	`OddQ(IExpr x)`	OddQ(x)
`static IAST`	`On(IExpr a0)`
`static IAST`	`On(IExpr a0, IExpr a1)`
`static String`	`openHTMLOnDesktop(String html)`
`static IAST`	`operatorForm1Append(IAST ast1)`	The operator form `op(f)[expr]` is transformed to `op(expr, f)`.
`static IAST`	`operatorForm2Prepend(IAST ast1, int[] expected, EvalEngine engine)`	The operator form `op(f)[expr]` is transformed to `op(f, expr)`.
`static IAST`	`operatorFormAppend2(IAST astArg)`	The binary operator form `op(f, g)[expr]` is transformed to `op(expr, f, g)`
`static IAST`	`OptimizeExpression(IExpr a0)`
`static IAST`	`Optional(IExpr a0)`
`static IAST`	`Optional(IExpr a0, IExpr a1)`
`static IAST`	`Options(IExpr a0)`
`static IAST`	`OptionValue(IExpr a0)`
`static IAST`	`OptionValue(IExpr a0, IExpr a1)`
`static IASTAppendable`	`Or()`
`static IAST`	`Or(IExpr... expr)`
`static IAST`	`Or(IExpr expr1, IExpr expr2)`	`expr1 \|\| expr2` evaluates each expression in turn, returning `S.True` as soon as an expression evaluates to `S.True`.
`static IAST`	`Or(IExpr expr1, IExpr expr2, IExpr expr3)`	`expr1 \|\| expr2 \|\| expr3` evaluates each expression in turn, returning `S.True` as soon as an expression evaluates to `S.True`.
`static IAST`	`Order(IExpr a0, IExpr a1)`
`static IAST`	`OrderedQ(IExpr a)`
`static IAST`	`Ordering(IExpr a)`
`static IAST`	`Out(int n)`
`static IAST`	`Out(IExpr a0)`
`static IAST`	`Overflow()`
`static Pair`	`pair(IExpr x1, IExpr x2)`	Return a pair of values as a `List()`
`static IAST`	`Parenthesis(IExpr a0)`
`static IAST`	`ParetoDistribution(IExpr a0, IExpr a1)`
`static IAST`	`ParetoDistribution(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ParetoDistribution(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IASTAppendable`	`Part()`	See: Part
`static IASTAppendable`	`Part(int extraSize, IExpr... a)`	See: Part
`static IASTAppendable`	`Part(IExpr... a)`	See: Part
`static IAST`	`Part(IExpr expr, IExpr i)`	Returns part `i` of `expr`.
`static IAST`	`Part(IExpr expr, IExpr i, IExpr j)`	Returns the part `i, j` of `expr`.
`static IAST`	`PartitionsP(IExpr a0)`
`static IAST`	`PartitionsQ(IExpr a0)`
`static IPattern`	`pattern(ISymbol symbol)`	Create a pattern for pattern-matching and term rewriting
`static IPattern`	`pattern(ISymbol symbol, IExpr check, boolean def)`	Create a pattern for pattern-matching and term rewriting
`static IAST`	`PatternTest(IExpr pattern, IExpr test)`	Constrains `pattern` to match `expr` only if the evaluation of `test(expr)` yields `S.True`.
`static IAST`	`PDF(IExpr distribution)`	See: PDF
`static IAST`	`PDF(IExpr distribution, IExpr x)`	See: PDF
`static IAST`	`Piecewise(IExpr listOfConditions)`	See: Piecewise
`static IAST`	`Piecewise(IExpr listOfConditions, IExpr defaultValue)`	See: Piecewise
`static IAST`	`PiecewiseExpand(IExpr expr)`	See: PiecewiseExpand
`static IAST`	`Plot(IExpr a0, IExpr a1)`
`static IAST`	`Plot(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Plot3D(IExpr a0, IExpr a1, IExpr a2)`
`static IExpr`	`plus(Integer i, IExpr b)`
`static IExpr`	`plus(BigInteger i, IExpr b)`
`static IExpr`	`plus(IExpr a, Integer i)`
`static IExpr`	`plus(IExpr a, BigInteger i)`
`static IASTAppendable`	`Plus()`	See: Plus
`static IAST`	`Plus(long num, IExpr... a)`	Define a `Plus()` expression `num + a0 + a1 + a2 ...` for addition.
`static IASTAppendable`	`Plus(IExpr a0)`	See: Plus
`static IAST`	`Plus(IExpr... a)`	Define a `Plus()` expression `a0 + a1 + a2 ...` for addition.
`static IAST`	`Plus(IExpr x, IExpr y)`	Define a `Plus()` expression `x + y` for addition.
`static IAST`	`Plus(IExpr x, IExpr y, IExpr z)`	Define a `Plus()` expression `x + y + z` for addition.
`static IASTAppendable`	`PlusAlloc(int initialCapacity)`	See: Plus
`static IAST`	`PlusMinus(IExpr... a)`
`static IAST`	`Pochhammer(IExpr a0, IExpr a1)`
`static IAST`	`Point(IAST list)`
`static IAST`	`PointSize(double value)`
`static IAST`	`PointSize(IExpr a0)`
`static IAST`	`PoissonDistribution(IExpr a0)`
`static IAST`	`PolyGamma(int n, IExpr z)`
`static IAST`	`PolyGamma(IExpr a0)`
`static IAST`	`PolyGamma(IExpr a0, IExpr a1)`
`static IAST`	`Polygon(IExpr a0)`
`static IAST`	`PolyLog(IExpr a0, IExpr a1)`
`static IAST`	`PolyLog(IExpr n, IExpr p, IExpr z)`
`static IAST`	`PolynomialGCD(IExpr poly1, IExpr poly2)`
`static IAST`	`PolynomialQ(IExpr expr, IExpr variable)`	Return `S.True` if `expr` is a polynomial for the `variable`.
`static IAST`	`PolynomialQuotient(IExpr poly1, IExpr poly2, IExpr x)`
`static IAST`	`PolynomialQuotientRemainder(IExpr poly1, IExpr poly2, IExpr x)`
`static IAST`	`PolynomialRemainder(IExpr poly1, IExpr poly2, IExpr x)`
`static IAST`	`Position(IExpr a0, IExpr a1)`
`static IAST`	`Positive(IExpr a0)`
`static IAST`	`PossibleZeroQ(IExpr a0)`
`static IExpr`	`Power(IExpr base, long exponent)`	Define a power expression `base ^ exponent`.
`static IAST`	`Power(IExpr base, IExpr exponent)`	Define `base` to the power of `exponent`.
`static IAST`	`PowerExpand(IExpr a0)`
`static IAST`	`PowerMod(IExpr a0, IExpr a1, IExpr a2)`
`static ISymbol`	`predefinedSymbol(String symbolName)`	Create a "predefined" symbol for constants or function names.
`static IAST`	`Prepend(IExpr a0, IExpr a1)`
`static IAST`	`PrimeOmega(IExpr a0)`
`static IAST`	`PrimePi(IExpr a0)`	See PrimePi
`static IAST`	`PrimeQ(IExpr a0)`	See PrimeQ
`static IAST`	`Print(IExpr... a)`
`static IExpr`	`product(Function<IInteger,IExpr> function, int from, int to)`	Iterate over an integer range `from <= i <= to` and create a product of the created values.
`static IAST`	`Product(IExpr expr, IExpr iterationSpecification)`
`static IAST`	`ProductLog(IExpr a0)`
`static IAST`	`ProductLog(IExpr a0, IExpr a1)`
`static IRational`	`productRational(IntFunction<IRational> function, int from, int to, int step)`
`static IAST`	`PseudoInverse(IExpr a0)`
`static IFraction`	`QQ(long numerator, long denominator)`	Create a "fractional" number `numerator / denominator`
`static IFraction`	`QQ(org.hipparchus.fraction.BigFraction frac)`	Create a "fractional" number from a Hipparchus `BigFraction` number.
`static IFraction`	`QQ(IInteger numerator, IInteger denominator)`	Create a "fractional" number `numerator / denominator`
`static IAST`	`QRDecomposition(IExpr a0)`
`static IAST`	`Quantile(IExpr distribution)`	Returns the Quantile of the `distribution`.
`static IAST`	`Quantile(IExpr list, IExpr q)`	Returns the `q`-Quantile of `list`.
`static IAST`	`Quantile(IExpr list, IExpr q, IExpr definition)`	Returns the `q`-Quantile of `list` with the given quantile `definition`.
`static IAST`	`Quantity(IExpr magnitude, IExpr unit)`	Returns the quantity for `magnitude` and `unit`.
`static IAST`	`QuantityMagnitude(IExpr quantity)`	Returns the value of the `quantity`.
`static IAST`	`QuantityMagnitude(IExpr quantity, IExpr unit)`	Returns the value of the `quantity` for the given `unit`
`static IAST`	`Quartiles(IExpr a0)`
`static IASTAppendable`	`quaternary(IExpr head, IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Quiet(IExpr a0)`
`static IASTMutable`	`quinary(IExpr head, IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`Quotient(IExpr a0, IExpr a1)`
`static IAST`	`Quotient(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`RandomComplex(IExpr a0)`
`static IAST`	`RandomInteger(IExpr a0)`
`static IAST`	`RandomReal(IExpr a0)`
`static IAST`	`RandomVariate(IExpr a0)`
`static IAST`	`RandomVariate(IExpr a0, IExpr a1)`
`static IAST`	`Range(IExpr a0)`
`static IAST`	`Range(IExpr a0, IExpr a1)`
`static IAST`	`Range(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Rational(IExpr a0, IExpr a1)`
`static IAST`	`Rationalize(IExpr a0)`
`static IAST`	`Rationalize(IExpr a0, IExpr a1)`
`static IExpr`	`Re(IExpr a0)`
`static IAST`	`RealAbs(IExpr a)`
`static IAST`	`RealSign(IExpr a)`
`static IAST`	`RealValuedNumberQ(IExpr a)`
`static IAST`	`RealValuedNumericQ(IExpr a)`
`static IAST`	`Reap(IExpr a)`
`static IAST`	`Rectangle(IAST originList)`
`static IExpr`	`reduce(IAST ast, int startInclusive, int endExclusive, IExpr identity, BinaryOperator<IExpr> accumulator)`	Performs a reduction on the elements of this function range, using the provided identity value and an associative accumulation function, and returns the reduced value.
`static IAST`	`Reduce(IExpr logicExpr, IExpr variable)`	Reduce(logic-expression, var) - returns the reduced `logic-expression` for the variable `var`.
`static IAST`	`Refine(IExpr a)`
`static IAST`	`Refine(IExpr a0, IExpr a1)`
`static IAST`	`RegularExpression(String str)`
`static IAST`	`RegularExpression(IExpr a0)`
`static double`	`relativeDifference(double x, double y)`	Calculate the relative difference between x and y.
`static IAST`	`ReleaseHold(IExpr z)`
`static ISymbol`	`removeUserSymbol(String symbolName)`	Remove a user-defined symbol from the eval engines context path.
`static IAST`	`Replace(IExpr a0, IExpr a1)`
`static IAST`	`ReplaceAll(IExpr a0, IExpr a1)`
`static IAST`	`ReplaceList(IExpr a0, IExpr a1)`
`static IAST`	`ReplacePart(IExpr a0, IExpr a1)`
`static IAST`	`ReplacePart(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ReplaceRepeated(IExpr a0, IExpr a1)`
`static IAST`	`Rest(IExpr a0)`
`static IAST`	`Resultant(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Return(IExpr a)`
`static IAST`	`Reverse(IExpr a)`
`static IAST`	`RGBColor(double red, double green, double blue)`
`static IAST`	`RGBColor(IExpr red, IExpr green, IExpr blue)`
`static IAST`	`RomanNumeral(IExpr a)`
`static IAST`	`Root(IExpr function, int k)`
`static IAST`	`Root(IExpr function, IExpr k)`
`static IAST`	`Roots(IExpr a0)`
`static IAST`	`Roots(IExpr a0, IExpr a1)`
`static IAST`	`RotationTransform(IExpr x)`
`static IAST`	`Round(IExpr x)`
`static IAST`	`RowBox(IAST list)`
`static IAST`	`RowReduce(IExpr m)`
`static IAST`	`Rule(String lhsStr, String rhsStr)`	Represents a rule replacing `lhsStr` with `rhsStr`.
`static IAST`	`Rule(String lhsStr, IExpr rhs)`	Represents a rule replacing `lhsStr` with `rhs`.
`static IAST`	`Rule(IExpr lhs, String rhsStr)`	Represents a rule replacing `lhs` with `rhsStr`.
`static IAST`	`Rule(IExpr lhs, IExpr rhs)`	Represents a rule replacing `lhs` with `rhs`.
`static IAST`	`RuleDelayed(IExpr lhs, IExpr rhs)`	Represents a rule replacing `lhs` with `rhs`, with `rhs` held unevaluated.
`static IAST`	`SameQ(IExpr a0, double d)`
`static IAST`	`SameQ(IExpr lhs, IExpr rhs)`	Returns `S.True` if `lhs` and `rhs` are structurally identical.
`static IAST`	`SatisfiabilityInstances(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ScalingTransform(IExpr z)`
`static IAST`	`Scan(IExpr a0, IExpr a1)`
`static IAST`	`Sec(IExpr z)`
`static IAST`	`Sech(IExpr z)`
`static IAST`	`Select(IExpr a0, IExpr a1)`
`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 IASTAppendable`	`Sequence()`
`static IASTMutable`	`Sequence(int... numbers)`
`static IAST`	`Sequence(IExpr a0)`
`static IAST`	`Sequence(IExpr... a)`
`static IAST`	`Series(IExpr... a)`
`static IAST`	`SeriesCoefficient(IExpr a0, IExpr a1)`
`static IAST`	`SeriesData(IExpr... a)`
`static IAST`	`Set(IExpr lhs, IExpr rhs)`	Evaluates `rhs` and assigns it to `lhs`.
`static IAST`	`SetAttributes(IExpr symbol, IExpr attribute)`
`static IAST`	`SetDelayed(IExpr lhs, IExpr rhs)`	Assigns `rhs` to `lhs`, without evaluating `rhs`.
`static IAST`	`ShearingTransform(IExpr a0, IExpr a1, IExpr a2)`
`static String`	`show(IExpr expr)`	Show the result in an HTML page with the help of the Java `Desktop.getDesktop().open()` method.
`static IAST`	`Show(IExpr a0)`
`static String`	`showGraphic(IExpr expr)`
`static IAST`	`Sign(IExpr z)`
`static IAST`	`Signature(IExpr a)`
`static IAST`	`SignCmp(IExpr z)`
`static IAST`	`Simplify(IExpr expr)`
`static IAST`	`Simplify(IExpr expr, IExpr assum)`
`static IAST`	`Sin(IExpr z)`	Returns the sine of `z` (measured in Radians).
`static IAST`	`Sinc(IExpr z)`
`static IAST`	`Sinh(IExpr z)`
`static IAST`	`SinhIntegral(IExpr z)`
`static IAST`	`SinIntegral(IExpr z)`
`static IAST`	`Skewness(IExpr a0)`
`static IAST`	`Slot(int i)`
`static IAST`	`Slot(String str)`
`static IAST`	`Slot(IExpr a0)`
`static IAST`	`SlotSequence(int i)`
`static IExpr[]`	`solve(IAST equations, ISymbol variable)`	Solve an equation for a single variable.
`static IAST`	`Solve(IExpr a0, IExpr a1)`	See Solve
`static IAST`	`Solve(IExpr a0, IExpr a1, IAST options)`
`static IAST`	`Sort(IExpr a0)`
`static IAST`	`Sort(IExpr a0, IExpr a1)`
`static IAST`	`Sow(IExpr a)`
`static IAST`	`Span(IExpr... a)`
`static ISparseArray`	`sparseArray(IAST arrayRulesList)`	Create a sparse array from the list of rules.
`static ISparseArray`	`sparseArray(IAST arrayRulesList, int[] dimension)`	Create a sparse array in the given `dimension` from the list of rules.
`static ISparseArray`	`sparseArray(IAST denseList, IExpr defaultValue)`	Create a sparse array from the dense list representation (for example dense vectors and matrices)
`static ISparseArray`	`sparseMatrix(BiIntFunction<? extends IExpr> binaryFunction, int n, int m)`	Generate a `n x m` sparse matrix.
`static IAST`	`Sphere(IExpr vector, IExpr radius)`
`static IAST`	`SphericalBesselJ(IExpr n, IExpr z)`
`static IAST`	`SphericalBesselY(IExpr n, IExpr z)`
`static IAST`	`SphericalHankelH1(IExpr n, IExpr z)`
`static IAST`	`SphericalHankelH2(IExpr n, IExpr z)`
`static IAST`	`SphericalHarmonicY(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Sqr(IExpr x)`	Create a "square" expression: `Power(x, 2)`.
`static IAST`	`Sqrt(int n)`	Create a "square root" expression: `Power(n, 1/2)`.
`static IAST`	`Sqrt(IExpr x)`	Create a "square root" expression: `Power(x, 1/2)`.
`static IAST`	`StandardDeviation(IExpr a0)`
`static IAST`	`Standardize(IExpr a0)`
`static IAST`	`Standardize(IExpr a0, IExpr a1)`
`static IAST`	`Standardize(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`StieltjesGamma(IExpr a0)`
`static IAST`	`StieltjesGamma(IExpr a0, IExpr a1)`
`static IAST`	`StirlingS1(IExpr n, IExpr m)`
`static IAST`	`StirlingS2(IExpr n, IExpr m)`
`static IAST`	`StringJoin(IExpr a)`
`static IStringX`	`stringx(char c)`	Create a Symja string expression with mime type TEXT_PLAIN.
`static IStringX`	`stringx(String str)`	Create a Symja string expression with mime type TEXT_PLAIN.
`static IStringX`	`stringx(StringBuilder str)`	Create a string expression
`static IStringX`	`stringx(String str, short mimeType)`	reate a Symja string expression.
`static IAST`	`StruveH(IExpr a0, IExpr a1)`
`static IAST`	`StruveL(IExpr a0, IExpr a1)`
`static IAST`	`StudentTDistribution(IExpr a0)`
`static IAST`	`StudentTDistribution(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Style(IExpr a0, IExpr a1)`
`static ASTRealVector`	`subdivide(double xMin, double xMax, int n)`	Create a list by dividing the range `xMin` to `xMax` into `n` parts.
`static ASTRealVector`	`subdivide(double xMax, int n)`	Create a list by dividing the range `0` to `xMax` into `n` parts.
`static IAST`	`subdivide(int n)`	Create a list `{0, 1/n,2/n,3/n,...,n}`.
`static IAST`	`subdivide(int xMax, int n)`	Create a list by dividing the range `0` to `xMax` into `n` parts.
`static IAST`	`subdivide(int xMin, int xMax, int n)`	Create a list by dividing the range `xMin` to `xMax` into `n` parts.
`static IAST`	`Subdivide(IExpr a0)`
`static IAST`	`Subdivide(IExpr a0, IExpr a1)`
`static IAST`	`Subdivide(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Subfactorial(IExpr a0)`
`static IExpr`	`subs(IExpr expr, IExpr x, IExpr y)`	Substitute all (sub-) expressions `x` in `expr` with `y`.
`static IAST`	`Subscript(IExpr x, IExpr y)`
`static IExpr`	`subsList(IExpr expr, Map<? extends IExpr,? extends IExpr> map)`	Substitute all (sub-) expressions contained as keys in `map` in `expr` with the corresponding value in `map`.
`static IExpr`	`subst(IExpr expr, Function<IExpr,IExpr> function)`	Substitute all (sub-) expressions with the given unary function.
`static IExpr`	`subst(IExpr expr, Map<? extends IExpr,? extends IExpr> map)`	Substitute all (sub-) expressions with the given map.
`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 x, int y)`	Return `x + (-1)*y`
`static IAST`	`Subtract(IExpr x, IExpr y)`	Return `x + (-1)*y`
`static IASTMutable`	`SubtractSides(IExpr equationOrInequality)`
`static IASTMutable`	`SubtractSides(IExpr equationOrInequality, IExpr x)`
`static IExpr`	`sum(Function<IInteger,IExpr> function, int iMin, int iMax)`	Evaluate the sum from `iMin` to `iMax` and step `1`.
`static IExpr`	`sum(Function<IInteger,IExpr> function, int iMin, int iMax, int iStep)`	Evaluate the sum from `iMin` to `iMax` and step `iStep`.
`static IExpr`	`sum(Function<IInteger,IExpr> function, int iMin, int iMax, int iStep, boolean expand)`	Evaluate the sum from `iMin` to `iMax` and step `iStep`.
`static IAST`	`Sum(IExpr expr, IExpr iterationSpecification)`
`static IAST`	`Sum(IExpr expr, IExpr iterationSpecification1, IExpr iterationSpecification2)`
`static IAST`	`Sum(IExpr expr, IExpr iterationSpecification1, IExpr iterationSpecification2, IExpr iterationSpecification3)`
`static IAST`	`Sum(IExpr expr, IExpr iterationSpecification1, IExpr iterationSpecification2, IExpr iterationSpecification3, IExpr iterationSpecification4)`
`static IAST`	`Sum(IExpr expr, IExpr iterationSpecification1, IExpr iterationSpecification2, IExpr iterationSpecification3, IExpr iterationSpecification4, IExpr iterationSpecification5)`
`static IRational`	`sumRational(IntFunction<IRational> function, int iMin, int iMax)`
`static IRational`	`sumRational(IntFunction<IRational> function, int from, int to, int step)`
`static IAST`	`Superscript(IExpr x, IExpr y)`
`static IAST`	`Surd(IExpr a0, IExpr a1)`
`static IASTAppendable`	`SurfaceGraphics()`
`static IAST`	`Switch(IExpr... a)`
`static ISymbol`	`symbol(String symbolName)`	Get or create a user defined symbol which is retrieved from the evaluation engines context path.
`static ISymbol`	`symbol(String symbolName, String contextStr, IAST assumptionAST, EvalEngine engine)`
`static ISymbol`	`symbol(String symbolName, EvalEngine engine)`	Get or create a user defined symbol which is retrieved from the evaluation engines context path.
`static ISymbol`	`symbol(String symbolName, IAST assumptionAST)`	Get or create a user defined symbol which is retrieved from the evaluation engines context path.
`static ISymbol`	`symbol(String symbolName, IAST assumptionAST, EvalEngine engine)`	Get or create a user defined symbol which is retrieved from the evaluation engines context path.
`static ISymbol`	`symbol(Context context, String symbolName, EvalEngine engine)`
`static String`	`symbolNameNormalized(String symbolName)`
`static IAST`	`SymbolQ(IExpr x)`	SymbolQ(x)
`static IBuiltInSymbol`	`symjify(boolean value)`	Return `S.True` or `S.False` symbol
`static INum`	`symjify(double value)`
`static IInteger`	`symjify(long value)`
`static IExpr`	`symjify(Object object)`	Converts and evaluates arbitrary expressions to a Symja type.
`static IExpr`	`symjify(Object object, boolean evaluate)`	Converts and evaluates arbitrary expressions to a Symja type.
`static IExpr`	`symjify(String str)`	Parses and evaluates a Java string to a Symja expression.
`static IExpr`	`symjify(String str, boolean evaluate)`	Parses a Java string to a Symja expression.
`static IAST`	`Symmetric(IExpr a0)`	Full symmetry
`static IAST`	`SymmetricMatrixQ(IExpr a0)`	See SymmetricMatrixQ
`static IAST`	`Table(IExpr expr, IExpr iterationSpecification)`	See Table
`static IAST`	`Table(IExpr expr, IExpr iterationSpecification1, IExpr iterationSpecification2)`
`static IASTMutable`	`TagSet(IExpr a0, IExpr a1, IExpr a2)`
`static IASTMutable`	`TagSetDelayed(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Take(IExpr a0, IExpr a1)`	See Take
`static IASTMutable`	`TakeLargest(IExpr a0, IExpr a1)`
`static IASTMutable`	`TakeLargestBy(IExpr a0, IExpr a1, IExpr a2)`
`static IASTMutable`	`TakeSmallest(IExpr a0, IExpr a1)`
`static IASTMutable`	`TakeSmallestBy(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Tan(IExpr z)`	Returns the tangent of `z` (measured in Radians).
`static IAST`	`Tanh(IExpr z)`	See Tanh
`static IAST`	`Taylor(IExpr a0, IExpr a1)`
`static IAST`	`TemplateSlot(IExpr a0)`
`static IAST`	`TemplateSlot(IExpr a0, IExpr a1)`
`static IAST`	`TensorDimensions(IExpr a0)`
`static IAST`	`tensorList(int n, Integer... numbers)`	For positive n, add the first n elements of `numbers` to the list.For negative n, add the last n elements of `numbers` to the list.
`static IAST`	`TensorRank(IExpr a0)`
`static IAST`	`TensorSymmetry(IExpr a0)`
`static IAST`	`TensorSymmetry(IExpr a0, IExpr a1)`
`static IASTMutable`	`ternaryAST3(IExpr head, IExpr arg1, IExpr arg2, IExpr arg3)`	Create a function `head(arg1, arg2, arg3)` with 3 argument as an `AST3` mutable object without evaluation.
`static IAST`	`TeXForm(IExpr expr)`	See TeXForm
`static IAST`	`Text(IExpr expr, IAST coords)`
`static IAST`	`Thread(IExpr a0)`	See Thread
`static IAST`	`ThreeJSymbol(IExpr arg1, IExpr arg2, IExpr arg3)`
`static IAST`	`Throw(IExpr a)`	See Throw
`static IAST`	`TimeConstrained(IExpr a0, IExpr a1)`	See TimeConstrained
`static IAST`	`TimeConstrained(IExpr a0, IExpr a1, IExpr a2)`	See TimeConstrained
`static IASTAppendable`	`Times()`	See: Times
`static IAST`	`Times(long num, IExpr... a)`	See: Times
`static IASTAppendable`	`Times(IExpr x)`	See: Times
`static IAST`	`Times(IExpr... a)`	Define a `Times()` expression `a1 * a2 * ...` for multiplication.
`static IASTMutable`	`Times(IExpr x, IExpr y)`	Define a `Times()` expression `x * y` for multiplication.
`static IAST`	`Times(IExpr x, IExpr y, IExpr z)`	Define a `Times()` expression `a0 * a1 * a2` for multiplication.
`static IASTAppendable`	`TimesAlloc(int initialCapacity)`	Create a Times() function with allocated space for size elements.
`static IExpr`	`timesDistribute(IExpr x, IExpr y, EvalEngine engine)`
`static IAST`	`ToExpression(IExpr a0)`	See ToExpression
`static IAST`	`Together(IExpr a0)`	See Together
`static int`	`toIntDefault(double value)`	Converts this number to an `int` value; this method returns `Integer.MIN_VALUE`, if the value of this integer isn't in the range `java.lang.Integer.MIN_VALUE`+1 to `java.lang.Integer.MAX_VALUE`-1 or the expression is not convertible to the `int` range.
`static int`	`toIntDefault(double value, int defaultValue)`	Converts this number to an `int` value; this method returns `defaultValue`, if the value of this integer isn't in the range `java.lang.Integer.MIN_VALUE`+1 to `java.lang.Integer.MAX_VALUE`-1 or the expression is not convertible to the `int` range.
`static IAST`	`ToIntervalData(IExpr expr)`
`static IAST`	`ToIntervalData(IExpr expr, IExpr variable)`
`static IAST`	`ToPolarCoordinates(IExpr a0)`
`static IAST`	`ToSphericalCoordinates(IExpr a0)`
`static IAST`	`Total(IExpr a0)`	See Total
`static IAST`	`Tr(IExpr a0)`	See Tr
`static IAST`	`Trace(IExpr a0)`
`static IAST`	`TransformationFunction(IExpr a0)`
`static IAST`	`TranslationTransform(IExpr a0)`
`static IAST`	`Transpose(IExpr list)`	See Transpose
`static IAST`	`Triangle(IAST list)`
`static IAST`	`TrigExpand(IExpr expr)`	See TrigExpand
`static IAST`	`TrigReduce(IExpr expr)`	See TrigReduce
`static IAST`	`TrigSimplifyFu(IExpr expr)`
`static IAST`	`TrigToExp(IExpr expr)`	See TrigToExp
`static IAST`	`TrueQ(IExpr expr)`	See TrueQ
`static IASTAppendable`	`unary(IExpr head, IExpr arg)`	Create a function `head(arg)` with 1 argument without evaluation.
`static IASTMutable`	`unaryAST1(IExpr head, IExpr arg)`	Create a function `head(arg)` with 1 argument as an `AST1` mutable object without evaluation.
`static IAST`	`Underflow()`
`static IAST`	`UndirectedEdge(IExpr a, IExpr b)`	`UndirectedEdge` is an undirected edge between the vertices `a` and `b` in a `graph` object.
`static IAST`	`Unequal(IExpr lhs, IExpr rhs)`	Yields `S.False` if `lhs` and `rhs` are known to be equal, or `S.True` if `lhs` and `rhs` are known to be unequal.
`static IAST`	`Unevaluated(IExpr a0)`
`static IAST`	`UniformDistribution(IExpr a)`
`static IAST`	`Union(IExpr list1)`
`static IAST`	`Union(IExpr list1, IExpr list2)`
`static IAST`	`Unique(IExpr a0)`
`static IAST`	`UnitConvert(IExpr quantity)`	Convert the `quantity` to the base unit.
`static IAST`	`UnitConvert(IExpr quantity, IExpr unit)`	Convert the `quantity` to the given `unit`.
`static IAST`	`UnitStep(IExpr a0)`
`static IAST`	`UnsameQ(IExpr lhs, IExpr rhs)`	Returns `S.True` if `lhs` and `rhs` are not structurally identical.
`static IAST`	`Unset(IExpr a0)`
`static IAST`	`UpSet(IExpr a0, IExpr a1)`
`static IAST`	`UpSetDelayed(IExpr a0, IExpr a1)`
`static String`	`usage(String symbolName)`	Print the documentation for the given symbol name.
`static String`	`usage(ISymbol head)`	Print the documentation for the given symbol.
`static IAST`	`Variables(IExpr a0)`
`static IAST`	`Variance(IExpr a0)`
`static IAST`	`vector(IntFunction<? extends IExpr> iFunction, int n)`	Generate a vector with `n` elements.
`static IAST`	`Vectors(IExpr a0)`
`static IAST`	`Vectors(IExpr a0, IExpr a1)`
`static IAST`	`WeberE(IExpr v, IExpr z)`
`static IAST`	`WeberE(IExpr v, IExpr m, IExpr z)`
`static IAST`	`WeibullDistribution(IExpr a0, IExpr a1)`
`static IAST`	`WeibullDistribution(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`While(IExpr test, IExpr body)`	Evaluates `body` as long as `test` evaluates to `S.True`.
`static IAST`	`WhittakerM(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`WhittakerW(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`With(IExpr listOfLocalVariables, IExpr expr)`	Evaluates `expr` for the`listOfLocalVariables` by replacing the local variables in `expr`.
`static IAST`	`ZeroSymmetric(IExpr a0)`	Symmetry of a zero tensor.
`static IAST`	`Zeta(IExpr s)`
`static IAST`	`Zeta(IExpr s, IExpr a)`
`static IAST`	`ZTransform(IExpr expr, IExpr n, IExpr z)`
`static IInteger`	`ZZ(int integerValue)`	Create an integer number by using the internal small integer number cache.
`static IInteger`	`ZZ(long integerValue)`	Create an integer number.
`static IInteger`	`ZZ(String integerString, int radix)`	Create a large integer number.
`static IInteger`	`ZZ(BigInteger integerValue)`	Create a large integer number.
`static IInteger`	`ZZUniqueReference(int integerValue)`	Create a new integer number without using the internal small integer number cache.

Methods inherited from class org.matheclipse.core.expression.S
exprID, exprID, initFinalHiddenSymbol, isDomain, symbol

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

Field Detail
- REMEMBER_INTEGER_CACHE
```
public static final com.google.common.cache.Cache<IAST,IExpr> REMEMBER_INTEGER_CACHE
```
  In computing, memoization or memoisation is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again. This cache is especially used for recursive integer functions to remember the results of the recursive call. See: Wikipedia - Memoization
- PREDEFINED_INTERNAL_FORM_STRINGS
```
public static final Map<String,String> PREDEFINED_INTERNAL_FORM_STRINGS
```
  The map for predefined strings for the IExpr.internalFormString(boolean, int) method.
- SYMBOL_OBSERVER
```
public static final ISymbolObserver SYMBOL_OBSERVER
```
- NIL
```
public static final AbstractAST.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).
  
  See Also:
  
  Optional.isPresent()
- INVALID
```
public static final AbstractAST.NILPointer INVALID
```
- a_
```
public static final IPattern a_
```
  Used to represent a formal pattern a_ that will be used only for predefined pattern-matching rules and can match one expression.
- b_
```
public static final IPattern b_
```
  Used to represent a formal pattern b_ that will be used only for predefined pattern-matching rules and can match one expression.
- c_
```
public static final IPattern c_
```
  Used to represent a formal pattern c_ that will be used only for predefined pattern-matching rules and can match one expression.
- d_
```
public static final IPattern d_
```
  Used to represent a formal pattern d_ that will be used only for predefined pattern-matching rules and can match one expression.
- e_
```
public static final IPattern e_
```
  Used to represent a formal pattern e_ that will be used only for predefined pattern-matching rules and can match one expression.
- f_
```
public static final IPattern f_
```
  Used to represent a formal pattern f_ that will be used only for predefined pattern-matching rules and can match one expression.
- g_
```
public static final IPattern g_
```
  Used to represent a formal pattern g_ that will be used only for predefined pattern-matching rules and can match one expression.
- h_
```
public static final IPattern h_
```
  Used to represent a formal pattern h_ that will be used only for predefined pattern-matching rules and can match one expression.
- i_
```
public static final IPattern i_
```
  Used to represent a formal pattern i_ that will be used only for predefined pattern-matching rules and can match one expression.
- j_
```
public static final IPattern j_
```
  Used to represent a formal pattern j_ that will be used only for predefined pattern-matching rules and can match one expression.
- k_
```
public static final IPattern k_
```
  Used to represent a formal pattern k_ that will be used only for predefined pattern-matching rules and can match one expression.
- l_
```
public static final IPattern l_
```
  Used to represent a formal pattern l_ that will be used only for predefined pattern-matching rules and can match one expression.
- m_
```
public static final IPattern m_
```
  Used to represent a formal pattern m_ that will be used only for predefined pattern-matching rules and can match one expression.
- n_
```
public static final IPattern n_
```
  Used to represent a formal pattern n_ that will be used only for predefined pattern-matching rules and can match one expression.
- o_
```
public static final IPattern o_
```
  Used to represent a formal pattern o_ that will be used only for predefined pattern-matching rules and can match one expression.
- p_
```
public static final IPattern p_
```
  Used to represent a formal pattern p_ that will be used only for predefined pattern-matching rules and can match one expression.
- q_
```
public static final IPattern q_
```
  Used to represent a formal pattern q_ that will be used only for predefined pattern-matching rules and can match one expression.
- r_
```
public static final IPattern r_
```
  Used to represent a formal pattern r_ that will be used only for predefined pattern-matching rules and can match one expression.
- s_
```
public static final IPattern s_
```
  Used to represent a formal pattern s_ that will be used only for predefined pattern-matching rules and can match one expression.
- t_
```
public static final IPattern t_
```
  Used to represent a formal pattern t_ that will be used only for predefined pattern-matching rules and can match one expression.
- u_
```
public static final IPattern u_
```
  Used to represent a formal pattern u_ that will be used only for predefined pattern-matching rules and can match one expression.
- v_
```
public static final IPattern v_
```
  Used to represent a formal pattern v_ that will be used only for predefined pattern-matching rules and can match one expression.
- w_
```
public static final IPattern w_
```
  Used to represent a formal pattern w_ that will be used only for predefined pattern-matching rules and can match one expression.
- x_
```
public static final IPattern x_
```
  Used to represent a formal pattern x_ that will be used only for predefined pattern-matching rules and can match one expression.
- y_
```
public static final IPattern y_
```
  Used to represent a formal pattern y_ that will be used only for predefined pattern-matching rules and can match one expression.
- z_
```
public static final IPattern z_
```
  Used to represent a formal pattern z_ that will be used only for predefined pattern-matching rules and can match one expression.
- x__
```
public static final IPatternSequence x__
```
  Used to represent a formal pattern sequence x__ that will be used only for predefined pattern-matching rules and can match any sequence of one or more expressions.
- y__
```
public static final IPatternSequence y__
```
  Used to represent a formal pattern sequence y__ that will be used only for predefined pattern-matching rules and can match any sequence of one or more expressions.
- z__
```
public static final IPatternSequence z__
```
  Used to represent a formal pattern sequence z__ that will be used only for predefined pattern-matching rules and can match any sequence of one or more expressions.
- x___
```
public static final IPatternSequence x___
```
  Used to represent a formal null pattern sequence x___ that will be used only for predefined pattern-matching rules and can match any sequence of zero or more expressions.
- y___
```
public static final IPatternSequence y___
```
  Used to represent a formal null pattern sequence y___ that will be used only for predefined pattern-matching rules and can match any sequence of zero or more expressions.
- z___
```
public static final IPatternSequence z___
```
  Used to represent a formal null pattern sequence z___ that will be used only for predefined pattern-matching rules and can match any sequence of zero or more expressions.
- 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_
```
- P_
```
public static final IPattern P_
```
- Q_
```
public static final IPattern Q_
```
- m_Integer
```
public static final IPattern m_Integer
```
- n_Integer
```
public static final IPattern n_Integer
```
- 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
```
- P_DEFAULT
```
public static final IPattern P_DEFAULT
```
- Q_DEFAULT
```
public static final IPattern Q_DEFAULT
```
- C0
```
public static final IInteger C0
```
  Constant integer "0"
- C1
```
public static final IInteger C1
```
  Constant integer "1"
- C2
```
public static final IInteger C2
```
  Constant integer "2"
- C3
```
public static final IInteger C3
```
  Constant integer "3"
- C4
```
public static final IInteger C4
```
  Constant integer "4"
- C5
```
public static final IInteger C5
```
  Constant integer "5"
- C6
```
public static final IInteger C6
```
  Constant integer "6"
- C7
```
public static final IInteger C7
```
  Constant integer "7"
- C8
```
public static final IInteger C8
```
  Constant integer "8"
- C9
```
public static final IInteger C9
```
  Constant integer "9"
- C10
```
public static final IInteger C10
```
  Constant integer "10"
- C100
```
public static final IInteger C100
```
  Constant integer "100"
- C1000
```
public static final IInteger C1000
```
  Constant integer "1000"
- CI
```
public static final IComplex CI
```
  Complex imaginary unit "0 + I". The parsed symbol "I" is converted on input to this constant.
- CNI
```
public static final IComplex CNI
```
  Complex negative imaginary unit "0 - I".
- C1D2
```
public static final IFraction C1D2
```
  Constant fraction "1/2"
- C3D2
```
public static final IFraction C3D2
```
  Constant fraction "3/2"
- C3D4
```
public static final IFraction C3D4
```
  Constant fraction "3/4"
- C5D2
```
public static final IFraction C5D2
```
  Constant fraction "5/2"
- CN1D2
```
public static final IFraction CN1D2
```
  Constant fraction "-1/2"
- CN3D2
```
public static final IFraction CN3D2
```
  Constant fraction "-3/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"
- C1D5
```
public static final IFraction C1D5
```
  Constant fraction "1/5"
- CN1D5
```
public static final IFraction CN1D5
```
  Constant fraction "-1/5"
- C1D6
```
public static final IFraction C1D6
```
  Constant fraction "1/6"
- CN1D6
```
public static final IFraction CN1D6
```
  Constant fraction "-1/6"
- C2D3
```
public static final IFraction C2D3
```
  Constant fraction "2/3"
- CN2D3
```
public static final IFraction CN2D3
```
  Constant fraction "-2/3"
- CND1
```
public static final Num CND1
```
  Constant double "-1.0"
- CD0
```
public static final Num CD0
```
  Constant double "0.0"
- CD1
```
public static final Num CD1
```
  Constant double "1.0"
- CDI
```
public static final IComplexNum CDI
```
  Complex numerical imaginary unit.
- CDNI
```
public static final IComplexNum CDNI
```
  Complex negative numerical imaginary unit.
- CEmptyString
```
public static final IStringX CEmptyString
```
  Represents the empty Smyja string ""
- CEmptySequence
```
public static final IAST CEmptySequence
```
  Represents Sequence() (i.e. the constant empty list)
- CEmptyList
```
public static final IAST CEmptyList
```
  Represents List() (i.e. the constant empty list)
- CEmptyInterval
```
public static final IAST CEmptyInterval
```
  Represents Interval() (i.e. the constant empty interval with closed ends)
- CEmptyIntervalData
```
public static final IAST CEmptyIntervalData
```
  Represents Interval() (i.e. the constant empty interval with closed/open ends)
- CMissingNotFound
```
public static final IAST CMissingNotFound
```
  Represents Missing("NotFound")
- CListC0
```
public static final IAST CListC0
```
  Represents List(0)
- CListC1
```
public static final IAST CListC1
```
  Represents List(1)
- CListCN1
```
public static final IAST CListCN1
```
  Represents List(-1). Can be used to specify the "leaf" VisitorLevelSpecification of an expression.
- CListC0C0
```
public static final IAST CListC0C0
```
  Represents List(0,0)
- CListC1C1
```
public static final IAST CListC1C1
```
  Represents List(1,1)
- CListC1C2
```
public static final IAST CListC1C2
```
  Represents List(1,2)
- CListC2
```
public static final IAST CListC2
```
  Represents List(2)
- CListC2C1
```
public static final IAST CListC2C1
```
  Represents List(2,1)
- CListC2C2
```
public static final IAST CListC2C2
```
  Represents List(2,2)
- CInfinity
```
public static final IAST CInfinity
```
  Represents Infinity (i.e. Infinity->DirectedInfinity(1))
- CReturnFalse
```
public static final IAST CReturnFalse
```
  Represents Return(False)
- CReturnTrue
```
public static final IAST CReturnTrue
```
  Represents Return(True)
- CThrowFalse
```
public static final IAST CThrowFalse
```
  Represents Throw(False)
- CThrowTrue
```
public static final IAST CThrowTrue
```
  Represents Throw(True)
- oo
```
public static final IAST oo
```
  Alias for CInfinity. Represents Infinity (i.e. Infinity->DirectedInfinity(1))
- CNInfinity
```
public static final IAST CNInfinity
```
  Represents -Infinity (i.e. -Infinity->DirectedInfinity(-1))
- Noo
```
public static final IAST Noo
```
  Alias for CNInfinity. Represents -Infinity (i.e. -Infinity->DirectedInfinity(-1))
- CIInfinity
```
public static final IAST CIInfinity
```
  Represents I*Infinity (i.e. I*Infinity->DirectedInfinity(I))
- CNIInfinity
```
public static final IAST CNIInfinity
```
  Represents -I*Infinity (i.e. -I*Infinity->DirectedInfinity(-I))
- CComplexInfinity
```
public static final IAST CComplexInfinity
```
  Represents ComplexInfinity (i.e. ComplexInfinity->DirectedInfinity())
- CNPi
```
public static final IAST CNPi
```
  Represents -Pi as Symja expression Times(CN1, Pi)
- CN2Pi
```
public static final IAST CN2Pi
```
  Represents -2*Pi as Symja expression Times(CN2, Pi)
- C2Pi
```
public static final IAST C2Pi
```
  Represents 2*Pi as Symja expression Times(C2, Pi)
- CNPiHalf
```
public static final IAST CNPiHalf
```
  Represents -Pi/2 as Symja expression Times(CN1D2, Pi)
- CPiHalf
```
public static final IAST CPiHalf
```
  Represents Pi/2 as Symja expression Times(C1D2, Pi)
- CNPiThird
```
public static final IAST CNPiThird
```
  Represents -Pi/3 as Symja expression Times(CN1D3, Pi)
- CPiThird
```
public static final IAST CPiThird
```
  Represents Pi/3 as Symja expression Times(C1D3, Pi)
- CNPiQuarter
```
public static final IAST CNPiQuarter
```
  Represents -Pi/4 as Symja expression Times(CN1D4, Pi)
- CPiQuarter
```
public static final IAST CPiQuarter
```
  Represents Pi/4 as Symja expression Times(C1D4, Pi)
- CSqrtPi
```
public static final IAST CSqrtPi
```
  Represents Sqrt(Pi)
- CSqrt2
```
public static final IAST CSqrt2
```
  Represents Sqrt(2)
- CSqrt3
```
public static final IAST CSqrt3
```
  Represents Sqrt(3)
- CSqrt5
```
public static final IAST CSqrt5
```
  Represents Sqrt(5)
- CSqrt6
```
public static final IAST CSqrt6
```
  Represents Sqrt(6)
- CSqrt7
```
public static final IAST CSqrt7
```
  Represents Sqrt(7)
- CSqrt10
```
public static final IAST CSqrt10
```
  Represents Sqrt(10)
- C1DSqrt2
```
public static final IAST C1DSqrt2
```
  Represents 1/Sqrt(2)
- C1DSqrt3
```
public static final IAST C1DSqrt3
```
  Represents 1/Sqrt(3)
- C1DSqrt5
```
public static final IAST C1DSqrt5
```
  Represents 1/Sqrt(5)
- C1DSqrt6
```
public static final IAST C1DSqrt6
```
  Represents 1/Sqrt(6)
- C1DSqrt7
```
public static final IAST C1DSqrt7
```
  Represents 1/Sqrt(7)
- C1DSqrt10
```
public static final IAST C1DSqrt10
```
  Represents 1/Sqrt(10)
- Slot1
```
public static final IAST Slot1
```
  Represents #1, the first argument of a pure function.
- Slot2
```
public static final IAST Slot2
```
  Represents #2, the second argument of a pure function.
- Slot3
```
public static final IAST Slot3
```
  Represents #3, the third argument of a pure function.
- EXPR_FIELD
```
public static final org.hipparchus.Field<IExpr> EXPR_FIELD
```
- CN1
```
public static final IInteger CN1
```
  Constant integer "-1"
- CN2
```
public static final IInteger CN2
```
  Constant integer "-2"
- CN3
```
public static final IInteger CN3
```
  Constant integer "-3"
- CN4
```
public static final IInteger CN4
```
  Constant integer "-4"
- CN5
```
public static final IInteger CN5
```
  Constant integer "-5"
- CN6
```
public static final IInteger CN6
```
  Constant integer "-6"
- CN7
```
public static final IInteger CN7
```
  Constant integer "-7"
- CN8
```
public static final IInteger CN8
```
  Constant integer "-8"
- CN9
```
public static final IInteger CN9
```
  Constant integer "-9"
- CN10
```
public static final IInteger CN10
```
  Constant integer "-10"
- DENOMINATOR_NUMERATOR_SYMBOLS
```
public static final List<ISymbol> DENOMINATOR_NUMERATOR_SYMBOLS
```
- DENOMINATOR_TRIG_TRUE_EXPRS
```
public static final List<IExpr> DENOMINATOR_TRIG_TRUE_EXPRS
```
- NUMERATOR_NUMERATOR_SYMBOLS
```
public static final List<ISymbol> NUMERATOR_NUMERATOR_SYMBOLS
```
- NUMERATOR_TRIG_TRUE_EXPRS
```
public static final List<IExpr> NUMERATOR_TRIG_TRUE_EXPRS
```

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

Method Detail

isSystemInitialized

public static boolean isSystemInitialized()

getPredefinedInternalFormString

public static String getPredefinedInternalFormString(String key)

getPredefinedPattern

public static IPattern getPredefinedPattern(String key)

getPredefinedPatternSequence

public static IPatternSequence getPredefinedPatternSequence(String key)

getUnaryInverseFunction

public static IExpr getUnaryInverseFunction(IExpr symbol)

await
```
public static final void await()
                        throws InterruptedException
```
Causes the current thread to wait until the main initialization has finished.

Throws:

InterruptedException

$
```
public static final IASTMutable $(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:

$bs
```
public static PatternSequence $bs(IExpr condition)
```
Create a BlankSequence[condition] pattern object for pattern-matching and term rewriting

Parameters:

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

Returns:

IPattern

$bns
```
public static PatternSequence $bns(IExpr condition)
```
Create a BlankNullSequence[condition] pattern object for pattern-matching and term rewriting

Parameters:

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

Returns:

IPattern

$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:

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

Returns:

IPattern

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

Parameters:

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

def - if true use a default value in pattern-matching if an argument is optional

Returns:

IPattern

$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 matchDefaultValue)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

matchDefaultValue - 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(ISymbol symbol,
                          IExpr headerCheck)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbol -

headerCheck - additional condition which should be checked for the header of an expression in pattern-matching

Returns:

IPattern

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

Parameters:

symbol -

headerCheck - additional condition which should be checked for the header of an expression

matchDefaultValue - 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(String symbolName)
```
Create a pattern for pattern-matching and term rewriting

Parameters:

symbolName -

Returns:

IPattern

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

Parameters:

symbolName -

def - use a default value for this pattern if necessary

Returns:

IPattern

$p
```
public static IPattern $p(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(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

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

Parameters:

symbol -

Returns:

IPattern

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

Parameters:

symbol -

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

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

Returns:

IPattern

$ps
```
public static IPatternSequence $ps(ISymbol symbol)
```
Create a new PatternSequence BlankSequence.

Parameters:

symbol -

Returns:

IPattern

$ps
```
public static IPatternSequence $ps(ISymbol symbol,
                                   boolean zeroArgsAllowed)
```
Create a new PatternSequence BlankSequence or BlankNullSequence.

Parameters:

symbol - the associated symbol of the pattern sequence. Maybe null.

zeroArgsAllowed - if true, 0 arguments are allowed, otherwise the number of args has to be >= 1.

Returns:

$ps
```
public static IPatternSequence $ps(ISymbol symbol,
                                   IExpr check)
```
Create a new PatternSequence BlankSequence or BlankNullSequence.

Parameters:

symbol - the associated symbol of the pattern sequence. Maybe null.

check - a header check.Maybe null.

Returns:

IPatternSequence

$ps
```
public static IPatternSequence $ps(ISymbol symbol,
                                   IExpr check,
                                   boolean def,
                                   boolean zeroArgsAllowed)
```
Create a new PatternSequence BlankSequence or BlankNullSequence.

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

$OptionsPattern

public static IPatternSequence $OptionsPattern()

$OptionsPattern

public static IPatternSequence $OptionsPattern(ISymbol symbol)

$OptionsPattern

public static IPatternSequence $OptionsPattern(ISymbol symbol,
                                               IExpr defaultOptions)

$Repeated

public static IPatternSequence $Repeated(IExpr patternExpr,
                                         int min,
                                         int max,
                                         EvalEngine engine)

Parameters:: patternExpr -; min - if min==0 RepeatedNull is assumed; max -; engine -
Returns:

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

Parameters:

symbolName - the name of the pattrn symbol

Returns:

IPattern

SymbolQ

public static IAST SymbolQ(IExpr x)

 SymbolQ(x)

is True if x is a symbol, or False otherwise.

Examples

 >> SymbolQ(a)
 True
 >> SymbolQ(1)
 False
 >> SymbolQ(a + b)
 False

Symmetric

public static IAST Symmetric(IExpr a0)

Full symmetry

Parameters:: a0 -
Returns:

SymmetricMatrixQ

public static IAST SymmetricMatrixQ(IExpr a0)

See SymmetricMatrixQ

symjify

public static IExpr symjify(Object object)

Converts and evaluates arbitrary expressions to a Symja type.

 Java Object       -> Symja object
 -------------------------------------
 null object          S.Null symbol
 IExpr                IExpr type
 Boolean              S.True or S.False symbol
 BigInteger           IInteger value
 BigDecimal           INum with Apfloat(java.math.BigDecimal) value
 Double               INum  with doubleValue() value
 Float                INum  with doubleValue() value
 Integer              IInteger with intValue() value
 Long                 IInteger with longValue() value
 Number               INum with doubleValue() value
 java.util.Collection list of elements
                      1..nth element of the list give the elements of the List()
 Object[]             a list of converted objects
 int[]                a list of IInteger integer values
 double[]             a vector ASTRealVector of double values
 double[][]           a matrix ASTRealMatrix of double values
 Complex[]            a list of IComplexNum values
 boolean[]            a list of S.True or S.False symbols

Parameters:: object -
Returns:: the object converted to a IExpr}

symjify

public static IExpr symjify(Object object,
                            boolean evaluate)

Converts and evaluates arbitrary expressions to a Symja type.

 Java Object       -> Symja object
 -------------------------------------
 null object          S.Null symbol
 IExpr                IExpr type
 Boolean              S.True or S.False symbol
 BigInteger           IInteger value
 BigDecimal           INum with Apfloat(java.math.BigDecimal) value
 Double               INum  with doubleValue() value
 Float                INum  with doubleValue() value
 Integer              IInteger with intValue() value
 Long                 IInteger with longValue() value
 Number               INum with doubleValue() value
 java.util.Collection list of elements
                      1..nth element of the list give the elements of the List()
 Object[]             a list of converted objects
 int[]                a list of IInteger integer values
 double[]             a vector ASTRealVector of double values
 double[][]           a matrix ASTRealMatrix of double values
 Complex[]            a list of IComplexNum values
 boolean[]            a list of S.True or S.False symbols

Parameters:: object -; evaluate - if true evaluate the parsed string
Returns:: the object converted to an IExpr}

symjify
```
public static IExpr symjify(String str)
```
Parses and evaluates a Java string to a Symja expression. May throw an SyntaxError exception, if the string couldn't be parsed.

Parameters:

str - the expression which should be parsed

Returns:

Throws:

SyntaxError

symjify
```
public static IExpr symjify(String str,
                            boolean evaluate)
```
Parses a Java string to a Symja expression. May throw a SyntaxError exception, if the string couldn't be parsed.

Parameters:

str - the expression which should be parsed

evaluate - if true evaluate the parsed string

Returns:

Throws:

SyntaxError

symjify
```
public static IInteger symjify(long value)
```
Parameters:

value -

Returns:

IInteger integer value

symjify

public static INum symjify(double value)

Parameters:: value -
Returns:: INum double wrapper

symjify
```
public static IBuiltInSymbol symjify(boolean value)
```
Return S.True or S.False symbol

Parameters:

value -

Returns:

S.True or S.False symbol

$s
```
public static ISymbol $s(String symbolName)
```
Get or create a global predefined symbol which is retrieved from the SYSTEM context map or created or retrieved from the SYSTEM context variables map.

Parameters:

symbolName - the name of the symbol

$rubi

public static ISymbol $rubi(String symbolName)

$rubi

public static ISymbol $rubi(String symbolName,
                            IEvaluator evaluator)

symbolNameNormalized

public static String symbolNameNormalized(String symbolName)

$str

public static final IStringX $str(char ch)

$str

public static final IStringX $str(String str)

Create a string expression

Parameters:: str -
Returns:

$str

public static final IStringX $str(String str,
                                  short mimeType)

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

AbsoluteCorrelation

public static IAST AbsoluteCorrelation(IExpr a0,
                                       IExpr a1)

AddSides

public static IASTMutable AddSides(IExpr equationOrInequality,
                                   IExpr a1)

Alternatives

public static IAST Alternatives(IExpr... a)

and

public static IExpr and(IExpr a,
                        Integer i)

and

public static IExpr and(IExpr a,
                        BigInteger i)

and

public static IExpr and(Integer i,
                        IExpr b)

and

public static IExpr and(BigInteger i,
                        IExpr b)

And
```
public static IASTAppendable And()
```

AmbientLight

public static IASTMutable AmbientLight(IExpr color)

And
```
public static IAST And(IExpr... expr)
```
expr1 && expr2 && expr3 ... evaluates each expression in turn, returning S.False as soon as an expression evaluates to S.False. If all expressions evaluate to S.True, it returns S.True.
See: And

Parameters:

expr -

Returns:

And
```
public static IAST And(IExpr expr1,
                       IExpr expr2)
```
expr1 && expr2 evaluates each expression in turn, returning S.False as soon as an expression evaluates to S.False. If all expressions evaluate to S.True, it returns S.True.
See: And

Parameters:

expr1 -

expr2 -

Returns:

And
```
public static IAST And(IExpr expr1,
                       IExpr expr2,
                       IExpr expr3)
```
expr1 && expr2 && expr3 evaluates each expression in turn, returning S.False as soon as an expression evaluates to S.False. If all expressions evaluate to S.True, it returns S.True.
See: And

Parameters:

expr1 -

expr2 -

expr3 -

Returns:

AngleVector

public static IAST AngleVector(IExpr a0)

AntiSymmetric

public static IAST AntiSymmetric(IExpr a0)

Apart

public static IAST Apart(IExpr a0)

Apart

public static IAST Apart(IExpr a0,
                         IExpr a1)

AppellF1

public static IAST AppellF1(IExpr a,
                            IExpr b1,
                            IExpr b2,
                            IExpr c,
                            IExpr z1,
                            IExpr z2)

Append

public static IAST Append(IExpr a0,
                          IExpr a1)

AppendTo

public static IAST AppendTo(IExpr a0,
                            IExpr a1)

Apply

public static IASTMutable Apply(IExpr a0,
                                IExpr a1)

Operator @@

Parameters:: a0 -; a1 -
Returns:

ApplySides

public static IASTMutable ApplySides(IExpr a0,
                                     IExpr equationOrInequality)

ApplyListC1

public static IASTMutable ApplyListC1(IExpr a0,
                                      IExpr a1)

Operator @@@

Parameters:: a0 -; a1 -
Returns:

AiryAi

public static IAST AiryAi(IExpr a0)

AiryAiPrime

public static IAST AiryAiPrime(IExpr a0)

AiryBi

public static IAST AiryBi(IExpr a0)

AiryBiPrime

public static IAST AiryBiPrime(IExpr a0)

Array

public static IAST Array(IExpr a0,
                         IExpr a1)

Arrays

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

Arrays

public static IAST Arrays(IExpr a0,
                          IExpr a1)

Arrays

public static IAST Arrays(IExpr a0)

ArcCos

public static IAST ArcCos(IExpr z)

ArcCosh

public static IAST ArcCosh(IExpr z)

ArcCot

public static IAST ArcCot(IExpr z)

ArcCoth

public static IAST ArcCoth(IExpr z)

ArcCsc

public static IAST ArcCsc(IExpr z)

ArcCsch

public static IAST ArcCsch(IExpr z)

ArcSec

public static IAST ArcSec(IExpr z)

ArcSech

public static IAST ArcSech(IExpr z)

ArcSin

public static IAST ArcSin(IExpr z)

ArcSinh

public static IAST ArcSinh(IExpr z)

ArcTan

public static IAST ArcTan(IExpr z)

ArcTan

public static IAST ArcTan(IExpr x,
                          IExpr y)

ArcTanh

public static IAST ArcTanh(IExpr z)

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

ArrayQ

public static IAST ArrayQ(IExpr a0)

 'ArrayQ(expr)

tests whether expr is a full array.

 'ArrayQ(expr, pattern)

also tests whether the array depth of expr matches pattern.

 'ArrayQ(expr, pattern, test)

furthermore tests whether test yields True for all elements of expr.

Examples

 >> ArrayQ(a)
 False
 >> ArrayQ({a})
 True
 >> ArrayQ({{{a}},{{b,c}}})
 False
 >> ArrayQ({{a, b}, {c, d}}, 2, SymbolQ)
 True

Arrays
```
public static IAST Arrays(IAST dimension)
```
The domain of arrays.

Parameters:

dimension -

Returns:

Arrays(dimensions, Complexes, {}).

Arrays

public static IAST Arrays(IAST dimension,
                          ISymbol domain)

The domain of arrays.

Parameters:: dimension -; domain -
Returns:: Arrays(dimensions, domain, {}).

Arrays

public static IAST Arrays(IAST dimension,
                          ISymbol domain,
                          IAST symmetry)

The domain of arrays.

Parameters:: dimension -; domain -; symmetry -
Returns:: Arrays(dimensions, domain, symmetry).

ArithmeticGeometricMean

public static IAST ArithmeticGeometricMean(IExpr a0,
                                           IExpr a1)

assoc
```
public static IAssociation assoc(IAST listOfRules)
```
Create an association data structure <| x0->y0, x1->y1, ... |> from a list of rules {x0->y0, x1->y1, ... }.

Parameters:

listOfRules - a list of rules {x0->y0, x1->y1, ... }

Returns:

assoc
```
public static IAssociation assoc(IAssociation templateAssociation,
                                 Map<IExpr,IASTMutable> mapOfRules)
```
Create an association data structure <| x0->y0, x1->y1, ... |> from a map of rules.

Parameters:

templateAssociation - the template association, which determines the type of rule (Rule or RuleDelayed and the key of the new rule.

mapOfRules - a map of keys to IASTMutable values

Returns:

assoc
```
public static IAssociation assoc()
```

sparseArray
```
public static ISparseArray sparseArray(IAST arrayRulesList)
```
Create a sparse array from the list of rules.
See: SparseArray

Parameters:

arrayRulesList -

Returns:

a ISparseArray instance

sparseArray
```
public static ISparseArray sparseArray(IAST arrayRulesList,
                                       int[] dimension)
```
Create a sparse array in the given dimension from the list of rules.
See: SparseArray

Parameters:

arrayRulesList -

dimension -

Returns:

a ISparseArray instance

sparseArray
```
public static ISparseArray sparseArray(IAST denseList,
                                       IExpr defaultValue)
```
Create a sparse array from the dense list representation (for example dense vectors and matrices)

Parameters:

denseList -

defaultValue - default value for positions not specified in the dense list representation.

Returns:

null if a new SparseArrayExpr cannot be created

sparseMatrix
```
public static ISparseArray sparseMatrix(BiIntFunction<? extends IExpr> binaryFunction,
                                        int n,
                                        int m)
```
Generate a n x m sparse matrix. The indices start in Java convention with 0.

Parameters:

binaryFunction - if the returned value unequals 0, the value will be stored in the sparse matrix

n - the number of rows of the matrix.

m - the number of columns of the matrix.

Returns:

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 IASTAppendable ast(IExpr head)
```
Create a new abstract syntax tree (AST).

Parameters:

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

ast
```
public static IASTAppendable ast(IExpr head,
                                 int initialCapacity)
```
Create a new abstract syntax tree (AST). Elements can be added to the end of the created AST instance with the IASTAppendable.append(IExpr) method.

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.

Returns:

ast
```
@Deprecated
public static IASTAppendable ast(IExpr head,
                                 int initialCapacity,
                                 boolean initNull)
```
Deprecated.
use ast(IExpr, int) or astMutable(IExpr, int)

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 IASTAppendable ast(IExpr head,
                                 Collection<? extends IExpr> collection)
```
Create a new abstract syntax tree (AST). Elements can be added at the end of the created AST instance with the IASTAppendable.append(IExpr) method.

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.

collection - the collection which holds the elements which should be appended

Returns:

ast
```
public static IASTAppendable ast(IExpr head,
                                 Collection<? extends IExpr> collection,
                                 int initialCapacity)
```
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.

collection - the collection which holds the elements which should be appended

initialCapacity - the additional capacity added to the collections size (i.e. number of arguments without the header element) of the list.

Returns:

astMutable
```
public static IASTMutable astMutable(IExpr head,
                                     int initialCapacity)
```
Create a new abstract syntax tree (AST) with pre- allocated elements set to null. Elements can be set in the created AST instance with the IASTMutable.set(int, IExpr) method.

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.

Returns:

constantArray
```
public static IASTAppendable constantArray(IExpr value,
                                           int copies)
```
Create a new List() with copies number of arguments, which are set to value.

Parameters:

value - initialize all elements with value.

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

Returns:

constantArray
```
public static IASTAppendable constantArray(IExpr head,
                                           IExpr value,
                                           int copies)
```
Create a new abstract syntax tree (AST) with a head and copies number of arguments, which are set to value.

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.

value - initialize all elements with value.

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

Returns:

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

Parameters:

arr - an array of arguments for this function expression

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:

ast
```
public static IASTAppendable ast(ISymbol head,
                                 int[] arr)
```
Create a new function expression (AST - abstract syntax tree), where all arguments are Java int values.

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.

arr - the integer arguments of the function expression

Returns:

ast
```
public static IASTAppendable ast(ISymbol head,
                                 org.hipparchus.complex.Complex[] arr)
```
Create a new function expression (AST - abstract syntax tree), where all arguments are Java org.hipparchus.complex.Complex values.

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.

arr - the org.hipparchus.complex.Complex arguments of the function expression

Returns:

ast
```
public static IASTAppendable ast(ISymbol head,
                                 boolean evalComplex,
                                 org.hipparchus.complex.Complex[] arr)
```
Create a new function expression (AST - abstract syntax tree), where all arguments are Java ComplexNum values.

Parameters:

head -

evalComplex - if true test if the imaginary part of the complex number is zero and insert a Num real value.

arr - the complex number arguments

Returns:

AtomQ

public static IAST AtomQ(IExpr a)

 AtomQ(x)

is true if x is an atom (an object such as a number or string, which cannot be divided into subexpressions using 'Part').

Examples

 >> AtomQ(x)
 True

 >> AtomQ(1.2)
 True

 >> AtomQ(2 + I)
 True

 >> AtomQ(2 / 3)
 True

 >> AtomQ(x + y)
 False

Attributes

public static IAST Attributes(IExpr a)

BaseForm

public static IAST BaseForm(IExpr a0,
                            IExpr a1)

BellB

public static IAST BellB(IExpr a0)

Bell number.

Parameters:: a0 -
Returns:

BellB

public static IAST BellB(IExpr a0,
                         IExpr a1)

Bell polynomial.

Parameters:: a0 -; a1 -
Returns:

BellY

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

BernoulliB

public static IAST BernoulliB(IExpr a0)

BernoulliB

public static IAST BernoulliB(IExpr a0,
                              IExpr a1)

BernoulliDistribution

public static IAST BernoulliDistribution(IExpr a0)

binary

public static final IASTAppendable binary(IExpr head,
                                          IExpr arg1,
                                          IExpr arg2)

Create a function head(arg1, arg2) with 2 arguments without evaluation.

Parameters:: head -; arg1 -; arg2 -
Returns:

binaryAST2

public static final IASTMutable binaryAST2(IExpr head,
                                           IExpr arg1,
                                           IExpr arg2)

Create a function head(arg1, arg2) with 2 argument as an AST2 mutable object without evaluation.

Parameters:: head -; arg1 -; arg2 -
Returns:

binaryAST2

public static final IASTMutable binaryAST2(IExpr head,
                                           String arg1,
                                           IExpr arg2)

binaryAST2

public static final IASTMutable binaryAST2(IExpr head,
                                           String arg1,
                                           String arg2)

Binomial

public static IAST Binomial(IExpr a0,
                            IExpr a1)

Binomial

public static IAST Binomial(int a0,
                            int a1)

BlankSequence
```
public static IAST BlankSequence()
```

Block

public static IAST Block(IExpr a0,
                         IExpr a1)

bool
```
@Deprecated
public static ISymbol bool(boolean value)
```
Deprecated.
use booleSymbol(boolean) instead

Returns symbol "True" or "False" (type ISymbol) depending on the boolean value.

Parameters:

value -

Returns:

booleSymbol
```
public static ISymbol booleSymbol(boolean value)
```
Returns symbol "True" or "False" (type ISymbol) depending on the boolean value.

Parameters:

value -

Returns:

booleInteger
```
public static IInteger booleInteger(boolean value)
```
Returns integers 1 or 0 (type ISymbol) depending on the boolean value true or false.

Parameters:

value -

Returns:

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

BooleanConvert

public static IAST BooleanConvert(IExpr a0,
                                  IExpr a1)

BooleanQ

public static IAST BooleanQ(IExpr a)

 BooleanQ(expr)

returns True if expr is either True or False.

Examples

 >> BooleanQ(True)
 True
 >> BooleanQ(False)
 True
 >> BooleanQ(a)
 False
 >> BooleanQ(1 < 2)
 True
 >> BooleanQ("string")
 False
 >> BooleanQ(Together(x/y + y/x))
 False

BooleanMinimize

public static IAST BooleanMinimize(IExpr a)

BooleanTable

public static IAST BooleanTable(IExpr a0,
                                IExpr a1)

BooleanVariables

public static IAST BooleanVariables(IExpr a0)

BesselI

public static IAST BesselI(IExpr a0,
                           IExpr a1)

BesselJ

public static IAST BesselJ(IExpr a0,
                           IExpr a1)

BesselY

public static IAST BesselY(IExpr a0,
                           IExpr a1)

BesselK

public static IAST BesselK(IExpr a0,
                           IExpr a1)

Beta

public static IAST Beta(IExpr a0,
                        IExpr a1)

Beta

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

BetaRegularized

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

BetaRegularized

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

BinomialDistribution

public static IAST BinomialDistribution(IExpr a0,
                                        IExpr a1)

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

BrownianBridgeProcess

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

C
```
public static IAST C(int index)
```

Cancel

public static IAST Cancel(IExpr a)

CancelButton
```
public static IAST CancelButton()
```

CarlsonRC

public static IAST CarlsonRC(IExpr a0,
                             IExpr a1)

CarlsonRD

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

CarlsonRF

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

CarlsonRG

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

CarmichaelLambda

public static IAST CarmichaelLambda(IExpr a0)

cast

public static IExpr cast(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:

CatalanNumber

public static IAST CatalanNumber(IExpr a)

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

CauchyDistribution

public static IAST CauchyDistribution(IExpr a0,
                                      IExpr a1)

CC
```
public static IComplex CC(IFraction re)
```
Create a symbolic complex number re + I * 0

Parameters:

re -

Returns:

CC
```
public static IComplex CC(IRational real,
                          IRational imag)
```
Create a symbolic complex number real + I * imag

Parameters:

real - the real part of the complex number

imag - the imaginary part of the complex number

Returns:

CC

public static IComplex CC(long realNumerator,
                          long realDenominator,
                          long imagNumerator,
                          long imagDenominator)

Create a symbolic complex number (realNumerator/realDenominator) + I * (imagNumerator/imagDenominator)

Parameters:: realNumerator -; realDenominator -; imagNumerator -; imagDenominator -
Returns:

CC
```
public static IComplex CC(long real,
                          long imag)
```
Create a symbolic complex number real + I * imag.

Parameters:

real - the real part of the complex number

imag - the imaginary part of the complex number

Returns:

CDF

public static IAST CDF(IExpr distribution)

CDF

public static IAST CDF(IExpr distribution,
                       IExpr a1)

Ceiling

public static IAST Ceiling(IExpr z)

ChebyshevT

public static IAST ChebyshevT(IExpr a0,
                              IExpr a1)

ChebyshevU

public static IAST ChebyshevU(IExpr a0,
                              IExpr a1)

CharacteristicPolynomial
```
public static IAST CharacteristicPolynomial(IExpr matrix,
                                            IExpr variable)
```
CharacteristicPolynomial(matrix, var) - computes the characteristic polynomial of a `matrix` for the variable `var`.

See Also:

CharacteristicPolynomial documentation

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

chopExpr

public static IExpr chopExpr(IExpr arg,
                             double delta)

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 the number should be set to zero

Returns:

arg if the argument couldn't be chopped

chopComplex
```
public static org.hipparchus.complex.Complex chopComplex(org.hipparchus.complex.Complex arg)
```
Set real or imaginary parts of a numeric argument to zero, those absolute value is less than Config.DEFAULT_CHOP_DELTA

Parameters:

arg - a numeric number

Returns:

arg if the argument couldn't be chopped

chopComplex
```
public static org.hipparchus.complex.Complex chopComplex(org.hipparchus.complex.Complex 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 the number should be set to zero

Returns:

arg if the argument couldn't be chopped

Circle

public static IAST Circle(IAST originList)

CentralMoment

public static IAST CentralMoment(IExpr a0,
                                 IExpr a1)

Clear

public static IAST Clear(IExpr... a)

ClearAttributes

public static IAST ClearAttributes(IExpr a0,
                                   IExpr a1)

ClebschGordan

public static final IAST ClebschGordan(IExpr arg1,
                                       IExpr arg2,
                                       IExpr arg3)

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

Clip

public static IAST Clip(IExpr a0,
                        IExpr a1)

Coefficient

public static IAST Coefficient(IExpr a0,
                               IExpr a1)

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)

Colon

public static IAST Colon(IExpr a0,
                         IExpr a1)

compareTo

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

Throws:: UnsupportedOperationException

compareTo

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

Throws:: UnsupportedOperationException

compareTo

public static int compareTo(IExpr a,
                            BigInteger i)
                     throws UnsupportedOperationException

Throws:: UnsupportedOperationException

compareTo

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

Throws:: UnsupportedOperationException

compareTo

public static int compareTo(BigInteger i,
                            IExpr b)
                     throws UnsupportedOperationException

Throws:: UnsupportedOperationException

Compile

public static IAST Compile(IExpr a0,
                           IExpr a1)

CompilePrint

public static IAST CompilePrint(IExpr a0,
                                IExpr a1)

Complement

public static IAST Complement(IExpr a0,
                              IExpr a1)

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:

IComplex

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

Parameters:

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

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

epsilon -

Returns:

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

Parameters:

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

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

Returns:

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:: real_numerator -; real_denominator -; imag_numerator -; imag_denominator -
Returns:

Complex

public static IAST Complex(IExpr a0,
                           IExpr a1)

Create a Complex(a, b) AST symbolic expression.

Parameters:: a0 -; a1 -
Returns:

complexNum
```
public static IComplexNum complexNum(org.apfloat.Apcomplex c)
```
Return a ApcomplexNum which wraps a Apcomplex arbitrary precision floating-point complex number.

Parameters:

c -

Returns:

complexNum
```
public static IComplexNum complexNum(org.apfloat.Apfloat realPart)
```
Return a ApcomplexNum which wraps two Apfloat arbitrary precision floating-point numbers for the real and imaginary part with imaginary part set to 0.

Parameters:

realPart -

Returns:

a ApcomplexNum which wraps two Apfloat arbitrary precision floating-point numbers for the real and imaginary part with imaginary part set to 0.

complexNum
```
public static IComplexNum complexNum(org.apfloat.Apfloat realPart,
                                     org.apfloat.Apfloat imaginaryPart)
```
Return a ApcomplexNum which wraps two Apfloat arbitrary precision floating-point numbers for the real and imaginary part.

Parameters:

realPart -

imaginaryPart -

Returns:

a ApcomplexNum which wraps two Apfloat arbitrary precision floating-point numbers for the real and imaginary part.

complexNum
```
public static IComplexNum complexNum(String realPart,
                                     String imaginaryPart,
                                     long precision)
```
Return a ApcomplexNum which wraps two Apfloat arbitrary precision floating-point numbers for the real and imaginary part.

Parameters:

realPart -

imaginaryPart -

precision -

Returns:

a ApcomplexNum which wraps two Apfloat arbitrary precision floating-point numbers for the real and imaginary part.

complexNum
```
public static IComplexNum complexNum(org.hipparchus.complex.Complex c)
```
Return a ComplexNum which wraps a Complex number with Java double values for the real and imaginary part.

Parameters:

c -

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:

a complex numeric number with imaginary part = 0.0

complexNum

public static IComplexNum complexNum(double r,
                                     double i)

Create a complex numeric value

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

complexNum

public static IComplexNum complexNum(IComplex value)

complexNum

public static IComplexNum complexNum(IFraction value)

complexNum

public static IComplexNum complexNum(IInteger value)

cse
```
public static IAST cse(IExpr expr)
```
Perform "common subexpression elimination" (CSE) on an expression.

Parameters:

expr -

Returns:

the pair of {shared-expressions, recursive-replacement-rules}

cse
```
public static IAST cse(IExpr expr,
                       Supplier<String> variablePrefix)
```
Perform "common subexpression elimination" (CSE) on an expression.

Parameters:

expr -

variablePrefix - the prefix string, which should be used for the variable names

Returns:

the pair of {shared-expressions, recursive-replacement-rules}

cseAsJava
```
public static void cseAsJava(IExpr expr,
                             StringBuilder buf)
```
Perform "common subexpression elimination" (CSE) on an expression and create Java source code in the given StringBuilder.

Parameters:

expr -

buf -

cseAsJava
```
public static void cseAsJava(IExpr expr,
                             Supplier<String> variablePrefix,
                             StringBuilder buf)
```
Perform "common subexpression elimination" (CSE) on an expression and create Java source code in the given StringBuilder.

Parameters:

expr -

variablePrefix - the prefix string, which should be used for the variable names

buf -

CompoundExpression
```
public static IAST CompoundExpression(IExpr... expr)
```
Evaluates its arguments in turn, returning the last result.
See: CompoundExpression

Parameters:

expr - a list of expressions

Returns:

function
```
public static IASTMutable function(IExpr head,
                                   IExpr... a)
```
Create a new abstract syntax tree (AST).

Parameters:

head - the header symbol 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:

Condition
```
public static IAST Condition(IExpr pattern,
                             IExpr test)
```
Places an additional constraint on pattern that only allows it to match if test evaluates to S.True.
See: Condition

Parameters:

pattern -

test -

Returns:

ConditionalExpression

public static IAST ConditionalExpression(IExpr expr,
                                         IExpr condition)

Cone

public static IAST Cone(IExpr matrix)

Cone

public static IAST Cone(IExpr matrix,
                        IExpr radius)

Conjugate

public static IAST Conjugate(IExpr a0)

ConstantArray

public static IAST ConstantArray(IExpr a0,
                                 IExpr a1)

ConjugateTranspose

public static IAST ConjugateTranspose(IExpr a0)

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

ContinuedFraction

public static IAST ContinuedFraction(IExpr a0)

CoordinateBoundingBox

public static IAST CoordinateBoundingBox(IExpr a0)

CoordinateBounds

public static IAST CoordinateBounds(IExpr a0)

CoplanarPoints

public static IAST CoplanarPoints(IExpr a0)

CoprimeQ

public static IAST CoprimeQ(IExpr a0,
                            IExpr a1)

Cos
```
public static IAST Cos(IExpr z)
```
Returns the cosine of z (measured in Radians).
See: Cos

Parameters:

z -

Returns:

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

CoshIntegral

public static IAST CoshIntegral(IExpr z)

CosIntegral

public static IAST CosIntegral(IExpr z)

Cot
```
public static IAST Cot(IExpr z)
```
Returns the cotangent of z (measured in Radians).
See: Cot

Parameters:

z -

Returns:

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

Count

public static IAST Count(IExpr a0,
                         IExpr a1)

Count

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

Covariance

public static IAST Covariance(IExpr a0,
                              IExpr a1)

Cross

public static IAST Cross(IExpr a0,
                         IExpr a1)

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

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

Cube

public static IAST Cube(IExpr center,
                        IExpr length)

CubeRoot

public static IAST CubeRoot(IExpr arg)

Cuboid

public static IAST Cuboid(IExpr pMin,
                          IExpr pMax)

Parameters:: pMin - lower corner; pMax - upper corner
Returns:

Cycles

public static IAST Cycles(IExpr a0)

Cylinder

public static IAST Cylinder(IExpr matrix)

Cylinder

public static IAST Cylinder(IExpr matrix,
                            IExpr radius)

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

D

public static IAST D(IExpr f,
                     IExpr x)

Dashing

public static IAST Dashing(IExpr a)

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

Depth

public static IAST Depth(IExpr a0)

Derivative

public static IAST Derivative(IExpr... a)

DesignMatrix

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

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

DialogReturn
```
public static IAST DialogReturn()
```

DialogReturn

public static IAST DialogReturn(IExpr a0)

DiagonalMatrix

public static IAST DiagonalMatrix(IExpr a0)

DiagonalMatrix

public static IAST DiagonalMatrix(IExpr a0,
                                  IExpr a1)

DiagonalMatrixQ

public static IAST DiagonalMatrixQ(IExpr a0)

DiagonalMatrixQ

public static IAST DiagonalMatrixQ(IExpr a0,
                                   IExpr a1)

DigitQ

public static IAST DigitQ(IExpr a0)

 DigitQ(str)

returns True if str is a string which contains only digits.

Examples

 >> DigitQ("1234")
 True

Dimensions

public static IAST Dimensions(IExpr a0)

 Dimensions(expr)

returns a list of the dimensions of the expression expr.

Examples

A vector of length 3:

 >> Dimensions({a, b, c})
  = {3}

A 3x2 matrix:

 >> Dimensions({{a, b}, {c, d}, {e, f}})
  = {3, 2}

Ragged arrays are not taken into account:

 >> Dimensions({{a, b}, {b, c}, {c, d, e}})
 {3}

The expression can have any head:

 >> Dimensions[f[f[a, b, c]]]
 {1, 3}
 >> Dimensions({})
 {0}
 >> Dimensions({{}})
 {1, 0}

DiracDelta

public static IAST DiracDelta(IExpr a0)

DirectedEdge

public static IAST DirectedEdge(IExpr a,
                                IExpr b)

DirectedEdge is a directed edge from vertex ab See: DirectedEdge

Parameters:: a -; b -
Returns:

DirectedInfinity

public static IAST DirectedInfinity(IExpr a0)

Disk

public static IAST Disk(IAST originList)

DiscreteDelta

public static IAST DiscreteDelta(IExpr a)

DiscreteUniformDistribution

public static IAST DiscreteUniformDistribution(IExpr a)

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)

Distributed

public static IAST Distributed(IExpr x,
                               IAST distribution)

Create a Distributed(x, <distribution>) AST.

Parameters:: x -; distribution -
Returns:

div

public static IExpr div(IExpr a,
                        Integer i)

div

public static IExpr div(IExpr a,
                        BigInteger i)

div

public static IExpr div(Integer i,
                        IExpr b)

div

public static IExpr div(BigInteger i,
                        IExpr b)

DirectionalLight

public static IASTMutable DirectionalLight(IExpr color,
                                           IExpr point)

Divide
```
public static IExpr Divide(IExpr numerator,
                           IExpr denominator)
```
The division numerator / denominator will be represented by numerator * denominator^(-1). If numerator.isOne()==true return denominator^(-1). If denominator.isOne()==true return numerator.

Parameters:

numerator - numerator

denominator - denominator

Returns:

Divide
```
public static IExpr Divide(int numerator,
                           IExpr denominator)
```
The division numerator / denominator will be represented by numerator * denominator^(-1). If numerator.isOne()==true return denominator^(-1). If denominator.isOne()==true return numerator.

Parameters:

numerator -

denominator -

Returns:

Divide
```
public static IExpr Divide(IExpr numerator,
                           int denominator)
```
The division numerator / denominator will be represented by numerator * denominator^(-1). If numerator.isOne()==true return denominator^(-1). If denominator.isOne()==true return numerator.

Parameters:

numerator -

denominator -

Returns:

DivideSides

public static IASTMutable DivideSides(IExpr equationOrInequality)

DivideSides

public static IASTMutable DivideSides(IExpr equationOrInequality,
                                      IExpr a1)

Divisible

public static IAST Divisible(IExpr a0,
                             IExpr a1)

DivisorSigma

public static IAST DivisorSigma(IExpr a0,
                                IExpr a1)

Divisors

public static IAST Divisors(IExpr a0)

Do

public static IAST Do(IExpr a0,
                      IExpr a1)

Dot

public static IAST Dot(IExpr... a)

Dot

public static IAST Dot(IExpr a,
                       IExpr b)

Dot

public static IAST Dot(IExpr a,
                       IExpr b,
                       IExpr c)

Drop

public static IAST Drop(IExpr list,
                        IExpr a1)

Drop

public static IAST Drop(IExpr list,
                        IExpr a1,
                        IExpr a2)

DSolve

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

Eigensystem

public static IAST Eigensystem(IExpr m)

Eigenvalues

public static IAST Eigenvalues(IExpr m)

Eigenvectors

public static IAST Eigenvectors(IExpr m)

Element
```
public static IAST Element(IExpr variable,
                           IExpr domain)
```
Set a domain as an assumption for a variable.

Parameters:

variable - the variable for which an assumption should be defined

domain - very often used domains are S.Booleans, S.Integers, S.Reals

Returns:

ElementData

public static IAST ElementData(IExpr name,
                               IExpr property)

Property of a name chemical element.

Parameters:: name -; property -
Returns:

Eliminate

public static IAST Eliminate(IExpr a0,
                             IExpr a1)

EllipticE

public static IAST EllipticE(IExpr m)

EllipticE

public static IAST EllipticE(IExpr phi,
                             IExpr m)

EllipticF

public static IAST EllipticF(IExpr phi,
                             IExpr m)

EllipticK

public static IAST EllipticK(IExpr m)

EllipticPi

public static IAST EllipticPi(IExpr n,
                              IExpr m)

EllipticPi

public static IAST EllipticPi(IExpr n,
                              IExpr phi,
                              IExpr m)

Equal

public static IAST Equal(IExpr... a)

Equal
```
public static IAST Equal(IExpr lhs,
                         IExpr rhs)
```
Yields S.True if lhs and rhs are known to be equal, or S.False if lhs and rhs are known to be unequal.
See: Equal

Parameters:

lhs -

rhs -

Returns:

Equal
```
public static IAST Equal(IExpr lhs,
                         int rhs)
```
Yields S.True if lhs and rhs are known to be equal, or S.False if lhs and rhs are known to be unequal.
See: Equal

Parameters:

lhs -

rhs -

Returns:

Equivalent

public static IAST Equivalent(IExpr lhs,
                              IExpr rhs)

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

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

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

ErlangDistribution

public static IAST ErlangDistribution(IExpr a0,
                                      IExpr a1)

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)

eval
```
public static IExpr eval(String str)
```
Parse and evaluate a string expression.

Parameters:

str - the string expression which should be parsed and evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

evalExpand
```
public static IExpr evalExpand(IExpr expr)
```
Evaluate Expand() for the given expression. Returns the evaluated expression or the given argument.

Parameters:

expr - the expression which should be evaluated

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

evalCollect

public static IExpr evalCollect(IExpr expr,
                                IExpr x)

evalSimplify

public static IExpr evalSimplify(IExpr expr)

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)

evalExpandAll
```
public static IExpr evalExpandAll(IExpr a,
                                  EvalEngine engine)
```
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)

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

Evaluate the given expression in numeric mode

Parameters:

a0 -

Returns:

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:

a - the expression which should be evaluated

Returns:

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

See Also:

EvalEngine.evalQuietNIL(IExpr)

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

 EvenQ(x)

returns True if x is even, and False otherwise.

Examples

 >> EvenQ(4)
 True
 >> EvenQ(-3)
 False
 >> EvenQ(n)
 False

ExactNumberQ

public static IAST ExactNumberQ(IExpr expr)

 ExactNumberQ(expr)

returns True if expr is an exact number, and False otherwise.

Examples

 >> ExactNumberQ(10)
 True

 >> ExactNumberQ(4.0)
 False

 >> ExactNumberQ(n)
 False

 >> ExactNumberQ(1+I)
 True

 >> ExactNumberQ(1 + 1. * I)
 False

Exists

public static IAST Exists(IExpr a0,
                          IExpr a1)

Exists

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

expr
```
public static IReal expr(Number number)
```
depending on the derived class of the given Number, the value is encoded as IInteger, INum

Parameters:

number - non-null

Returns:

scalar with best possible accuracy to encode given number

Throws:

Exception - if number is null, or instance of an unsupported type

EuclideanDistance

public static IAST EuclideanDistance(IExpr a0,
                                     IExpr a1)

EulerE

public static IAST EulerE(IExpr n)

EulerE

public static IAST EulerE(IExpr n,
                          IExpr x)

EulerPhi

public static IAST EulerPhi(IExpr a0)

Exp
```
public static IAST Exp(IExpr z)
```
The exponential function E^z.
See: Exp

Parameters:

z -

Returns:

Exp
```
public static IAST Exp(int z)
```

ExpToTrig

public static IAST ExpToTrig(IExpr a0)

expand
```
public static IExpr expand(IExpr a,
                           boolean expandNegativePowers,
                           boolean distributePlus,
                           boolean evalParts)
```
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 -

distributePlus -

evalParts - evaluate the determined numerator and denominator parts

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

Expand
```
public static IAST Expand(IExpr expr)
```
Expands out positive rational powers and products of sums in expr.
See: Expand

Parameters:

expr -

Returns:

Expand

public static IAST Expand(IExpr expr,
                          IExpr pattern)

Expands out positive rational powers and products of sums in expr.

See: Expand

Parameters:: expr -; pattern -
Returns:

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 -

distributePlus -

Returns:

the evaluated expression

See Also:

EvalEngine.evaluate(IExpr)

ExpandAll

public static IAST ExpandAll(IExpr a0)

ExpIntegralE

public static IAST ExpIntegralE(IExpr a0,
                                IExpr a1)

ExpIntegralEi

public static IAST ExpIntegralEi(IExpr a)

Exponent

public static IAST Exponent(IExpr a0,
                            IExpr a1)

Exponent

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

ExponentialDistribution

public static IAST ExponentialDistribution(IExpr a0)

ExportString

public static IAST ExportString(IExpr a0,
                                IExpr a1)

Extract

public static IAST Extract(IExpr a0,
                           IExpr a1)

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

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

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

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

Factor

public static IAST Factor(IExpr poly)

FactorTerms

public static IAST FactorTerms(IExpr poly)

Factorial

public static IAST Factorial(IExpr a0)

Factorial

public static IAST Factorial(int a0)

Factorial2

public static IAST Factorial2(IExpr a0)

FactorialPower

public static IAST FactorialPower(IExpr x,
                                  IExpr n)

FactorialPower

public static IAST FactorialPower(IExpr x,
                                  IExpr n,
                                  IExpr h)

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)

Fibonacci

public static IAST Fibonacci(IExpr a0,
                             IExpr a1)

FindFit

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

FindMaximum

public static IAST FindMaximum(IExpr f,
                               IExpr x)

FindMinimum

public static IAST FindMinimum(IExpr f,
                               IExpr x)

FindRoot

public static IAST FindRoot(IExpr f,
                            IExpr x)

FindShortestPath

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

FindShortestTour

public static IAST FindShortestTour(IExpr a0)

FindSpanningTree

public static IAST FindSpanningTree(IExpr a0)

Fit

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

FiveNum

public static IAST FiveNum(IExpr a)

First

public static IAST First(IExpr a0)

Flatten

public static IAST Flatten(IExpr a0)

Flatten

public static IAST Flatten(IExpr a0,
                           IExpr a1)

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

Fold

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

ForAll

public static IAST ForAll(IExpr a0,
                          IExpr a1)

ForAll

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

fraction
```
public static IFraction fraction(org.hipparchus.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(BigInteger numerator,
                                 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(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

fraction
```
public static IFraction fraction(double value)
```
Create a "fractional" number from a double number with Config.DOUBLE_EPSILON maximum error allowed.

Parameters:

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

fraction
```
public static IFraction fraction(double value,
                                 double epsilon)
```
Create a "fractional" number from a double number.

Parameters:

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

epsilon - maximum error allowed. The resulting fraction is within epsilon of value, in absolute terms

fractionConvergent
```
public static IFraction fractionConvergent(double value)
```
Create a "fractional" number from a double number.

Parameters:

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

Returns:

fractionExact
```
public static IExpr fractionExact(double value,
                                  boolean attemptNiceFraction)
```
Create a "fractional" expression that exactly represents the given double number.
This methods returns an IExpr that, when being evaluated to a double value (using IExpr.evalf()), results to the exact same value (per bit) as the given one.

Because double values are not exact in all cases but this method returns an exact representation of the given double the results may be unexpected if attemptNiceFraction = false. For example for the value 0.7 the result is 3152519739159347/4503599627370496 and not 7/10 as one would actually expect.
When this method is called with attemptNiceFraction=true it is attempted to compute a result that often meets a human's expectations better and is therefore considered 'nicer'. For example the input 0.7 then results in 7/10. The 'nicer' results comes with the cost of an increased runtime. Nevertheless the same requirement regarding an evaluation of the result to the exact same value also applies in this case.

While in most cases the returned reference is a IFraction, it is not guaranteed for all cases so users should not expect an IFraction.

Parameters:

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

attemptNiceFraction - if it should be attempted to compute a 'nicer' fraction

Returns:

an expression without floating-point numbers that evaluates to the exact same value

See Also:

AbstractFractionSym.valueOfExact(double), AbstractFractionSym.valueOfConvergent(double)

FractionBox

public static IAST FractionBox(IExpr a0,
                               IExpr a1)

FractionalPart

public static IAST FractionalPart(IExpr a)

FreeQ

public static IAST FreeQ(IExpr expr,
                         IExpr form)

Returns S.True if expr does not contain the pattern form.

See: FreeQ

Parameters:: expr -; form -
Returns:

FrechetDistribution

public static IAST FrechetDistribution(IExpr a0,
                                       IExpr a1)

FresnelC

public static IAST FresnelC(IExpr a)

FresnelS

public static IAST FresnelS(IExpr a)

FromPolarCoordinates

public static IAST FromPolarCoordinates(IExpr a)

FromSphericalCoordinates

public static IAST FromSphericalCoordinates(IExpr a)

FullForm

public static IAST FullForm(IExpr a0)

FullSimplify

public static IAST FullSimplify(IExpr a)

Function

public static IAST Function(IExpr a0)

Function

public static IAST Function(IExpr a0,
                            IExpr a1)

FunctionDomain

public static IAST FunctionDomain(IExpr a0,
                                  IExpr a1)

FunctionDomain

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

FunctionExpand

public static IAST FunctionExpand(IExpr a0)

FunctionExpand

public static IAST FunctionExpand(IExpr a0,
                                  IExpr a1)

FunctionRange

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

FunctionRange

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

FunctionURL

public static IAST FunctionURL(IExpr a0)

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

Get

public static IAST Get(String str)

Gamma

public static IAST Gamma(IExpr a0)

Gamma

public static IAST Gamma(IExpr a0,
                         IExpr a1)

Gamma

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

GammaDistribution

public static IAST GammaDistribution(IExpr a0,
                                     IExpr a1)

GammaDistribution

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

GammaRegularized

public static IAST GammaRegularized(IExpr a0,
                                    IExpr a1)

GammaRegularized

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

Gather

public static IAST Gather(IExpr a0,
                          IExpr a1)

GatherBy

public static IAST GatherBy(IExpr a0,
                            IExpr a1)

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

GCD

public static IAST GCD(IExpr a0,
                       IExpr a1)

GegenbauerC

public static IAST GegenbauerC(IExpr a0,
                               IExpr a1)

GegenbauerC

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

GeoDistance

public static IAST GeoDistance(IExpr a0,
                               IExpr a1)

GeometricMean

public static IAST GeometricMean(IExpr a0)

Grad

public static IAST Grad(IExpr a0,
                        IExpr a1)

Graph

public static IAST Graph(IExpr a0)

Graph

public static IAST Graph(IExpr a0,
                         IExpr a1)

Graph

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

Graphics

public static IASTAppendable Graphics()

Graphics

public static IASTAppendable Graphics(IExpr graphicPrimitives)

Graphics

public static IASTAppendable Graphics(IExpr graphicPrimitives,
                                      IAST... optionRules)

Graphics3D

public static IASTAppendable Graphics3D(IExpr graphicPrimitives)

Graphics3D

public static IAST Graphics3D(IExpr graphicPrimitives,
                              IExpr option)

Greater

public static IAST Greater(IExpr x,
                           IExpr y)

Yields S.True if x is known to be greater than y.

See: Greater

Parameters:: x -; y -
Returns:

Greater
```
public static IAST Greater(IExpr x,
                           int y)
```
Yields S.True if x is known to be greater than y.
See: Greater

Parameters:

x -

y -

Returns:

GreaterEqual

public static IAST GreaterEqual(IExpr x,
                                IExpr y)

Yields S.True if x is known to be greater equal than y.

See: GreaterEqual

Parameters:: x -; y -
Returns:

GreaterEqual
```
public static IAST GreaterEqual(IExpr x,
                                int y)
```
Yields S.True if x is known to be greater equal than y.
See: GreaterEqual

Parameters:

x -

y -

Returns:

Gudermannian

public static IAST Gudermannian(IExpr a0)

GumbelDistribution

public static IAST GumbelDistribution()

GumbelDistribution

public static IAST GumbelDistribution(IExpr a0,
                                      IExpr a1)

HankelH1

public static IAST HankelH1(IExpr a0,
                            IExpr a1)

HankelH2

public static IAST HankelH2(IExpr a0,
                            IExpr a1)

HarmonicMean

public static IAST HarmonicMean(IExpr a0)

HarmonicNumber

public static IAST HarmonicNumber(IExpr a)

HarmonicNumber

public static IAST HarmonicNumber(IExpr a0,
                                  IExpr a1)

Haversine

public static IAST Haversine(IExpr a)

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

headAST0
```
public static final IASTMutable 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.

HeavisideTheta

public static IAST HeavisideTheta(IExpr a0)

heaviside

public static IExpr heaviside(IExpr a0,
                              IExpr defaultValue,
                              EvalEngine engine)

HermiteH

public static IAST HermiteH(IExpr a0,
                            IExpr a1)

HermitianMatrixQ

public static IAST HermitianMatrixQ(IExpr a0)

HilbertMatrix

public static IAST HilbertMatrix(IExpr a0)

Histogram

public static IAST Histogram(IExpr a)

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

HoldComplete

public static IAST HoldComplete(IExpr a0)

HoldForm

public static IAST HoldForm(IExpr a0)

HoldPattern

public static IAST HoldPattern(IExpr a0)

HurwitzLerchPhi

public static IAST HurwitzLerchPhi(IExpr z,
                                   IExpr s,
                                   IExpr a)

HurwitzZeta

public static IAST HurwitzZeta(IExpr a0,
                               IExpr a1)

Hyperfactorial

public static IAST Hyperfactorial(IExpr a0)

Hypergeometric0F1

public static IAST Hypergeometric0F1(IExpr a0,
                                     IExpr a1)

Hypergeometric1F1

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

Hypergeometric1F1Regularized

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

Hypergeometric2F1

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

Hypergeometric2F1Regularized

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

HypergeometricPFQ

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

HypergeometricPFQRegularized

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

HypergeometricU

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

Identity

public static IAST Identity(IExpr a0)

IdentityMatrix

public static IAST IdentityMatrix(IExpr a0)

IdentityMatrix

public static IAST IdentityMatrix(int dim)

If

public static IAST If(IExpr condition,
                      IExpr trueExpr)

Returns trueExpr if condition evaluates to S.True.

See: If

Parameters:: condition -; trueExpr -
Returns:

If

public static IAST If(IExpr condition,
                      IExpr trueExpr,
                      IExpr falseExpr)

Returns trueExpr if condition evaluates to S.True and


 falseExpr

if it evaluates to S.False.

See: If

Parameters:: condition -; trueExpr -; falseExpr -
Returns:

If

public static IAST If(IExpr condition,
                      IExpr trueExpr,
                      IExpr falseExpr,
                      IExpr undefinedExpr)

Returns trueExpr if condition evaluates to S.True and


 falseExpr

if it evaluates to S.False or


 undefinedExpr

if condition don't evakluate to S.True or S.False.

See: If

Parameters:: condition -; trueExpr -; falseExpr -
Returns:

IInit

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

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

Implies

public static IAST Implies(IExpr a0,
                           IExpr a1)

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

Increment

public static IAST Increment(IExpr a)

Inequality

public static IAST Inequality(IExpr... a)

InexactNumberQ

public static IAST InexactNumberQ(IExpr a)

 InexactNumberQ(expr)

returns True if expr is not an exact number, and False otherwise.

Examples

 >> InexactNumberQ(a)
 False

 >> InexactNumberQ(3.0)
 True

 >> InexactNumberQ(2/3)
 False

InexactNumberQ can be applied to complex numbers:

 >> InexactNumberQ(4.0+I)
 True

Information

public static IAST Information(IExpr a)

Information

public static IAST Information(IExpr a0,
                               IExpr a1)

initPredefinedPattern

public static IPattern initPredefinedPattern(ISymbol symbol)

initPredefinedPatternSequence

public static IPatternSequence initPredefinedPatternSequence(ISymbol symbol)

initPredefinedPatternSequence

public static IPatternSequence initPredefinedPatternSequence(ISymbol symbol,
                                                             boolean zeroArgsAllowed)

initSymbols
```
public static void initSymbols()
```
Initialize the complete System

Insert

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

integer
```
@Deprecated
public static IInteger integer(BigInteger integerValue)
```
Deprecated.
use ZZ()

Create a large integer number.

Parameters:

integerValue -

Returns:

integer
```
@Deprecated
public static IInteger integer(long integerValue)
```
Deprecated.
use ZZ()

Create a large integer number.

Parameters:

integerValue -

Returns:

integer
```
@Deprecated
public static IInteger integer(String integerString,
                               int radix)
```
Deprecated.
use ZZ()

Create a large integer number.

Parameters:

integerString - the integer number represented as a String

radix - the radix to be used while parsing

Returns:

Object

IntegerPart

public static IAST IntegerPart(IExpr a0)

IntegerName

public static IAST IntegerName(IExpr a0)

IntegerName

public static IAST IntegerName(IExpr a0,
                               IExpr a1)

IntegerQ

public static IAST IntegerQ(IExpr expr)

 IntegerQ(expr)

returns True if expr is an integer, and False otherwise.

Examples

 >> IntegerQ(3)
 4

 >> IntegerQ(Pi)
 False

Integrate
```
public static IAST Integrate(IExpr f,
                             IExpr x)
```
Integrates f with respect to x. The result does not contain the additive integration constant.
See: Integrate

Parameters:

f -

x -

Returns:

Interpolation

public static IAST Interpolation(IExpr list)

InterpolatingPolynomial

public static IAST InterpolatingPolynomial(IExpr a0,
                                           IExpr a1)

InterquartileRange

public static IAST InterquartileRange(IExpr a)

IntervalAlloc
```
public static IASTAppendable IntervalAlloc(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:

IntervalDataAlloc

public static IASTAppendable IntervalDataAlloc(int capacity)

Interval
```
public static IAST Interval(IExpr list)
```
Create an "interval" expression: Interval(list).

Parameters:

list -

Returns:

Interval
```
public static IAST Interval(IExpr min,
                            IExpr max)
```
Create an "interval" expression: Interval(List(from, to)).

Parameters:

min - minimum value of the interval

max - maximum value of the interval

Returns:

IntervalComplement

public static IAST IntervalComplement(IExpr a1,
                                      IExpr a2)

IntervalIntersection
```
public static IAST IntervalIntersection(IExpr... intervals)
```
IntervalIntersection(interval_1, interval_2, ...) - compute the intersection of the intervals `interval_1, interval_2, ...`

IntervalMemberQ

public static IAST IntervalMemberQ(IExpr interval,
                                   IExpr expr)

IntervalUnion
```
public static IAST IntervalUnion(IExpr... intervals)
```
IntervalUnion(interval_1, interval_2, ...) - compute the union of the intervals `interval_1, interval_2, ...`

IntervalData
```
public static IAST IntervalData(IAST list)
```
Intervals will be represented by objects with head S.IntervalData wrapped around a sequence of quadruples of the form, e.g., {a,Less,LessEqual,b} representing the half open interval (a,b]. The empty interval is represented by Interval().
See: 162486/operating-with-real-intervals/162505#162505

IntervalData
```
public static IAST IntervalData(IAST... lists)
```
Intervals will be represented by objects with head S.IntervalData wrapped around a sequence of quadruples of the form, e.g., {a,Less,LessEqual,b} representing the half open interval (a,b]. The empty interval is represented by Interval().
See: 162486/operating-with-real-intervals/162505#162505

intIterator

public static IAST intIterator(ISymbol head,
                               Function<IExpr,IExpr> function,
                               int from,
                               int to,
                               int step)

Iterate over an integer range from <= i <= to with the step step/code>.



Parameters:
head - the header symbol of the result
function - the function which should be applied on each iterator value
from - from this position (included)
to - to this position (included)
step - 
Returns:







intIterator
public static IAST intIterator(ISymbol head,
                               IntFunction<IExpr> function,
                               int from,
                               int to,
                               int step)
Iterate over an integer range from <= i <= to with the step step/code>.


Parameters:
head - the header symbol of the result
function - the integer function which should be applied on each iterator value
from - 
to - 
step - 
Returns:








intIterator
public static IAST intIterator(ISymbol head,
                               Function<IExpr,IExpr> function,
                               IAST list)







productRational
public static IRational productRational(IntFunction<IRational> function,
                                        int from,
                                        int to,
                                        int step)







sumRational
public static IRational sumRational(IntFunction<IRational> function,
                                    int from,
                                    int to,
                                    int step)







Intersection
public static IAST Intersection(IExpr a0,
                                IExpr a1)







Inverse
public static IAST Inverse(IExpr a0)







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







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







InverseCDF
public static IAST InverseCDF(IExpr distribution,
                              IExpr q)







InverseErf
public static IAST InverseErf(IExpr a0)







InverseErfc
public static IAST InverseErfc(IExpr a0)







InverseFunction
public static IAST InverseFunction(IExpr a)







InverseGammaRegularized
public static IAST InverseGammaRegularized(IExpr a0,
                                           IExpr a1)







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







InverseGudermannian
public static IAST InverseGudermannian(IExpr a0)







InverseHaversine
public static IAST InverseHaversine(IExpr a)







InverseJacobiCD
public static IAST InverseJacobiCD(IExpr a0,
                                   IExpr a1)







InverseJacobiCN
public static IAST InverseJacobiCN(IExpr a0,
                                   IExpr a1)







InverseJacobiDC
public static IAST InverseJacobiDC(IExpr a0,
                                   IExpr a1)







InverseJacobiNC
public static IAST InverseJacobiNC(IExpr a0,
                                   IExpr a1)







InverseJacobiND
public static IAST InverseJacobiND(IExpr a0,
                                   IExpr a1)







InverseJacobiDN
public static IAST InverseJacobiDN(IExpr a0,
                                   IExpr a1)







InverseJacobiSC
public static IAST InverseJacobiSC(IExpr a0,
                                   IExpr a1)







InverseJacobiSD
public static IAST InverseJacobiSD(IExpr a0,
                                   IExpr a1)







InverseJacobiSN
public static IAST InverseJacobiSN(IExpr a0,
                                   IExpr a1)







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







InverseZTransform
public static IAST InverseZTransform(IExpr expr,
                                     IExpr z,
                                     IExpr n)







ISet
public static IAST ISet(IExpr lhs,
                        IExpr rhs)
Assign the evaluated rhs to the lhs.

 Note: this method returns F.NIL.

Parameters:
lhs - left-hand-side of the assignment
rhs - right-hand-side of the assignment
Returns:
F.NIL








ISetDelayed
public static IAST ISetDelayed(IExpr lhs,
                               IExpr rhs)
Assign the unevaluated rhs to the lhs.

 Note: this method returns NIL.

Parameters:
lhs - left-hand-side of the assignment
rhs - right-hand-side of the assignment
Returns:
NIL








ISetDelayed
public static IAST ISetDelayed(int priority,
                               IExpr lhs,
                               IExpr rhs)







IIntegrate
public static IExpr IIntegrate(int priority,
                               IAST lhs,
                               IExpr rhs)







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

Throws:
ArithmeticException








isNumEqualRational
public static boolean isNumEqualRational(double value,
                                         IRational rational)
                                  throws ArithmeticException
Test if rational.doubleValue() equals value within the tolerance
 Config.DOUBLE_TOLERANCE.

Parameters:
value - 
rational - 
Returns:
Throws:
ArithmeticException








isNumIntValue
public static boolean isNumIntValue(double value)
Test if the value is a Java int value within the tolerance 
 Config.DOUBLE_TOLERANCE.

Parameters:
value - 
Returns:








isNumIntValue
public static boolean isNumIntValue(double value,
                                    double epsilon)
Test if the value is a Java int value within the given tolerance epsilon
 .

Parameters:
value - 
epsilon - the tolerance
Returns:








isNumIntValue
public static boolean isNumIntValue(double value,
                                    int i)







isEqual
public static final boolean isEqual(double x,
                                    double y)
Check difference is less than a constant

 
 infinity == infinity returns true eg 1/0

 

 -infinity == infinity returns false eg -1/0

 

 -infinity == -infinity returns true

 

 undefined == undefined returns false eg 0/0

Returns:
whether x is equal to y








isEqual
public static final boolean isEqual(org.hipparchus.complex.Complex x,
                                    org.hipparchus.complex.Complex y)







isFuzzyEquals
public static boolean isFuzzyEquals(double a,
                                    double b,
                                    double tolerance)
Returns true if a and b are within tolerance (exclusive) of
 each other.

 
 Technically speaking, this is equivalent to Math.abs(a - b) <= tolerance ||
 Double.valueOf(a).equals(Double.valueOf(b)).

 

 Notable special cases include:

 

 All NaNs are fuzzily equal.
 
If a == b, then a and b are always fuzzily equal.
 
Positive and negative zero are always fuzzily equal.
 
If tolerance is zero, and neither a nor b is NaN, then a
 and b are fuzzily equal if and only if a == b.
 
With Double.POSITIVE_INFINITY tolerance, all non-NaN values are fuzzily equal.
 
With finite tolerance, Double.POSITIVE_INFINITY and 
       Double.NEGATIVE_INFINITY are fuzzily equal only to themselves.
 

 
 This is reflexive and symmetric, but not transitive, so it is not an
 equivalence relation and not suitable for use in Object.equals(java.lang.Object)
 implementations.

Throws:
IllegalArgumentException - if tolerance is < 0 or NaN








isFuzzyEquals
public static final boolean isFuzzyEquals(org.hipparchus.complex.Complex x,
                                          org.hipparchus.complex.Complex y,
                                          double tolerance)







isAlmostSame
public static boolean isAlmostSame(double a,
                                   double b)
Test if a and b are almost the same values by comparing the
 Double.doubleToLongBits(double) values.
 
 See also the implementation of Double.compare(double, double)

Parameters:
a - 
b - 








relativeDifference
public static double relativeDifference(double x,
                                        double y)
Calculate the relative difference between x and y. In case |x+y|/2 is zero the absolute
 difference is returned.

Parameters:
x - first value
y - second value
Returns:
relative error








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(org.hipparchus.complex.Complex value)
Test if the absolute value is less Config.MACHINE_EPSILON.

Parameters:
value - 
Returns:








isZero
public static boolean isZero(double x,
                             double epsilon)
Test if the absolute value is less than the given epsilon.

Parameters:
x - 
epsilon - 
Returns:








isZero
public static boolean isZero(org.hipparchus.complex.Complex x,
                             double epsilon)
Test if the absolute value is less Config.MACHINE_EPSILON.

Parameters:
x - 
epsilon - 
Returns:








isZero
public static boolean isZero(org.apfloat.Apfloat x,
                             double epsilon)







isZero
public static boolean isZero(org.apfloat.Apfloat x,
                             org.apfloat.Apfloat epsilon)







isZero
public static boolean isZero(org.apfloat.Apcomplex x,
                             double epsilon)







isZero
public static boolean isZero(org.apfloat.Apcomplex x,
                             org.apfloat.Apfloat epsilon)







JSFormData
public static IAST JSFormData(String plainJavaScript,
                              String format)
Create JavaScript form data in the given format.

Parameters:
plainJavaScript - 
format - 
Returns:








JacobiAmplitude
public static IAST JacobiAmplitude(IExpr a0,
                                   IExpr a1)







JacobiCD
public static IAST JacobiCD(IExpr a0,
                            IExpr a1)







JacobiCN
public static IAST JacobiCN(IExpr a0,
                            IExpr a1)







JacobiDC
public static IAST JacobiDC(IExpr a0,
                            IExpr a1)







JacobiEpsilon
public static IAST JacobiEpsilon(IExpr a0,
                                 IExpr a1)







JacobiNC
public static IAST JacobiNC(IExpr a0,
                            IExpr a1)







JacobiND
public static IAST JacobiND(IExpr a0,
                            IExpr a1)







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







JacobiDN
public static IAST JacobiDN(IExpr a0,
                            IExpr a1)







JacobiSC
public static IAST JacobiSC(IExpr a0,
                            IExpr a1)







JacobiSD
public static IAST JacobiSD(IExpr a0,
                            IExpr a1)







JacobiSN
public static IAST JacobiSN(IExpr a0,
                            IExpr a1)







JavaForm
public static IAST JavaForm(IExpr a0,
                            IExpr a1)







Join
public static IAST Join(IExpr a0,
                        IExpr a1)







KelvinBei
public static IAST KelvinBei(IExpr a0,
                             IExpr a1)







KelvinBer
public static IAST KelvinBer(IExpr a0,
                             IExpr a1)







Key
public static IAST Key(IExpr a0)







KleinInvariantJ
public static IAST KleinInvariantJ(IExpr a0)







KroneckerDelta
public static IAST KroneckerDelta(IExpr a0)







KroneckerDelta
public static IAST KroneckerDelta(IExpr a0,
                                  IExpr a1)







LaguerreL
public static IAST LaguerreL(IExpr a0,
                             IExpr a1)







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







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)







LegendreP
public static IAST LegendreP(IExpr a0,
                             IExpr a1)







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







LegendreQ
public static IAST LegendreQ(IExpr a0,
                             IExpr a1)







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







LeafCount
public static IAST LeafCount(IExpr expr)







Length
public static IAST Length(IExpr expr)







LerchPhi
public static IAST LerchPhi(IExpr z,
                            IExpr s,
                            IExpr a)







Less
public static IAST Less(IExpr x,
                        IExpr y)
Yields S.True if x is known to be less than y.

 
 See: Less

Parameters:
x - 
y - 
Returns:








Less
public static IAST Less(IExpr x,
                        int y)
Yields S.True if x is known to be less than y.

 
 See: Less

Parameters:
x - 
y - 
Returns:








Less
public static IAST Less(IExpr x1,
                        IExpr x2,
                        IExpr x3)
Yields S.True if x1 is known to be less than x2 and x2
  is known to be less than x3.

 
 See: Less

Parameters:
x1 - 
x2 - 
x3 - 
Returns:








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







Less
public static IAST Less(IExpr a0,
                        IExpr a1,
                        IExpr a2,
                        IExpr a3,
                        IExpr a4)







LessEqual
public static IAST LessEqual(IExpr x,
                             IExpr y)
Yields S.True if x is known to be less equal than y.

 
 See: LessEqual

Parameters:
x - 
y - 
Returns:








LessEqual
public static IAST LessEqual(IExpr x,
                             int y)
Yields S.True if x is known to be less equal than y.

 
 See: LessEqual

Parameters:
x - 
y - 
Returns:








LessEqual
public static IAST LessEqual(IExpr x1,
                             IExpr x2,
                             IExpr x3)
Yields S.True if x1 is known to be less equal than x2 and
 x2 is known to be less equal than x3.

 
 See: LessEqual

Parameters:
x1 - 
x2 - 
x3 - 
Returns:








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







LeviCivitaTensor
public static IAST LeviCivitaTensor(IExpr d)







Limit
public static IAST Limit(IExpr f,
                         IExpr rule)







Limit
public static IAST Limit(IExpr f,
                         IExpr rule,
                         IExpr direction)







Line
public static IASTAppendable Line()







Line
public static IAST Line(IExpr listOfPoints)







LinearModelFit
public static IAST LinearModelFit(IExpr a0)







LinearModelFit
public static IAST LinearModelFit(IExpr a0,
                                  IExpr a1)







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







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







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







LinearSolve
public static IAST LinearSolve(IExpr a0,
                               IExpr a1)







allocLevel1
public static int allocLevel1(IAST ast,
                              Predicate<IExpr> predicate)
Calulate the allocation size for a new IAST object. If predicate#test()
 returns true add the arguments IAST.argSize() to the ast.argSize()
 

Parameters:
ast - 
predicate - 
Returns:








allocMin8
public static int allocMin8(IAST ast)
Determine the minimum of the ast IAST.argSize() and integer number 7

Parameters:
ast - 
Returns:








allocMin8
public static int allocMin8(int size)
Determine the minimum of the size and integer number 7

Parameters:
size - 
Returns:








allocMin16
public static int allocMin16(IAST ast)
Determine the minimum of the ast IAST.argSize() and integer number 15

Parameters:
ast - 
Returns:








allocMin16
public static int allocMin16(int size)
Determine the minimum of the size and integer number 15

Parameters:
size - 
Returns:








allocMin32
public static int allocMin32(IAST ast)
Determine the minimum of the ast IAST.argSize() and integer number 31,

Parameters:
ast - 
Returns:








allocMin32
public static int allocMin32(int size)
Determine the minimum of the size and integer number 31

Parameters:
size - 
Returns:








allocMin64
public static int allocMin64(IAST ast)
Determine the minimum of the ast IAST.argSize() and integer number 63,

Parameters:
ast - 
Returns:








allocMax8
public static int allocMax8(IAST ast)
Determine the maximum of the ast IAST.argSize() and integer number 7,

Parameters:
ast - 
Returns:








allocMax16
public static int allocMax16(IAST ast)
Determine the maximum of the ast IAST.argSize() and integer number 15,

Parameters:
ast - 
Returns:








allocMax32
public static int allocMax32(IAST ast)
Determine the maximum of the ast IAST.argSize() and integer number 31,

Parameters:
ast - 
Returns:








allocMax64
public static int allocMax64(IAST ast)
Determine the maximum of the ast IAST.argSize() and integer number 63,

Parameters:
ast - 
Returns:








ListAlloc
public static IASTAppendable ListAlloc()
Create an appendable list { }.

Returns:








ListAlloc
public static IASTAppendable ListAlloc(int initialCapacity)
Create a new List with the given initial capacity.

Parameters:
initialCapacity - the assumed number of arguments (+ 1 for the header expression is added
        internally).
Returns:








ListAlloc
public static IASTAppendable ListAlloc(Collection<? extends IExpr> collection)
Create a new List with the capacity collection.size() and append the
 elements of the collection.

Parameters:
collection - the collection which holds the elements which should be appended
Returns:








ListAlloc
public static IASTAppendable ListAlloc(Collection<? extends IExpr> collection,
                                       int capacity)
Create a new List with the capacity collection.size() + capacity and
 append the elements of the collection.

Parameters:
collection - 
capacity - 
Returns:








ListAlloc
public static IASTAppendable ListAlloc(IExpr... a)
Create an appendable list { }.

Parameters:
a - 
Returns:








ListAlloc
public static IASTAppendable ListAlloc(Stream<? extends IExpr> stream)
Constructs a list that holds the expressions of the input stream.
 
 
 for instance,
 

 if the stream consists of IReals, the return value represents a vector,
 
if the stream consists of vectors, the return value represents a matrix.
 
if the stream consists of matrices, the return value represents a tensor with rank 3.
 
etc.
 

Parameters:
stream - of expressions to form the first level of the return value
Returns:
list that holds the expressions of the input stream








ListAlloc
public static IASTAppendable ListAlloc(IntStream stream)







TemplateSlot
public static IAST TemplateSlot(IExpr a0)







TemplateSlot
public static IAST TemplateSlot(IExpr a0,
                                IExpr a1)







TensorDimensions
public static IAST TensorDimensions(IExpr a0)







tensorList
public static IAST tensorList(int n,
                              Integer... numbers)
For positive n, add the first n elements of numbers to the list.For negative n,
 add the last n elements of numbers to the list.

Parameters:
n - 
numbers - 
Returns:








List
public static IASTMutable List(double... numbers)







List
public static IASTMutable List(String... strs)







List
public static IAST List()
Create an empty immutable list { } (i.e. List()).

Returns:








listOfObjects
public static IAST listOfObjects(Object... objects)
Create an immutable list { } by converting the Objects expression types
 into IExpr types.

Parameters:
objects - the objects which should be converted, before adding them to the list
Returns:
a List(...) of expressions








List
public static IAST List(IExpr... a)
Create an immutable list { }.

Parameters:
a - 
Returns:








list
public static IAST list(IExpr expr)
Return a single value as a List()

Parameters:
expr - 
Returns:








list
public static IAST list(IExpr x1,
                        IExpr x2)
Return a pair of values as a List()

Parameters:
x1 - 
x2 - 
Returns:








pair
public static Pair pair(IExpr x1,
                        IExpr x2)
Return a pair of values as a List()

Parameters:
x1 - 
x2 - 
Returns:








list
public static IAST list(IExpr x1,
                        IExpr x2,
                        IExpr x3)
Return a triple of values as a List()

Parameters:
x1 - 
x2 - 
x3 - 
Returns:








List
public static IAST List(long... numbers)







List
public static IASTMutable List(int... numbers)







ListConvolve
public static IAST ListConvolve(IExpr a0,
                                IExpr a1)







ListPlot
public static IAST ListPlot(IExpr a)







ListPlot3D
public static IAST ListPlot3D(IExpr a)







ListPointPlot3D
public static IAST ListPointPlot3D(IExpr a)







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

 

 
 tests whether expr is a List.

 

 Examples

  >> ListQ({1, 2, 3})
 True

 >> ListQ({{1, 2}, {3, 4}})
 True

 >> ListQ(x)
 False
 







Literal
@Deprecated
public static IAST Literal(IExpr a0)
Deprecated.
use HoldPattern


Parameters:
a0 - 
Returns:








Log
public static IAST Log(IExpr z)
Returns the natural logarithm of z.

 
 See: Log

Parameters:
z - 
Returns:








Log
public static IAST Log(int z)
Returns the natural logarithm of z.

Parameters:
z - 
Returns:








Log
public static IAST Log(IExpr z,
                       IExpr base)
Returns the logarithm of z for the base.

 
 See: Log

Parameters:
z - 
base - 
Returns:








Log
public static IAST Log(IExpr z,
                       int base)
Returns the logarithm of z for the base.

Parameters:
z - 
base - 
Returns:








Log
public static IAST Log(int z,
                       int base)
Returns the logarithm of z for the base.

Parameters:
z - 
base - 
Returns:








Log10
public static IAST Log10(IExpr a0)
Log[10, a0].

Parameters:
a0 - 
Returns:
Log[10, a0].








LogGamma
public static IAST LogGamma(IExpr a0)







LogIntegral
public static IAST LogIntegral(IExpr a)







LogisticSigmoid
public static IAST LogisticSigmoid(IExpr a)







LogNormalDistribution
public static IAST LogNormalDistribution(IExpr a0,
                                         IExpr a1)







LucasL
public static IAST LucasL(IExpr a)







LucasL
public static IAST LucasL(IExpr a,
                          IExpr b)







MachineNumberQ
public static IAST MachineNumberQ(IExpr a0)
 MachineNumberQ(expr)
 

 

 
 returns True if expr is a machine-precision real or complex number.

 

 Examples

  >> MachineNumberQ(3.14159265358979324)
 False

 >> MachineNumberQ(1.5 + 2.3*I)
 True

 >> MachineNumberQ(2.71828182845904524 + 3.14159265358979324*I)
 False

 >> MachineNumberQ(1.5 + 3.14159265358979324*I)
 True

 >> MachineNumberQ(1.5 + 5 *I)
 True
 







Manipulate
public static IAST Manipulate(IExpr a0)







Manipulate
public static IAST Manipulate(IExpr a0,
                              IExpr a1)







mapFunction
public static IASTAppendable mapFunction(IExpr head,
                                         IAST ast)







mapFunction
public static <T extends IExpr> IASTAppendable mapFunction(IExpr head,
                                                           IAST ast,
                                                           Function<T,IExpr> function)
Iterates over the ast elements and calls the function. Append the functions result
 expression at the end of the result list, if the function results is not equal NIL.
 If the function results is null stop iterating and return F.NIL.

Parameters:
head - the head of the result ast
ast - 
function - 
Returns:
NIL if the function returns null








mapFunction
public static <T extends IExpr> IASTAppendable mapFunction(IExpr head,
                                                           IAST ast,
                                                           Function<T,IExpr> function,
                                                           Predicate<T> predicate)







mapFunction
public static <T extends IExpr> IASTAppendable mapFunction(IExpr head,
                                                           IAST ast,
                                                           int start,
                                                           int end,
                                                           Function<T,IExpr> function)

Parameters:
head - the head of the result ast
ast - 
start - start of the range (inclusive) of elements which should be mapped
end - end of the range (exclusive) of elements which should be mapped
function - 
Returns:








mapFunction
public static <T extends IExpr> IASTAppendable mapFunction(IExpr head,
                                                           IAST ast,
                                                           int start,
                                                           int end,
                                                           Function<T,IExpr> function,
                                                           Predicate<T> predicate)

Parameters:
head - the head of the result ast
ast - 
start - start of the range (inclusive) of elements which should be mapped
end - end of the range (exclusive) of elements which should be mapped
function - 
predicate - 
Returns:








mapFunction
public static IASTAppendable mapFunction(IExpr head,
                                         IAST ast,
                                         ObjIntFunction<IExpr,IExpr> function)
Iterates over the lists elements and calls the function. Append the functions result expression
 at the end of the result list, if the function results is not equal NIL. If the
 function results is null stop iterating and return false.

Parameters:
ast - 
function - 
Returns:
NIL if the function returns null








mapFunction
public static <T> IASTAppendable mapFunction(IExpr head,
                                             List<T> list,
                                             Function<T,IExpr> function)
Iterates over the lists elements and calls the function. Append the functions result expression
 at the end of the result list, if the function results is not equal NIL. If the
 function results is null stop iterating and return false.

Parameters:
list - 
function - 
Returns:
NIL if the function returns null








mapFunction
public static <T> IASTAppendable mapFunction(IExpr head,
                                             List<T> list,
                                             Function<T,IExpr> function,
                                             Predicate<T> predicate)







mapList
public static <T extends IExpr> IASTAppendable mapList(IAST ast,
                                                       Function<T,IExpr> function)
Iterates over the lists elements and calls the function. Append the functions result expression
 at the end of the result list, if the function results is not equal NIL. If the
 function results is null stop iterating and return false.

Parameters:
ast - 
function - 
Returns:
NIL if the function returns null








mapList
public static <T extends IExpr> IASTAppendable mapList(IAST ast,
                                                       Function<T,IExpr> function,
                                                       Predicate<T> predicate)







mapList
public static IASTAppendable mapList(IAST ast,
                                     ObjIntFunction<IExpr,IExpr> function)
Iterates over the lists elements and calls the function. Append the functions result expression
 at the end of the result list, if the function results is not equal NIL. If the
 function results is null stop iterating and return false.

Parameters:
ast - 
function - 
Returns:
NIL if the function returns null








mapList
public static <T extends IExpr> IASTAppendable mapList(List<T> list,
                                                       Function<T,IExpr> function)
Iterates over the lists elements and calls the function. Append the functions result expression
 at the end of the result list, if the function results is not equal NIL. If the
 function results is null stop iterating and return false.

Parameters:
list - 
function - 
Returns:
NIL if the function returns null








mapList
public static IASTAppendable mapList(List<IExpr> list,
                                     Function<IExpr,IExpr> function,
                                     Predicate<IExpr> predicate)







mapSet
public static IASTAppendable mapSet(Set<? extends IExpr> exprSet,
                                    Function<IExpr,IExpr> function)
Iterates over the set elements and calls the function. Append the functions result expression
 at the end of the result list, if the function results is not equal NIL. If the
 function results is null stop iterating and return false.

Parameters:
exprSet - 
function - 
Returns:
NIL if the function returns null








mapMap
public static IASTAppendable mapMap(Map<? extends IExpr,? extends IExpr> map,
                                    BiFunction<IExpr,IExpr,IExpr> biFunction)
Iterates over the maps (key, value) pairs and calls the function. Append the functions result
 expression at the end of the result list, if the function results is not equal NIL.
 If the function results is null stop iterating and return false.

Parameters:
map - 
biFunction - 
Returns:
NIL if the biFunction returns null








mapRange
public static <T extends IExpr> IASTAppendable mapRange(int iMin,
                                                        int iMax,
                                                        IntFunction<T> function)
Create an integer range between iMin (inclusive) and iMax (exclusive)
 and call the function with the elements of the created range. Append the result of the
 function to the returned result list.If it's equal NIL then don't
 appending an entry. If it's equal null then return NIL for this method.

Parameters:
iMin - minimum range limit (inclusive)
iMax - maximum range limit (exclusive)
function - function those apply(x) method will be called with each number in
        the range. If the apply method returns null then return
        NIL.
Returns:








mapRange
public static <T extends IExpr> IASTAppendable mapRange(IExpr head,
                                                        int iMin,
                                                        int iMax,
                                                        IntFunction<T> function)
Create an integer range between iMin (inclusive) and iMax (exclusive)
 and call the function with the elements of the created range. Append the result of the
 function to the returned result ast. If it's equal NIL then
 don't appending an entry. If it's equal null then return NIL for this
 method.

Parameters:
head - the new head of the result ast
iMin - minimum range limit (inclusive)
iMax - maximum range limit (exclusive)
function - those apply(x) method will be called with each number in the
        range. If the apply method returns null then return
        NIL.
Returns:








Map
public static IAST Map(IExpr f)







Map
public static IAST Map(IExpr f,
                       IExpr expr)







Map
public static IAST Map(IExpr f,
                       IExpr expr,
                       IExpr levelspec)







MapThread
public static IAST MapThread(IExpr f,
                             IExpr expr)







MapAll
public static IAST MapAll(IExpr a0)







MatchQ
public static IAST MatchQ(IExpr expr,
                          IExpr form)







MathMLForm
public static IAST MathMLForm(IExpr expr)







MatrixD
public static IAST MatrixD(IExpr expr,
                           IExpr x)







MatrixExp
public static IAST MatrixExp(IExpr a0)







MatrixLog
public static IAST MatrixLog(IExpr a0)







MatrixForm
public static IAST MatrixForm(IExpr a0)







MatrixPower
public static IAST MatrixPower(IExpr matrix,
                               IExpr n)







Max
public static IASTAppendable Max()







Max
public static IAST Max(IExpr a0)







Max
public static IAST Max(IExpr a0,
                       IExpr a1)







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







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







Maximize
public static IAST Maximize(IExpr a0,
                            IExpr a1)







Mean
public static IAST Mean(IExpr list)







MeanDeviation
public static IAST MeanDeviation(IExpr list)







Median
public static IAST Median(IExpr list)







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







MemberQ
public static IAST MemberQ(IExpr list,
                           IExpr form)
Returns S.True if form matches any element of list, or
 S.False otherwise.

 
 See: MemberQ

Parameters:
list - 
form - 
Returns:








MessageName
public static IAST MessageName(IExpr a0,
                               IExpr a1)







MessageName
public static IAST MessageName(ISymbol symbol,
                               String str)







Min
public static IASTAppendable Min()







Min
public static IAST Min(IExpr a0)







Min
public static IAST Min(IExpr a0,
                       IExpr a1)







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







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







Minimize
public static IAST Minimize(IExpr a0,
                            IExpr a1)







minus
public static IExpr minus(IExpr a,
                          Integer i)







minus
public static IExpr minus(IExpr a,
                          BigInteger i)







minus
public static IExpr minus(Integer i,
                          IExpr b)







minus
public static IExpr minus(BigInteger i,
                          IExpr b)







Missing
public static IAST Missing(IExpr reason)







Missing
public static IAST Missing(String reason)







Missing
public static IAST Missing(IExpr a0,
                           IExpr a1)







MissingQ
public static IAST MissingQ(IExpr a0)
 MissingQ(expr)
 

 

 
 returns True if expr is a Missing() expression.

 

 Examples

  >> MissingQ(Missing("Test message"))
 True
 







MoebiusMu
public static IAST MoebiusMu(IExpr a0)







mod
public static IExpr mod(IExpr a,
                        Integer i)







mod
public static IExpr mod(IExpr a,
                        BigInteger i)







mod
public static IExpr mod(Integer i,
                        IExpr b)







mod
public static IExpr mod(BigInteger i,
                        IExpr b)







Mod
public static IExpr Mod(IExpr a0,
                        IExpr a1)







Module
public static IAST Module(IExpr listOfLocalVariables,
                          IExpr expr)
Evaluates expr for the listOfLocalVariables by first renaming the
 local variables in expr.

 
 See: Module

Parameters:
listOfLocalVariables - 
expr - 
Returns:








Most
public static IAST Most(IExpr a0)







multiply
public static IExpr multiply(IExpr a,
                             Integer i)







multiply
public static IExpr multiply(IExpr a,
                             BigInteger i)







multiply
public static IExpr multiply(Integer i,
                             IExpr b)







multiply
public static IExpr multiply(BigInteger i,
                             IExpr b)







Multinomial
public static IAST Multinomial(IExpr... a)







MultiplicativeOrder
public static IAST MultiplicativeOrder(IExpr a0,
                                       IExpr a1)







MultiplySides
public static IASTMutable MultiplySides(IExpr equationOrInequality,
                                        IExpr x)







N
public static IAST N(IExpr symbolicExpr)
Evaluate the given (symbolic) expression in numeric mode.

Parameters:
symbolicExpr - 
Returns:








N
public static IAST N(IExpr symbolicExpr,
                     IExpr precision)
Evaluate the given (symbolic) expression in numeric mode with precision digits .

Parameters:
symbolicExpr - 
precision - 
Returns:








NakagamiDistribution
public static IAST NakagamiDistribution(IExpr a0,
                                        IExpr a1)







NameQ
public static IAST NameQ(IExpr a0)







NameQ
public static IAST NameQ(String str)







Needs
public static IAST Needs(IExpr a0)







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-sides
 expressions). so it is only called for INumber objects, otherwise a 
 Times(CN1, x) AST would be created.

Parameters:
x - the expression which should be negated.
Returns:








Negative
public static IAST Negative(IExpr x)







Nest
public static IAST Nest(IExpr a0,
                        IExpr a1,
                        int n)







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







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:








NewLimit
public static IAST NewLimit(IExpr f,
                            IExpr rule)







NewLimit
public static IAST NewLimit(IExpr f,
                            IExpr rule,
                            IExpr direction)







NMaximize
public static IAST NMaximize(IExpr a0,
                             IExpr a1)







NMinimize
public static IAST NMinimize(IExpr a0,
                             IExpr a1)







NonCommutativeMultiply
public static IAST NonCommutativeMultiply(IExpr... a)







Norm
public static IAST Norm(IExpr a)







NormalDistribution
public static IAST NormalDistribution()







NormalDistribution
public static IAST NormalDistribution(IExpr a0,
                                      IExpr a1)







ParetoDistribution
public static IAST ParetoDistribution(IExpr a0,
                                      IExpr a1)







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







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







Normalize
public static IAST Normalize(IExpr a)







Not
public static IAST Not(IExpr expr)
Logical Not function (negation). Returns S.True if expr is
 S.False. Returns S.False if expr is S.True.

 
 See: Not

Parameters:
expr - 
Returns:








NotElement
public static IAST NotElement(IExpr x,
                              IExpr domain)







NRoots
public static IAST NRoots(IExpr a0,
                          IExpr a1)







NullSpace
public static IAST NullSpace(IExpr a0)







num
public static INum num(org.apfloat.Apfloat af)
Return a ApfloatNum which wraps a Apfloat arbitrary precision floating-point
 number.

Parameters:
af - 
Returns:








num
public static INum num(String valueString)
Create a numeric value from the input string. If EvalEngine.isArbitraryMode() is
 true return a ApfloatNum which wraps a Apfloat arbitrary precision
 floating-point number with the engines precision.

Parameters:
valueString - the numeric value represented as a string.
Returns:








num
public static INum num(String numberStr,
                       long precision)
Return a ApfloatNum which wraps a Apfloat arbitrary precision floating-point
 number.

Parameters:
numberStr - 
precision - 
Returns:
a ApfloatNum which wraps a Apfloat Arbitrary precision floating-point
         number.








num
public static Num num(double value)
Return a Num which wraps a Java double number.

Parameters:
value - 
Returns:








num
public static INum num(IFraction value)







num
public static INum num(IInteger value)







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

 

 
 returns True if expr is an explicit number, and False
 otherwise.

 

 Examples

  >> NumberQ(3+I)
 True

 >> NumberQ(5!)
 True

 >> NumberQ(Pi)
 False
 







Numerator
public static IAST Numerator(IExpr expr)







NumericalOrder
public static IAST NumericalOrder(IExpr a0,
                                  IExpr a1)







NumericalSort
public static IAST NumericalSort(IExpr a0)







NumericQ
public static IAST NumericQ(IExpr a0)
 NumericQ(expr)
 

 

 
 returns True if expr is an explicit numeric expression, and 
 False otherwise.

 

 Examples

  >> NumericQ(E+Pi)
 True

 >> NumericQ(Sqrt(3))
 True
 







O
public static IAST O(IExpr a0)







OddQ
public static IAST OddQ(IExpr x)
 OddQ(x)
 

 

 
 returns True if x is odd, and False otherwise.

 

 Examples

  >> OddQ(-3)
 True

 >> OddQ(0)
 False
 







On
public static IAST On(IExpr a0,
                      IExpr a1)







On
public static IAST On(IExpr a0)







OptimizeExpression
public static IAST OptimizeExpression(IExpr a0)







Optional
public static IAST Optional(IExpr a0,
                            IExpr a1)







Optional
public static IAST Optional(IExpr a0)







Options
public static IAST Options(IExpr a0)







OptionValue
public static IAST OptionValue(IExpr a0,
                               IExpr a1)







OptionValue
public static IAST OptionValue(IExpr a0)







Or
public static IASTAppendable Or()







Or
public static IAST Or(IExpr expr1,
                      IExpr expr2)
expr1 || expr2 evaluates each expression in turn, returning S.True as soon
 as an expression evaluates to S.True. If all expressions evaluate to S.False,
 it returns S.False.

 
 See: Or

Parameters:
expr1 - 
expr2 - 
Returns:








Or
public static IAST Or(IExpr expr1,
                      IExpr expr2,
                      IExpr expr3)
expr1 || expr2 || expr3 evaluates each expression in turn, returning
 S.True as soon as an expression evaluates to S.True. If all expressions
 evaluate to S.False, it returns S.False.

 
 See: Or

Parameters:
expr1 - 
expr2 - 
expr3 - 
Returns:








Or
public static IAST Or(IExpr... expr)







Order
public static IAST Order(IExpr a0,
                         IExpr a1)







Ordering
public static IAST Ordering(IExpr a)







OrderedQ
public static IAST OrderedQ(IExpr a)







Out
public static IAST Out(IExpr a0)







Out
public static IAST Out(int n)







Overflow
public static IAST Overflow()







Parenthesis
public static IAST Parenthesis(IExpr a0)







Part
public static IASTAppendable Part()
See: Part







Part
public static IAST Part(IExpr expr,
                        IExpr i)
Returns part i of expr.

 
 See: Part

Parameters:
expr - 
i - 
Returns:








Part
public static IAST Part(IExpr expr,
                        IExpr i,
                        IExpr j)
Returns the part i, j of expr.

 
 See: Part

Parameters:
expr - 
i - 
j - 
Returns:








Part
public static IASTAppendable Part(IExpr... a)
See: Part







Part
public static IASTAppendable Part(int extraSize,
                                  IExpr... a)
See: Part







PartitionsP
public static IAST PartitionsP(IExpr a0)







PartitionsQ
public static IAST PartitionsQ(IExpr a0)







PatternTest
public static IAST PatternTest(IExpr pattern,
                               IExpr test)
Constrains pattern to match expr only if the evaluation of 
 test(expr) yields S.True.

 
 See: PatternTest

Parameters:
pattern - 
test - 
Returns:








PDF
public static IAST PDF(IExpr distribution)
See: PDF







PDF
public static IAST PDF(IExpr distribution,
                       IExpr x)
See: PDF







Piecewise
public static IAST Piecewise(IExpr listOfConditions)
See: Piecewise







Piecewise
public static IAST Piecewise(IExpr listOfConditions,
                             IExpr defaultValue)
See: Piecewise







PiecewiseExpand
public static IAST PiecewiseExpand(IExpr expr)
See: PiecewiseExpand







Plot
public static IAST Plot(IExpr a0,
                        IExpr a1)







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







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







plus
public static IExpr plus(IExpr a,
                         Integer i)







plus
public static IExpr plus(IExpr a,
                         BigInteger i)







plus
public static IExpr plus(Integer i,
                         IExpr b)







plus
public static IExpr plus(BigInteger i,
                         IExpr b)







Plus
public static IASTAppendable Plus()
See: Plus







PlusAlloc
public static IASTAppendable PlusAlloc(int initialCapacity)
See: Plus

Parameters:
initialCapacity - the initialCapacity of this AST
Returns:








Plus
public static IASTAppendable Plus(IExpr a0)
See: Plus







Plus
public static IAST Plus(IExpr... a)
Define a Plus() expression a0 + a1 + a2 ... for addition.

 
 See: Plus







PlusMinus
public static IAST PlusMinus(IExpr... a)







Plus
public static IAST Plus(IExpr x,
                        IExpr y)
Define a Plus() expression x + y for addition.

 
 See: Plus

Parameters:
x - 
y - 
Returns:








Plus
public static IAST Plus(IExpr x,
                        IExpr y,
                        IExpr z)
Define a Plus() expression x + y + z for addition.

 
 See: Plus







Plus
public static IAST Plus(long num,
                        IExpr... a)
Define a Plus() expression num + a0 + a1 + a2 ... for addition.

 
 See: Plus







Pochhammer
public static IAST Pochhammer(IExpr a0,
                              IExpr a1)







Point
public static IAST Point(IAST list)







PoissonDistribution
public static IAST PoissonDistribution(IExpr a0)







PolyGamma
public static IAST PolyGamma(IExpr a0)







PolyGamma
public static IAST PolyGamma(IExpr a0,
                             IExpr a1)







PolyGamma
public static IAST PolyGamma(int n,
                             IExpr z)







Polygon
public static IAST Polygon(IExpr a0)







PolyLog
public static IAST PolyLog(IExpr a0,
                           IExpr a1)







PolyLog
public static IAST PolyLog(IExpr n,
                           IExpr p,
                           IExpr z)







PolynomialGCD
public static IAST PolynomialGCD(IExpr poly1,
                                 IExpr poly2)







PolynomialQ
public static IAST PolynomialQ(IExpr expr,
                               IExpr variable)
Return S.True if expr is a polynomial for the variable.
 Return S.False in all other cases.

 
 See: PolynomialQ

Parameters:
expr - 
variable - 
Returns:








PolynomialQuotient
public static IAST PolynomialQuotient(IExpr poly1,
                                      IExpr poly2,
                                      IExpr x)







PolynomialQuotientRemainder
public static IAST PolynomialQuotientRemainder(IExpr poly1,
                                               IExpr poly2,
                                               IExpr x)







PolynomialRemainder
public static IAST PolynomialRemainder(IExpr poly1,
                                       IExpr poly2,
                                       IExpr x)







PointSize
public static IAST PointSize(IExpr a0)







PointSize
public static IAST PointSize(double value)







Position
public static IAST Position(IExpr a0,
                            IExpr a1)







Positive
public static IAST Positive(IExpr a0)







PossibleZeroQ
public static IAST PossibleZeroQ(IExpr a0)







Power
public static IAST Power(IExpr base,
                         IExpr exponent)
Define base to the power of exponent. Symja operator form:
 base ^ exponent.

 
 See: Power

Parameters:
base - 
exponent - 
Returns:








Power
public static IExpr Power(IExpr base,
                          long exponent)
Define a power expression base ^ exponent.

 
 See: Power

Parameters:
base - 
exponent - 
Returns:








PowerExpand
public static IAST PowerExpand(IExpr a0)







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







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

Parameters:
symbolName - 
Returns:








Prepend
public static IAST Prepend(IExpr a0,
                           IExpr a1)







PrimeOmega
public static IAST PrimeOmega(IExpr a0)







PrimePi
public static IAST PrimePi(IExpr a0)
See PrimePi







PrimeQ
public static IAST PrimeQ(IExpr a0)
See PrimeQ







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







Product
public static IAST Product(IExpr expr,
                           IExpr iterationSpecification)

Parameters:
expr - expression which should be multiplied up
iterationSpecification - a standard iteration specification
Returns:
Product(expr, iterationSpecification) AST








product
public static IExpr product(Function<IInteger,IExpr> function,
                            int from,
                            int to)
Iterate over an integer range from <= i <= to and create a product of the created
 values.

Parameters:
function - the function which should be applied on each iterator value
from - 
to - 
Returns:








ProductLog
public static IAST ProductLog(IExpr a0)







ProductLog
public static IAST ProductLog(IExpr a0,
                              IExpr a1)







PseudoInverse
public static IAST PseudoInverse(IExpr a0)







QQ
public static IFraction QQ(org.hipparchus.fraction.BigFraction frac)
Create a "fractional" number from a Hipparchus BigFraction number.

Parameters:
frac - a big fractional number
Returns:
IFraction








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

Parameters:
numerator - numerator of the fractional number
denominator - denominator of the fractional number
Returns:
IFraction








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

Parameters:
numerator - numerator of the fractional number
denominator - denominator of the fractional number
Returns:
IFraction








QRDecomposition
public static IAST QRDecomposition(IExpr a0)







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







Quantile
public static IAST Quantile(IExpr distribution)
Returns the Quantile of the distribution.

 
 See: Quantile

Parameters:
distribution - 
Returns:








Quantile
public static IAST Quantile(IExpr list,
                            IExpr q)
Returns the q-Quantile of list.

 
 See: Quantile

Parameters:
list - 
q - 
Returns:








Quantile
public static IAST Quantile(IExpr list,
                            IExpr q,
                            IExpr definition)
Returns the q-Quantile of list with the given quantile 
 definition. The default parameters for the quantile definition are {{0,0},{1,0}}
 .

 
 See: Quantile

Parameters:
list - 
q - 
Returns:








Quantity
public static IAST Quantity(IExpr magnitude,
                            IExpr unit)
Returns the quantity for magnitude and unit.

 
 See: Quantity

Parameters:
magnitude - 
unit - 
Returns:








QuantityMagnitude
public static IAST QuantityMagnitude(IExpr quantity)
Returns the value of the quantity.

 
 See: QuantityMagnitude

Parameters:
quantity - 
Returns:








QuantityMagnitude
public static IAST QuantityMagnitude(IExpr quantity,
                                     IExpr unit)
Returns the value of the quantity for the given unit

 
 See: QuantityMagnitude

Parameters:
quantity - 
unit - 
Returns:








Quartiles
public static IAST Quartiles(IExpr a0)







Quiet
public static IAST Quiet(IExpr a0)







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







Quotient
public static IAST Quotient(IExpr a0,
                            IExpr a1)







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







RandomComplex
public static IAST RandomComplex(IExpr a0)







RandomInteger
public static IAST RandomInteger(IExpr a0)







RandomReal
public static IAST RandomReal(IExpr a0)







RandomVariate
public static IAST RandomVariate(IExpr a0)







RandomVariate
public static IAST RandomVariate(IExpr a0,
                                 IExpr a1)







Range
public static IAST Range(IExpr a0)







Range
public static IAST Range(IExpr a0,
                         IExpr a1)







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







Rational
public static IAST Rational(IExpr a0,
                            IExpr a1)







Rationalize
public static IAST Rationalize(IExpr a0)







Rationalize
public static IAST Rationalize(IExpr a0,
                               IExpr a1)







Rectangle
public static IAST Rectangle(IAST originList)







reduce
public static IExpr reduce(IAST ast,
                           int startInclusive,
                           int endExclusive,
                           IExpr identity,
                           BinaryOperator<IExpr> accumulator)
Performs a reduction on the elements of this function range, using the provided identity value
 and an associative accumulation function, and returns the reduced value. This is equivalent to:
 
  IExpr result = identity;
 for (int i = startInclusive; i < endExclusive; i++) {
   IExpr element = ast.getRule(i);
   result = accumulator.apply(result, element);
 }
 return result;
 

Parameters:
ast - 
startInclusive - the first index to cover, inclusive
endExclusive - index immediately past the last index to cover
identity - the identity value for the accumulating function
accumulator - an associative, non-interfering, stateless function for combining two values
Returns:








Re
public static IExpr Re(IExpr a0)







RealAbs
public static IAST RealAbs(IExpr a)







RealValuedNumberQ
public static IAST RealValuedNumberQ(IExpr a)







RealValuedNumericQ
public static IAST RealValuedNumericQ(IExpr a)







RealSign
public static IAST RealSign(IExpr a)







Reap
public static IAST Reap(IExpr a)







Reduce
public static IAST Reduce(IExpr logicExpr,
                          IExpr variable)
Reduce(logic-expression, var) - returns the reduced `logic-expression` for the variable `var`.
 Reduce works only for the `Reals` domain.

See Also:
Reduce
      documentation








Refine
public static IAST Refine(IExpr a)







Refine
public static IAST Refine(IExpr a0,
                          IExpr a1)







RegularExpression
public static IAST RegularExpression(IExpr a0)







RegularExpression
public static IAST RegularExpression(String str)







Replace
public static IAST Replace(IExpr a0,
                           IExpr a1)







ReplaceAll
public static IAST ReplaceAll(IExpr a0,
                              IExpr a1)







ReplaceList
public static IAST ReplaceList(IExpr a0,
                               IExpr a1)







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







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







ReplaceRepeated
public static IAST ReplaceRepeated(IExpr a0,
                                   IExpr a1)







Rest
public static IAST Rest(IExpr a0)







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







RGBColor
public static IAST RGBColor(IExpr red,
                            IExpr green,
                            IExpr blue)







RGBColor
public static IAST RGBColor(double red,
                            double green,
                            double blue)







symbol
public static ISymbol symbol(String symbolName)
Get or create a user defined symbol which is retrieved from the evaluation engines context
 path.

Parameters:
symbolName - the name of the symbol
Returns:
the symbol object from the context path








symbol
public static ISymbol symbol(String symbolName,
                             EvalEngine engine)
Get or create a user defined symbol which is retrieved from the evaluation engines context
 path.

Parameters:
symbolName - the name of the symbol
engine - the evaluation engine
Returns:
the symbol object from the context path








symbol
public static ISymbol symbol(String symbolName,
                             IAST assumptionAST)
Get or create a user defined symbol which is retrieved from the evaluation engines context
 path. Additional set assumptions to the engines global assumptions. Use #1 or
 Slot1 in the assumptionAST expression for this symbol.

Parameters:
symbolName - the name of the symbol
assumptionAST - the assumptions which should be set for the symbol. Use #1 or
        Slot1 in the assumptionAST expression for this symbol.
Returns:
the symbol object from the context path








symbol
public static ISymbol symbol(String symbolName,
                             IAST assumptionAST,
                             EvalEngine engine)
Get or create a user defined symbol which is retrieved from the evaluation engines context
 path. Additional set assumptions to the engines global assumptions. Use #1 or
 Slot1 in the assumptionAST expression for this symbol.

Parameters:
symbolName - the name of the symbol
assumptionAST - the assumptions which should be set for the symbol. Use #1 or
        Slot1 in the assumptionAST expression for this symbol.
engine - the evaluation engine
Returns:
the symbol object from the context path








hasSymbol
public static boolean hasSymbol(String symbolName,
                                EvalEngine engine)
Test if the symbolName is defined in the one of the contexts available on the
 context path.

Parameters:
symbolName - the name of a symbol
engine - 
Returns:








symbol
public static ISymbol symbol(String symbolName,
                             String contextStr,
                             IAST assumptionAST,
                             EvalEngine engine)







symbol
public static ISymbol symbol(Context context,
                             String symbolName,
                             EvalEngine engine)







usage
public static final String usage(ISymbol head)
Print the documentation for the given symbol.

Parameters:
head - 
Returns:








usage
public static final String usage(String symbolName)
Print the documentation for the given symbol name.

Parameters:
symbolName - 
Returns:








Dummy
public static ISymbol Dummy(char symbolName)
Create a unique dummy symbol which is retrieved from the evaluation engines DUMMY context. A
 "Dummy" symbol is not known in string parsing.

Parameters:
symbolName - the name of the symbol
Returns:
the symbol object from the context path
See Also:
symbol(String)








Dummy
public static ISymbol Dummy(String symbolName)
Create a unique dummy symbol which is retrieved from the evaluation engines DUMMY context. A
 "Dummy" symbol is not known in string parsing.

Parameters:
symbolName - the name of the symbol
Returns:
the symbol object from the context path
See Also:
symbol(String)








Dummy
public static ISymbol Dummy()
Create a unique dummy symbol with prefix "$", which is retrieved from the evaluation engines
 DUMMY context. A "Dummy" symbol is not known in string parsing.

Returns:
the symbol object from the context path








localBiFunction
public static IBuiltInSymbol localBiFunction(String symbolName,
                                             BinaryOperator<IExpr> function)







localFunction
public static IBuiltInSymbol localFunction(String symbolName,
                                           UnaryOperator<IExpr> function)







localFunction
public static IBuiltInSymbol localFunction(String symbolName,
                                           IEvaluator evaluator)







localBiPredicate
public static IBuiltInSymbol localBiPredicate(String symbolName,
                                              BiPredicate<IExpr,IExpr> function)







localPredicate
public static IBuiltInSymbol localPredicate(String symbolName,
                                            Predicate<IExpr> function)







removeUserSymbol
public static ISymbol removeUserSymbol(String symbolName)
Remove a user-defined symbol from the eval engines context path. Doesn't remove predefined
 names from the System Context.

Parameters:
symbolName - the name of the symbol
Returns:
the removed symbol or null if no symbol was found








ReleaseHold
public static IAST ReleaseHold(IExpr z)







Return
public static IAST Return(IExpr a)







Reverse
public static IAST Reverse(IExpr a)







RomanNumeral
public static IAST RomanNumeral(IExpr a)







Root
public static IAST Root(IExpr function,
                        IExpr k)







Root
public static IAST Root(IExpr function,
                        int k)







Roots
public static IAST Roots(IExpr a0)







Roots
public static IAST Roots(IExpr a0,
                         IExpr a1)







Round
public static IAST Round(IExpr x)







RotationTransform
public static IAST RotationTransform(IExpr x)







RowBox
public static IAST RowBox(IAST list)







RowReduce
public static IAST RowReduce(IExpr m)







Rule
public static IAST Rule(String lhsStr,
                        IExpr rhs)
Represents a rule replacing lhsStr with rhs.

 
 See: Rule

Parameters:
lhsStr - 
rhs - 
Returns:








Rule
public static IAST Rule(String lhsStr,
                        String rhsStr)
Represents a rule replacing lhsStr with rhsStr.

 
 See: Rule

Parameters:
lhsStr - 
rhsStr - 
Returns:








Rule
public static IAST Rule(IExpr lhs,
                        IExpr rhs)
Represents a rule replacing lhs with rhs.

 
 See: Rule

Parameters:
lhs - 
rhs - 
Returns:








Rule
public static IAST Rule(IExpr lhs,
                        String rhsStr)
Represents a rule replacing lhs with rhsStr.

 
 See: Rule

Parameters:
lhs - 
rhsStr - 
Returns:








RuleDelayed
public static IAST RuleDelayed(IExpr lhs,
                               IExpr rhs)
Represents a rule replacing lhs with rhs, with rhs held
 unevaluated.

 
 See: RuleDelayed

Parameters:
lhs - 
rhs - 
Returns:








SameQ
public static IAST SameQ(IExpr lhs,
                         IExpr rhs)
Returns S.True if lhs and rhs are structurally identical.

 
 See: SameQ

Parameters:
lhs - 
rhs - 
Returns:








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







SameQ
public static IAST SameQ(IExpr a0,
                         double d)







ScalingTransform
public static IAST ScalingTransform(IExpr z)







Scan
public static IAST Scan(IExpr a0,
                        IExpr a1)







Sec
public static IAST Sec(IExpr z)







Sech
public static IAST Sech(IExpr z)







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







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







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







Sequence
public static IASTAppendable Sequence()







Sequence
public static IAST Sequence(IExpr a0)







Sequence
public static IAST Sequence(IExpr... a)







Sequence
public static IASTMutable Sequence(int... numbers)







Series
public static IAST Series(IExpr... a)







SeriesCoefficient
public static IAST SeriesCoefficient(IExpr a0,
                                     IExpr a1)







SeriesData
public static IAST SeriesData(IExpr... a)







Set
public static IAST Set(IExpr lhs,
                       IExpr rhs)
Evaluates rhs and assigns it to lhs.

 
 See: Set

Parameters:
lhs - 
rhs - 
Returns:








SetAttributes
public static IAST SetAttributes(IExpr symbol,
                                 IExpr attribute)







SetDelayed
public static IAST SetDelayed(IExpr lhs,
                              IExpr rhs)
Assigns rhs to lhs, without evaluating rhs.

 
 See: SetDelayed

Parameters:
lhs - 
rhs - 
Returns:








Show
public static IAST Show(IExpr a0)







Sign
public static IAST Sign(IExpr z)







Signature
public static IAST Signature(IExpr a)







SignCmp
public static IAST SignCmp(IExpr z)







Simplify
public static IAST Simplify(IExpr expr)







Simplify
public static IAST Simplify(IExpr expr,
                            IExpr assum)







Sin
public static IAST Sin(IExpr z)
Returns the sine of z (measured in
 Radians).

 
 See: Sin

Parameters:
z - 
Returns:








Sinc
public static IAST Sinc(IExpr z)







Sinh
public static IAST Sinh(IExpr z)







SinhIntegral
public static IAST SinhIntegral(IExpr z)







SinIntegral
public static IAST SinIntegral(IExpr z)







Skewness
public static IAST Skewness(IExpr a0)







Slot
public static IAST Slot(IExpr a0)







Slot
public static IAST Slot(int i)







Slot
public static IAST Slot(String str)







SlotSequence
public static IAST SlotSequence(int i)







Solve
public static IAST Solve(IExpr a0,
                         IExpr a1)
See Solve







Solve
public static IAST Solve(IExpr a0,
                         IExpr a1,
                         IAST options)







solve
public static IExpr[] solve(IAST equations,
                            ISymbol variable)
Solve an equation for a single variable.

 
 Solve 100-x==0 for variable x

 
 ISymbol x = F.Dummy(engine);
 IExpr[] solutions = F.solve(F.Equal(F.Subtract(F.ZZ(100), x), F.C0), x);
 

 See Solve

Parameters:
equations - one single equation or a list of equations.
variable - 
Returns:








Sort
public static IAST Sort(IExpr a0)







Sort
public static IAST Sort(IExpr a0,
                        IExpr a1)







Sow
public static IAST Sow(IExpr a)







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







Sphere
public static IAST Sphere(IExpr vector,
                          IExpr radius)







SphericalBesselJ
public static IAST SphericalBesselJ(IExpr n,
                                    IExpr z)







SphericalBesselY
public static IAST SphericalBesselY(IExpr n,
                                    IExpr z)







SphericalHankelH1
public static IAST SphericalHankelH1(IExpr n,
                                     IExpr z)







SphericalHankelH2
public static IAST SphericalHankelH2(IExpr n,
                                     IExpr z)







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







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

 
 See: Sqrt

Parameters:
x - 
Returns:








Sqrt
public static IAST Sqrt(int n)
Create a "square root" expression: Power(n, 1/2).

 
 See: Sqrt

Parameters:
n - 
Returns:








StandardDeviation
public static IAST StandardDeviation(IExpr a0)







Standardize
public static IAST Standardize(IExpr a0)







Standardize
public static IAST Standardize(IExpr a0,
                               IExpr a1)







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







StieltjesGamma
public static IAST StieltjesGamma(IExpr a0)







StieltjesGamma
public static IAST StieltjesGamma(IExpr a0,
                                  IExpr a1)







StirlingS1
public static IAST StirlingS1(IExpr n,
                              IExpr m)







StirlingS2
public static IAST StirlingS2(IExpr n,
                              IExpr m)







StringJoin
public static IAST StringJoin(IExpr a)







Surd
public static IAST Surd(IExpr a0,
                        IExpr a1)







stringx
public static final IStringX stringx(char c)
Create a Symja string expression with mime type TEXT_PLAIN.

Parameters:
c - 
Returns:
See Also:
IStringX.TEXT_PLAIN








stringx
public static final IStringX stringx(String str)
Create a Symja string expression with mime type TEXT_PLAIN.

Parameters:
str - 
Returns:
See Also:
IStringX.TEXT_PLAIN








stringx
public static final IStringX stringx(String str,
                                     short mimeType)
reate a Symja string expression.

Parameters:
str - 
mimeType - the mime type of the string
Returns:
See Also:
IStringX.TEXT_PLAIN, 
IStringX.TEXT_LATEX, 
IStringX.TEXT_MATHML, 
IStringX.TEXT_HTML








stringx
public static final IStringX stringx(StringBuilder str)
Create a string expression

Parameters:
str - 
Returns:








StruveH
public static IAST StruveH(IExpr a0,
                           IExpr a1)







StruveL
public static IAST StruveL(IExpr a0,
                           IExpr a1)







StudentTDistribution
public static IAST StudentTDistribution(IExpr a0)







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







Style
public static IAST Style(IExpr a0,
                         IExpr a1)







Subdivide
public static IAST Subdivide(IExpr a0)







Subdivide
public static IAST Subdivide(IExpr a0,
                             IExpr a1)







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







subdivide
public static IAST subdivide(int n)
Create a list {0, 1/n,2/n,3/n,...,n}.

Parameters:
n - the number of the "elements of the result list" minus 1
Returns:
a list {0, 1/n,2/n,3/n,...,n}








subdivide
public static IAST subdivide(int xMax,
                             int n)
Create a list by dividing the range 0 to xMax into n
 parts.

Parameters:
xMax - end of range (inclusive)
n - the number of the "elements of the result list" minus 1
Returns:








subdivide
public static IAST subdivide(int xMin,
                             int xMax,
                             int n)
Create a list by dividing the range xMin to xMax into n
 parts.

Parameters:
xMin - start of range (inclusive)
xMax - end of range (inclusive)
n - the number of the "elements of the result list" minus 1
Returns:








subdivide
public static ASTRealVector subdivide(double xMax,
                                      int n)
Create a list by dividing the range 0 to xMax into n
 parts.

Parameters:
xMax - end of range (inclusive)
n - the number of the "elements of the result list" minus 1
Returns:








subdivide
public static ASTRealVector subdivide(double xMin,
                                      double xMax,
                                      int n)
Create a list by dividing the range xMin to xMax into n
 parts.

Parameters:
xMin - start of range (inclusive)
xMax - end of range (inclusive)
n - the number of the "elements of the result list" minus 1
Returns:








Subfactorial
public static IAST Subfactorial(IExpr a0)







Subscript
public static IAST Subscript(IExpr x,
                             IExpr y)







subs
public static IExpr subs(IExpr expr,
                         IExpr x,
                         IExpr y)
Substitute all (sub-) expressions x in expr with y. If
 no substitution matches, the method returns the given expr.

Parameters:
expr - the complete expresssion
x - the subexpression which should be replaced
y - the expression which replaces x
Returns:
the input expr if no substitution of a (sub-)expression was possible or
         the substituted expression.








subsList
public static IExpr subsList(IExpr expr,
                             Map<? extends IExpr,? extends IExpr> map)
Substitute all (sub-) expressions contained as keys in map in expr
 with the corresponding value in map. If no substitution matches, the method
 returns the given expr.

Parameters:
expr - 
Returns:








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

Parameters:
expr - 
function - if the unary functions apply() method returns F.NIL
        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,
                          Map<? extends IExpr,? extends IExpr> map)
Substitute all (sub-) expressions with the given map. If no substitution matches, the method
 returns the given expr.

Parameters:
expr - 
map - if the maps get() 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.








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.








Subtract
public static IAST Subtract(IExpr x,
                            IExpr y)
Return x + (-1)*y

Parameters:
x - 
y - 
Returns:








Subtract
public static IAST Subtract(IExpr x,
                            int y)
Return x + (-1)*y

Parameters:
x - 
y - 
Returns:








SubtractSides
public static IASTMutable SubtractSides(IExpr equationOrInequality)







SubtractSides
public static IASTMutable SubtractSides(IExpr equationOrInequality,
                                        IExpr x)







Sum
public static IAST Sum(IExpr expr,
                       IExpr iterationSpecification)

Parameters:
expr - expression which should be summed up
iterationSpecification - a standard iteration specification
Returns:
Sum(expr, iterationSpecification) AST








Sum
public static IAST Sum(IExpr expr,
                       IExpr iterationSpecification1,
                       IExpr iterationSpecification2)







Sum
public static IAST Sum(IExpr expr,
                       IExpr iterationSpecification1,
                       IExpr iterationSpecification2,
                       IExpr iterationSpecification3)







Sum
public static IAST Sum(IExpr expr,
                       IExpr iterationSpecification1,
                       IExpr iterationSpecification2,
                       IExpr iterationSpecification3,
                       IExpr iterationSpecification4)







Sum
public static IAST Sum(IExpr expr,
                       IExpr iterationSpecification1,
                       IExpr iterationSpecification2,
                       IExpr iterationSpecification3,
                       IExpr iterationSpecification4,
                       IExpr iterationSpecification5)







sumRational
public static IRational sumRational(IntFunction<IRational> function,
                                    int iMin,
                                    int iMax)







sum
public static IExpr sum(Function<IInteger,IExpr> function,
                        int iMin,
                        int iMax)
Evaluate the sum from iMin to iMax and step 1.

Parameters:
function - 
iMin - 
iMax - 
Returns:








intProduct
public static IExpr intProduct(Function<IInteger,IExpr> function,
                               int from,
                               int to,
                               int step)
Iterate over an integer range from <= i <= to with the step step/code> and
 evaluate the S.Product


Parameters:
function - the function which should be applied on each iterator value
from - from this position (included)
to - to this position (included)
step - 
Returns:








intSum
public static IExpr intSum(IntFunction<IExpr> function,
                           int iMin,
                           int iMax)
Calculate Sum(function(k), {k, iMin, iMax})

Parameters:
function - 
iMin - from this position (included)
iMax - to this position (included)
Returns:








intSum
public static IExpr intSum(Function<IInteger,IExpr> function,
                           int from,
                           int to,
                           int step)
Iterate over an integer range from <= i <= to with the step step/code> and
 evaluate the S.Sum


Parameters:
function - the function which should be applied on each iterator value
from - from this position (included)
to - to this position (included)
step - 
Returns:








intSum
public static IExpr intSum(Function<IInteger,IExpr> function,
                           int from,
                           int to,
                           int step,
                           boolean expand)
Iterate over an integer range from <= i <= to with the step step/code> and
 evaluate the S.Sum


Parameters:
function - the function which should be applied on each iterator value
from - from this position (included)
to - to this position (included)
step - 
expand - expand S.Plus, S.Times, S.Power subexpressions
Returns:








sum
public static IExpr sum(Function<IInteger,IExpr> function,
                        int iMin,
                        int iMax,
                        int iStep)
Evaluate the sum from iMin to iMax and step iStep.

Parameters:
function - 
iMin - from this position (included)
iMax - to this position (included)
iStep - 
Returns:








sum
public static IExpr sum(Function<IInteger,IExpr> function,
                        int iMin,
                        int iMax,
                        int iStep,
                        boolean expand)
Evaluate the sum from iMin to iMax and step iStep.

Parameters:
function - 
iMin - from this position (included)
iMax - to this position (included)
iStep - 
expand - expand S.Plus, S.Times, S.Power subexpressions
Returns:








Superscript
public static IAST Superscript(IExpr x,
                               IExpr y)







SurfaceGraphics
public static IASTAppendable SurfaceGraphics()







Switch
public static IAST Switch(IExpr... a)







Table
public static IAST Table(IExpr expr,
                         IExpr iterationSpecification)
See Table

Parameters:
expr - expression which should be iterated
iterationSpecification - a standard iteration specification
Returns:
Table(expr, iterationSpecification) AST








Table
public static IAST Table(IExpr expr,
                         IExpr iterationSpecification1,
                         IExpr iterationSpecification2)







TagSet
public static IASTMutable TagSet(IExpr a0,
                                 IExpr a1,
                                 IExpr a2)







TagSetDelayed
public static IASTMutable TagSetDelayed(IExpr a0,
                                        IExpr a1,
                                        IExpr a2)







Take
public static IAST Take(IExpr a0,
                        IExpr a1)
See Take







TakeLargest
public static IASTMutable TakeLargest(IExpr a0,
                                      IExpr a1)







TakeLargestBy
public static IASTMutable TakeLargestBy(IExpr a0,
                                        IExpr a1,
                                        IExpr a2)







TakeSmallest
public static IASTMutable TakeSmallest(IExpr a0,
                                       IExpr a1)







TakeSmallestBy
public static IASTMutable TakeSmallestBy(IExpr a0,
                                         IExpr a1,
                                         IExpr a2)







Tan
public static IAST Tan(IExpr z)
Returns the tangent of z (measured in
 Radians).

 
 See: Tan

Parameters:
z - 
Returns:








Tanh
public static IAST Tanh(IExpr z)
See Tanh







Taylor
public static IAST Taylor(IExpr a0,
                          IExpr a1)







TensorRank
public static IAST TensorRank(IExpr a0)







TensorSymmetry
public static IAST TensorSymmetry(IExpr a0)







TensorSymmetry
public static IAST TensorSymmetry(IExpr a0,
                                  IExpr a1)







TeXForm
public static IAST TeXForm(IExpr expr)
See TeXForm







Text
public static IAST Text(IExpr expr,
                        IAST coords)







ternaryAST3
public static final IASTMutable ternaryAST3(IExpr head,
                                            IExpr arg1,
                                            IExpr arg2,
                                            IExpr arg3)
Create a function head(arg1, arg2, arg3) with 3 argument as an AST3
 mutable object without evaluation.

Parameters:
head - 
arg1 - 
arg2 - 
arg3 - 
Returns:








Thread
public static IAST Thread(IExpr a0)
See Thread







ThreeJSymbol
public static final IAST ThreeJSymbol(IExpr arg1,
                                      IExpr arg2,
                                      IExpr arg3)







Throw
public static IAST Throw(IExpr a)
See Throw







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







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







Times
public static IASTAppendable Times()
See: Times

Returns:








TimesAlloc
public static IASTAppendable TimesAlloc(int initialCapacity)
Create a Times() function with allocated space for size elements. See: Times

Parameters:
initialCapacity - the initialCapacity of this AST
Returns:








Times
public static IASTAppendable Times(IExpr x)
See: Times







Times
public static IAST Times(IExpr... a)
Define a Times() expression a1 * a2 * ... for multiplication.

 
 See: Times







Times
public static IASTMutable Times(IExpr x,
                                IExpr y)
Define a Times() expression x * y for multiplication.

 
 See: Times







timesDistribute
public static IExpr timesDistribute(@Nonnull
                                    IExpr x,
                                    @Nonnull
                                    IExpr y,
                                    EvalEngine engine)







Times
public static IAST Times(IExpr x,
                         IExpr y,
                         IExpr z)
Define a Times() expression a0 * a1 * a2 for multiplication.

 
 See: Times







Times
public static IAST Times(long num,
                         IExpr... a)
See: Times







ToExpression
public static IAST ToExpression(IExpr a0)
See ToExpression







toIntDefault
public static int toIntDefault(double value)
Converts this number to an int value; this method returns
 Integer.MIN_VALUE, if the value of this integer isn't in the range
 java.lang.Integer.MIN_VALUE+1 to java.lang.Integer.MAX_VALUE-1 or the
 expression is not convertible to the int range.

Returns:
the numeric value represented by this expression after conversion to type int
      or Integer.MIN_VALUE if this expression cannot be converted.








toIntDefault
public static int toIntDefault(double value,
                               int defaultValue)
Converts this number to an int value; this method returns
 defaultValue, if the value of this integer isn't in the range
 java.lang.Integer.MIN_VALUE+1 to java.lang.Integer.MAX_VALUE-1 or the
 expression is not convertible to the int range.

Parameters:
value - 
defaultValue - the default value, if this integer is not in the int range
Returns:
the numeric value represented by this integer after conversion to type int








ToIntervalData
public static IAST ToIntervalData(IExpr expr)







ToIntervalData
public static IAST ToIntervalData(IExpr expr,
                                  IExpr variable)







Together
public static IAST Together(IExpr a0)
See Together







ToPolarCoordinates
public static IAST ToPolarCoordinates(IExpr a0)







ToSphericalCoordinates
public static IAST ToSphericalCoordinates(IExpr a0)







Total
public static IAST Total(IExpr a0)
See Total







Tr
public static IAST Tr(IExpr a0)
See Tr







Trace
public static IAST Trace(IExpr a0)







TransformationFunction
public static IAST TransformationFunction(IExpr a0)







TranslationTransform
public static IAST TranslationTransform(IExpr a0)







Transpose
public static IAST Transpose(IExpr list)
See Transpose







Triangle
public static IAST Triangle(IAST list)







TrigExpand
public static IAST TrigExpand(IExpr expr)
See TrigExpand







TrigReduce
public static IAST TrigReduce(IExpr expr)
See TrigReduce







TrigSimplifyFu
public static IAST TrigSimplifyFu(IExpr expr)







TrigToExp
public static IAST TrigToExp(IExpr expr)
See TrigToExp







TrueQ
public static IAST TrueQ(IExpr expr)
See TrueQ







unary
public static final IASTAppendable unary(IExpr head,
                                         IExpr arg)
Create a function head(arg) with 1 argument without evaluation.

Parameters:
head - 
arg - 
Returns:








unaryAST1
public static final IASTMutable unaryAST1(IExpr head,
                                          IExpr arg)
Create a function head(arg) with 1 argument as an AST1 mutable object
 without evaluation.

Parameters:
head - 
arg - 
Returns:








Underflow
public static IAST Underflow()







UndirectedEdge
public static IAST UndirectedEdge(IExpr a,
                                  IExpr b)
UndirectedEdge is an undirected edge between the vertices a and
 b in a `graph` object.

 
 See: UndirectedEdge

Parameters:
a - 
b - 
Returns:








Unequal
public static IAST Unequal(IExpr lhs,
                           IExpr rhs)
Yields S.False if lhs and rhs are known to be equal, or
 S.True if lhs and rhs are known to be unequal.

 
 See: Unequal

Parameters:
lhs - 
rhs - 
Returns:








Unevaluated
public static IAST Unevaluated(IExpr a0)







Union
public static IAST Union(IExpr list1)







Union
public static IAST Union(IExpr list1,
                         IExpr list2)







Unique
public static IAST Unique(IExpr a0)







UnitConvert
public static IAST UnitConvert(IExpr quantity)
Convert the quantity to the base unit.

 
 See: UnitConvert

Parameters:
quantity - 
Returns:








UnitConvert
public static IAST UnitConvert(IExpr quantity,
                               IExpr unit)
Convert the quantity to the given unit.

 
 See: UnitConvert

Parameters:
quantity - 
unit - 
Returns:








UniformDistribution
public static IAST UniformDistribution(IExpr a)







UnitStep
public static IAST UnitStep(IExpr a0)







UnsameQ
public static IAST UnsameQ(IExpr lhs,
                           IExpr rhs)
Returns S.True if lhs and rhs are not structurally identical.

 
 See: UnsameQ

Parameters:
lhs - 
rhs - 
Returns:








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)







Variables
public static IAST Variables(IExpr a0)







Variance
public static IAST Variance(IExpr a0)







WeberE
public static IAST WeberE(IExpr v,
                          IExpr z)







WeberE
public static IAST WeberE(IExpr v,
                          IExpr m,
                          IExpr z)







WeibullDistribution
public static IAST WeibullDistribution(IExpr a0,
                                       IExpr a1)







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







While
public static IAST While(IExpr test,
                         IExpr body)
Evaluates body as long as test evaluates to S.True.

 
 See: While

Parameters:
test - 
body - 
Returns:








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







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







With
public static IAST With(IExpr listOfLocalVariables,
                        IExpr expr)
Evaluates expr for thelistOfLocalVariables by replacing the local
 variables in expr.

 
 See: With

Parameters:
listOfLocalVariables - 
expr - 
Returns:








ZeroSymmetric
public static IAST ZeroSymmetric(IExpr a0)
Symmetry of a zero tensor.

Parameters:
a0 - 
Returns:








Zeta
public static IAST Zeta(IExpr s)







Zeta
public static IAST Zeta(IExpr s,
                        IExpr a)







ZTransform
public static IAST ZTransform(IExpr expr,
                              IExpr n,
                              IExpr z)







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

Parameters:
integerValue - 
Returns:








ZZ
public static IInteger ZZ(int integerValue)
Create an integer number by using the internal small integer number cache. The returned object
 references might be the same.

Parameters:
integerValue - 
Returns:








ZZUniqueReference
public static IInteger ZZUniqueReference(int integerValue)
Create a new integer number without using the internal small integer number cache. The returned
 object references will always be newly created.

Parameters:
integerValue - 
Returns:








ZZ
public static IInteger ZZ(long integerValue)
Create an integer number.

Parameters:
integerValue - 
Returns:








ZZ
public static IInteger ZZ(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








operatorForm1Append
public static IAST operatorForm1Append(IAST ast1)
The operator form op(f)[expr] is transformed to op(expr, f). The
 operator form op(f, g)[expr] is transformed to op(expr, f, g)

Parameters:
ast1 - an IAST with condition ast1Arg.head().isAST1() && ast1Arg.isAST1()
Returns:








operatorFormAppend2
public static IAST operatorFormAppend2(IAST astArg)
The binary operator form op(f, g)[expr] is transformed to op(expr, f, g)
 

Parameters:
astArg - an IAST with condition astArg.head().isAST2() && astArg.isAST1()
Returns:








operatorForm2Prepend
public static IAST operatorForm2Prepend(IAST ast1,
                                        int[] expected,
                                        EvalEngine engine)
The operator form op(f)[expr] is transformed to op(f, expr). The
 operator form op(f)[expr1, expr2] is transformed to op(f, expr1, expr2)
 .

Parameters:
ast1 - an IAST with condition 
     ast1Arg.head().isAST1() && ast1Arg.isAST1()
Returns:








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







Matrices
public static IAST Matrices(IExpr a0,
                            IExpr a1)







Matrices
public static IAST Matrices(IExpr a0)







matrix
public static IAST matrix(BiIntFunction<? extends IExpr> biFunction,
                          int n,
                          int m)
Generate a n x m matrix. The indices start in Java convention with 0.

Parameters:
biFunction - 
n - the number of rows of the matrix.
m - the number of elements in one row
Returns:








vector
public static IAST vector(IntFunction<? extends IExpr> iFunction,
                          int n)
Generate a vector with n elements.

Parameters:
iFunction - 
n - the number of elements of the vector.
Returns:








Vectors
public static IAST Vectors(IExpr a0,
                           IExpr a1)







Vectors
public static IAST Vectors(IExpr a0)







fromString
public static IExpr fromString(String string)
Parses a given string to an instance of IExpr

 
 Examples:

 
 "7/9" -> RationalScalar.of(7, 9)
 "3.14" -> DoubleScalar.of(3.14)
 "(3+2)*I/(-1+4)+8-I" -> ComplexScalar.of(8, 2/3) == "8+2/3*I"
 "9.81[m*s^-2]" -> Quantity.of(9.81, "m*s^-2")
 

 If the parsing logic encounters an inconsistency, the return type is a IStringX that
 holds the input string.

 
 Scalar types that are not supported include GaussScalar.

Parameters:
string - 
Returns:
scalar








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







show
public static String show(IExpr expr)
Show the result in an HTML page with the help of the Java Desktop.getDesktop().open()
  method. On some platforms the Desktop API may not be supported; use the 
 isDesktopSupported() method todetermine if the current desktop is supported.

Parameters:
expr - 
Returns:
Throws:
IOException








showGraphic
public static String showGraphic(IExpr expr)







openHTMLOnDesktop
public static String openHTMLOnDesktop(String html)
                                throws IOException

Throws:
IOException








flattenSequence
public static IAST flattenSequence(IAST list)
Iterate over the arguments of list and flatten the arguments of 
 Sequence(...)
  expressions. (i.e. {Sequence(a,b,...)} is rewritten as {a,b,...}
 ). If some of the elements is the symbol Nothing it's automatically removed
 from the arguments.

Parameters:
list - an AST which may contain Sequence(...) expressions or Nothing
      symbols.
Returns:
F.NIL if no sequence is flattened

Class F

Field Summary

Fields inherited from class org.matheclipse.core.expression.S

Constructor Summary

Method Summary

Methods inherited from class org.matheclipse.core.expression.S

Methods inherited from class java.lang.Object

Field Detail

REMEMBER_INTEGER_CACHE

PREDEFINED_INTERNAL_FORM_STRINGS

SYMBOL_OBSERVER

NIL

INVALID

a_

b_

c_

d_

e_

f_

g_

h_

i_

j_

k_

l_

m_

n_

o_

p_

q_

r_

s_

t_

u_

v_

w_

x_

y_

z_

x__

y__

z__

x___

y___

z___

A_

B_

C_

F_

G_

P_

Q_

m_Integer

n_Integer

a_Symbol

b_Symbol

c_Symbol

d_Symbol

e_Symbol

f_Symbol

g_Symbol

h_Symbol

i_Symbol

j_Symbol

k_Symbol

l_Symbol

m_Symbol

n_Symbol

o_Symbol

p_Symbol

q_Symbol

r_Symbol

s_Symbol

t_Symbol

u_Symbol

v_Symbol

w_Symbol

x_Symbol

y_Symbol

z_Symbol