UtilityFunctionCtors

java.lang.Object
- org.matheclipse.core.integrate.rubi45.UtilityFunctionCtors

```
public class UtilityFunctionCtors
extends java.lang.Object
```
UtilityFunction constructors from the Rubi - rule-based integrator. TODO a lot of functions are only placeholders at the moment.

Field Summary

Fields
Modifier and Type	Field and Description
`static ISymbol`	`A`
`static ISymbol`	`AbortRubi`
`static ISymbol`	`B`
`static ISymbol`	`C`
`static ISymbol`	`F`
`static ISymbol`	`G`
`static ISymbol`	`H`
`static java.lang.String`	`INTEGRATE_PREFIX`
`static ISymbol`	`INTEGRATE_REAPLIST`
`static ISymbol`	`INTEGRATE_SIMP`
`static ISymbol`	`INTEGRATE_SMARTDENOMINATOR`
`static ISymbol`	`INTEGRATE_SMARTLEAFCOUNT`
`static ISymbol`	`INTEGRATE_SMARTNUMERATOR`
`static ISymbol`	`INTEGRATE_TRIG_SIMPLIFY`
`static ISymbol`	`J`
`static ISymbol`	`K`
`static ISymbol`	`L`
`static ISymbol`	`M`
`static ISymbol`	`O`
`static ISymbol`	`P`
`static ISymbol`	`Q`
`static ISymbol`	`R`
`static ISymbol`	`S`
`static ISymbol`	`T`
`static ISymbol`	`U`
`static ISymbol`	`V`
`static ISymbol`	`W`
`static ISymbol`	`X`
`static ISymbol`	`Y`
`static ISymbol`	`Z`

Constructor Summary

Constructors
Constructor and Description

UtilityFunctionCtors()

Constructors
Constructor and Description
`UtilityFunctionCtors()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static IAST`	`AbortRubi(IExpr a0)`
`static IAST`	`AbsorbMinusSign(IExpr a0)`
`static IAST`	`AbsurdNumberFactors(IExpr a0)`
`static IAST`	`AbsurdNumberGCD(IExpr... a)`
`static IAST`	`AbsurdNumberGCDList(IExpr a0, IExpr a1)`
`static IAST`	`AbsurdNumberQ(IExpr a0)`
`static IAST`	`ActivateTrig(IExpr a0)`
`static IAST`	`AlgebraicFunctionFactors(IExpr a0, IExpr a1)`
`static IAST`	`AlgebraicFunctionQ(IExpr a0, IExpr a1)`
`static IAST`	`AlgebraicTrigFunctionQ(IExpr a0, IExpr a1)`
`static IAST`	`BinomialDegree(IExpr a0, IExpr a1)`
`static IAST`	`BinomialMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`BinomialQ(IExpr a0, IExpr a1)`
`static IAST`	`BinomialQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`BinomialTest(IExpr a0, IExpr a1)`
`static IAST`	`CalculusFreeQ(IExpr a0, IExpr a1)`
`static IAST`	`CalculusQ(IExpr a0)`
`static IAST`	`CancelCommonFactors(IExpr a0, IExpr a1)`
`static IAST`	`CollectReciprocals(IExpr a0, IExpr a1)`
`static IAST`	`CombineExponents(IExpr a0)`
`static IAST`	`CommonFactors(IExpr a0)`
`static IAST`	`CommonNumericFactors(IExpr a0)`
`static IAST`	`ComplexFreeQ(IExpr a0)`
`static IAST`	`ConstantFactor(IExpr a0, IExpr a1)`
`static IAST`	`ContentFactor(IExpr a0)`
`static IAST`	`ContentFactorAux(IExpr a0)`
`static IAST`	`CoshQ(IExpr a0)`
`static IAST`	`CosQ(IExpr a0)`
`static IAST`	`CothQ(IExpr a0)`
`static IAST`	`CotQ(IExpr a0)`
`static IAST`	`CschQ(IExpr a0)`
`static IAST`	`CscQ(IExpr a0)`
`static IAST`	`CubicMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`DeactivateTrig(IExpr a0, IExpr a1)`
`static IAST`	`DeactivateTrigAux(IExpr a0, IExpr a1)`
`static IAST`	`DerivativeDivides(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Dist(IExpr a0, IExpr a1)`
`static IAST`	`Dist(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Distrib(IExpr a0, IExpr a1)`
`static IAST`	`DivideDegreesOfFactors(IExpr a0, IExpr a1)`
`static IAST`	`Divides(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`EasyDQ(IExpr a0, IExpr a1)`
`static IAST`	`EulerIntegrandQ(IExpr a0, IExpr a1)`
`static IAST`	`EvenQuotientQ(IExpr a0, IExpr a1)`
`static IAST`	`ExpandAlgebraicFunction(IExpr a0, IExpr a1)`
`static IAST`	`ExpandCleanup(IExpr a0, IExpr a1)`
`static IAST`	`ExpandExpression(IExpr a0, IExpr a1)`
`static IAST`	`ExpandIntegrand(IExpr a0, IExpr a1)`
`static IAST`	`ExpandIntegrand(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExpandLinearProduct(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`ExpandToSum(IExpr a0, IExpr a1)`
`static IAST`	`ExpandToSum(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExpandTrig(IExpr a0, IExpr a1)`
`static IAST`	`ExpandTrig(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExpandTrigExpand(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4, IExpr a5)`
`static IAST`	`ExpandTrigReduce(IExpr a0, IExpr a1)`
`static IAST`	`ExpandTrigReduce(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExpandTrigReduceAux(IExpr a0, IExpr a1)`
`static IAST`	`ExpandTrigToExp(IExpr a0, IExpr a1)`
`static IAST`	`ExpandTrigToExp(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExponentIn(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExponentInAux(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ExpQ(IExpr a0)`
`static IAST`	`F(IExpr a0)`
`static IAST`	`F(IExpr a0, IExpr a1)`
`static IAST`	`FactorAbsurdNumber(IExpr a0)`
`static IAST`	`FactorNumericGcd(IExpr a0)`
`static IAST`	`FactorOrder(IExpr a0, IExpr a1)`
`static IAST`	`FalseQ(IExpr a0)`
`static IAST`	`FindTrigFactor(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`FixInertTrigFunction(IExpr a0, IExpr a1)`
`static IAST`	`FixIntRule(IExpr a0, IExpr a1)`
`static IAST`	`FixIntRules(IExpr a0)`
`static IAST`	`FixRhsIntRule(IExpr a0, IExpr a1)`
`static IAST`	`FixSimplify(IExpr a0)`
`static IAST`	`FractionalPowerFreeQ(IExpr a0)`
`static IAST`	`FractionalPowerOfLinear(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FractionalPowerOfQuotientOfLinears(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FractionalPowerOfSquareQ(IExpr a0)`
`static IAST`	`FractionalPowerQ(IExpr a0)`
`static IAST`	`FractionalPowerSubexpressionQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FractionOrNegativeQ(IExpr... a)`
`static IAST`	`FractionQ(IExpr... a)`
`static IAST`	`FreeFactors(IExpr a0, IExpr a1)`
`static IAST`	`FreeTerms(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfCoshQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfCosQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfDensePolynomialsQ(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfExpnQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfExponential(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfExponentialFunction(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfExponentialFunctionAux(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfExponentialQ(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfExponentialTest(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfExponentialTestAux(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfHyperbolic(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfHyperbolic(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfHyperbolicQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfInverseLinear(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfInverseLinear(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfLinear(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfLinear(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`FunctionOfLinearSubst(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FunctionOfLog(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfLog(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FunctionOfQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfQ(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`FunctionOfSinhQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfSinQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfSquareRootOfQuadratic(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfSquareRootOfQuadratic(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfTanhQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfTanhWeight(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfTanQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfTanWeight(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfTrig(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfTrig(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`FunctionOfTrigOfLinearQ(IExpr a0, IExpr a1)`
`static IAST`	`FunctionOfTrigQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`G(IExpr a0)`
`static IAST`	`G(IExpr a0, IExpr a1)`
`static IAST`	`Gcd(IExpr... a)`
`static IAST`	`Gcd(IExpr a0, IExpr a1)`
`static IAST`	`GE(IExpr a0, IExpr a1)`
`static IAST`	`GE(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`GeneralizedBinomialDegree(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedBinomialMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedBinomialQ(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedBinomialTest(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedTrinomialDegree(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedTrinomialMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedTrinomialQ(IExpr a0, IExpr a1)`
`static IAST`	`GeneralizedTrinomialTest(IExpr a0, IExpr a1)`
`static IAST`	`GensymSubst(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`GT(IExpr a0, IExpr a1)`
`static IAST`	`GT(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`H(IExpr a0)`
`static IAST`	`H(IExpr a0, IExpr a1)`
`static IAST`	`H(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`HeldFormQ(IExpr a0)`
`static IAST`	`HyperbolicQ(IExpr a0)`
`static IAST`	`ImaginaryNumericQ(IExpr a0)`
`static IAST`	`ImaginaryQ(IExpr a0)`
`static IAST`	`IndependentQ(IExpr a0, IExpr a1)`
`static IAST`	`InertReciprocalQ(IExpr a0, IExpr a1)`
`static IAST`	`InertTrigFreeQ(IExpr a0)`
`static IAST`	`InertTrigQ(IExpr a0)`
`static IAST`	`InertTrigQ(IExpr a0, IExpr a1)`
`static IAST`	`InertTrigQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`InertTrigSumQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Int(IExpr a0, IExpr a1)` Convert to Integrate[]
`static IAST`	`IntegerPowerQ(IExpr a0)`
`static IAST`	`IntegerQuotientQ(IExpr a0, IExpr a1)`
`static IAST`	`IntegersQ(IExpr... a)`
`static IAST`	`IntSum(IExpr a0, IExpr a1)`
`static IAST`	`IntTerm(IExpr a0, IExpr a1)`
`static IAST`	`InverseFunctionFreeQ(IExpr a0, IExpr a1)`
`static IAST`	`InverseFunctionOfLinear(IExpr a0, IExpr a1)`
`static IAST`	`InverseFunctionOfQuotientOfLinears(IExpr a0, IExpr a1)`
`static IAST`	`InverseFunctionQ(IExpr a0)`
`static IAST`	`InverseHyperbolicQ(IExpr a0)`
`static IAST`	`InverseTrigQ(IExpr a0)`
`static IAST`	`KernelSubst(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`KnownCotangentIntegrandQ(IExpr a0, IExpr a1)`
`static IAST`	`KnownSecantIntegrandQ(IExpr a0, IExpr a1)`
`static IAST`	`KnownSineIntegrandQ(IExpr a0, IExpr a1)`
`static IAST`	`KnownTangentIntegrandQ(IExpr a0, IExpr a1)`
`static IAST`	`KnownTrigIntegrandQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`LE(IExpr a0, IExpr a1)`
`static IAST`	`LE(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`LeadBase(IExpr a0)`
`static IAST`	`LeadDegree(IExpr a0)`
`static IAST`	`LeadFactor(IExpr a0)`
`static IAST`	`LeadTerm(IExpr a0)`
`static IAST`	`LinearMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`LinearPairQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`LinearQ(IExpr a0, IExpr a1)`
`static IAST`	`LogQ(IExpr a0)`
`static IAST`	`LT(IExpr a0, IExpr a1)`
`static IAST`	`LT(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`MakeAssocList(IExpr a0, IExpr a1)`
`static IAST`	`MakeAssocList(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`Map2(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`MapAnd(IExpr a0, IExpr a1)`
`static IAST`	`MapAnd(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`MapOr(IExpr a0, IExpr a1)`
`static IAST`	`MergeableFactorQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`MergeFactor(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`MergeFactors(IExpr a0, IExpr a1)`
`static IAST`	`MergeMonomials(IExpr a0, IExpr a1)`
`static IAST`	`MinimumDegree(IExpr a0, IExpr a1)`
`static IAST`	`MinimumMonomialExponent(IExpr a0, IExpr a1)`
`static IAST`	`MonomialExponent(IExpr a0, IExpr a1)`
`static IAST`	`MonomialFactor(IExpr a0, IExpr a1)`
`static IAST`	`MonomialQ(IExpr a0, IExpr a1)`
`static IAST`	`MonomialSumQ(IExpr a0, IExpr a1)`
`static IAST`	`MostMainFactorPosition(IExpr a0)`
`static IAST`	`NegativeCoefficientQ(IExpr a0)`
`static IAST`	`NegativeIntegerQ(IExpr... a)`
`static IAST`	`NegativeOrZeroQ(IExpr a0)`
`static IAST`	`NegativeQ(IExpr a0)`
`static IAST`	`NegQ(IExpr a0)`
`static IAST`	`NiceSqrtAuxQ(IExpr a0)`
`static IAST`	`NiceSqrtQ(IExpr a0)`
`static IAST`	`NonabsurdNumberFactors(IExpr a0)`
`static IAST`	`NonalgebraicFunctionFactors(IExpr a0, IExpr a1)`
`static IAST`	`NonfreeFactors(IExpr a0, IExpr a1)`
`static IAST`	`NonfreeTerms(IExpr a0, IExpr a1)`
`static IAST`	`NonnumericFactors(IExpr a0)`
`static IAST`	`NonpolynomialTerms(IExpr a0, IExpr a1)`
`static IAST`	`NonpositiveFactors(IExpr a0)`
`static IAST`	`NonrationalFunctionFactors(IExpr a0, IExpr a1)`
`static IAST`	`NonsumQ(IExpr a0)`
`static IAST`	`NonzeroQ(IExpr a0)`
`static IAST`	`NormalizeIntegrand(IExpr a0, IExpr a1)`
`static IAST`	`NormalizeIntegrandAux(IExpr a0, IExpr a1)`
`static IAST`	`NormalizeIntegrandFactor(IExpr a0, IExpr a1)`
`static IAST`	`NormalizeIntegrandFactorBase(IExpr a0, IExpr a1)`
`static IAST`	`NormalizeLeadTermSigns(IExpr a0)`
`static IAST`	`NormalizePowerOfLinear(IExpr a0, IExpr a1)`
`static IAST`	`NormalizeSumFactors(IExpr a0)`
`static IAST`	`NormalizeTogether(IExpr a0)`
`static IAST`	`NormalizeTrig(IExpr a0, IExpr a1)`
`static IAST`	`NotFalseQ(IExpr a0)`
`static IAST`	`NotIntegrableQ(IExpr a0, IExpr a1)`
`static IAST`	`NumericFactor(IExpr a0)`
`static IAST`	`OddHyperbolicPowerQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`OddQuotientQ(IExpr a0, IExpr a1)`
`static IAST`	`OddTrigPowerQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`OneQ(IExpr... a)`
`static IAST`	`OneQ(IExpr a0)`
`static IAST`	`PerfectPowerTest(IExpr a0, IExpr a1)`
`static IAST`	`PerfectSquareQ(IExpr a0)`
`static IAST`	`PiecewiseLinearQ(IExpr a0, IExpr a1)`
`static IAST`	`PiecewiseLinearQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialDivide(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialDivide(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`PolynomialInAuxQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialInQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialInSubst(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialInSubstAux(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PolynomialTermQ(IExpr a0, IExpr a1)`
`static IAST`	`PolynomialTerms(IExpr a0, IExpr a1)`
`static IAST`	`PolyQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PosAux(IExpr a0)`
`static IAST`	`PositiveFactors(IExpr a0)`
`static IAST`	`PositiveIntegerPowerQ(IExpr a0)`
`static IAST`	`PositiveIntegerQ(IExpr... a)`
`static IAST`	`PositiveOrZeroQ(IExpr a0)`
`static IAST`	`PositiveQ(IExpr a0)`
`static IAST`	`PosQ(IExpr a0)`
`static IAST`	`PowerOfLinearMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`PowerOfLinearQ(IExpr a0, IExpr a1)`
`static IAST`	`PowerQ(IExpr a0)`
`static IAST`	`PowerVariableDegree(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`PowerVariableExpn(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PowerVariableSubst(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`ProductOfLinearPowersQ(IExpr a0, IExpr a1)`
`static IAST`	`ProductQ(IExpr a0)`
`static IAST`	`PureFunctionOfCoshQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfCosQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfCothQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfCotQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfSinhQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfSinQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfTanhQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`PureFunctionOfTanQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`QuadraticMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`QuadraticQ(IExpr a0, IExpr a1)`
`static IAST`	`QuotientOfLinearsMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`QuotientOfLinearsP(IExpr a0, IExpr a1)`
`static IAST`	`QuotientOfLinearsParts(IExpr a0, IExpr a1)`
`static IAST`	`QuotientOfLinearsQ(IExpr a0, IExpr a1)`
`static IAST`	`RationalFunctionExpand(IExpr a0, IExpr a1)`
`static IAST`	`RationalFunctionExponents(IExpr a0, IExpr a1)`
`static IAST`	`RationalFunctionFactors(IExpr a0, IExpr a1)`
`static IAST`	`RationalFunctionQ(IExpr a0, IExpr a1)`
`static IAST`	`RationalPowerQ(IExpr a0)`
`static IAST`	`RationalQ(IExpr... a)`
`static IAST`	`RealNumericQ(IExpr a0)`
`static IAST`	`RealQ(IExpr a0)`
`static IAST`	`ReapList(IExpr a0)`
`static IAST`	`RectifyCotangent(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`RectifyCotangent(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`RectifyTangent(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`RectifyTangent(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`RemainingFactors(IExpr a0)`
`static IAST`	`RemainingTerms(IExpr a0)`
`static IAST`	`RemoveContent(IExpr a0, IExpr a1)`
`static IAST`	`Rt(IExpr a0)`
`static IAST`	`Rt(IExpr a0, IExpr a1)`
`static IAST`	`RtAux(IExpr a0, IExpr a1)`
`static IAST`	`SechQ(IExpr a0)`
`static IAST`	`SecQ(IExpr a0)`
`static IAST`	`SignOfFactor(IExpr a0)`
`static IAST`	`Simp(IExpr a0, IExpr a1)`
`static IAST`	`SimpFixFactor(IExpr a0, IExpr a1)`
`static IAST`	`SimpHelp(IExpr a0, IExpr a1)`
`static IAST`	`SimplerIntegrandQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SimplerQ(IExpr a0, IExpr a1)`
`static IAST`	`SimplerSqrtQ(IExpr a0, IExpr a1)`
`static IAST`	`SimplifyAntiderivative(IExpr a0, IExpr a1)`
`static IAST`	`SimplifyAntiderivativeSum(IExpr a0, IExpr a1)`
`static IAST`	`SimplifyIntegrand(IExpr a0, IExpr a1)`
`static IAST`	`SimplifyTerm(IExpr a0, IExpr a1)`
`static IAST`	`SinCosQ(IExpr a0)`
`static IAST`	`SinhCoshQ(IExpr a0)`
`static IAST`	`SinhQ(IExpr a0)`
`static IAST`	`SinQ(IExpr a0)`
`static IAST`	`Smallest(IExpr a0)`
`static IAST`	`Smallest(IExpr a0, IExpr a1)`
`static IAST`	`SmartApart(IExpr a0, IExpr a1)`
`static IAST`	`SmartApart(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SmartDenominator(IExpr a0)`
`static IAST`	`SmartNumerator(IExpr a0)`
`static IAST`	`SmartSimplify(IExpr a0)`
`static IAST`	`SplitFreeFactors(IExpr a0, IExpr a1)`
`static IAST`	`SqrtNumberQ(IExpr a0)`
`static IAST`	`SqrtNumberSumQ(IExpr a0)`
`static IAST`	`SqrtQ(IExpr a0)`
`static IAST`	`SquareRootOfQuadraticSubst(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`Subst(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstAux(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstFor(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstFor(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`SubstForAux(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstForExpn(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstForFractionalPower(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`SubstForFractionalPowerAuxQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstForFractionalPowerOfLinear(IExpr a0, IExpr a1)`
`static IAST`	`SubstForFractionalPowerOfQuotientOfLinears(IExpr a0, IExpr a1)`
`static IAST`	`SubstForFractionalPowerQ(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstForHyperbolic(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`SubstForInverseFunction(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`SubstForInverseFunction(IExpr a0, IExpr a1, IExpr a2, IExpr a3)`
`static IAST`	`SubstForInverseFunctionOfQuotientOfLinears(IExpr a0, IExpr a1)`
`static IAST`	`SubstForTrig(IExpr a0, IExpr a1, IExpr a2, IExpr a3, IExpr a4)`
`static IAST`	`SumQ(IExpr a0)`
`static IAST`	`SumSimplerAuxQ(IExpr a0, IExpr a1)`
`static IAST`	`SumSimplerQ(IExpr a0, IExpr a1)`
`static IAST`	`TanhQ(IExpr a0)`
`static IAST`	`TanQ(IExpr a0)`
`static IAST`	`TogetherSimplify(IExpr a0)`
`static IAST`	`TrigHyperbolicFreeQ(IExpr a0, IExpr a1)`
`static IAST`	`TrigQ(IExpr a0)`
`static IAST`	`TrigSimplify(IExpr a0)`
`static IAST`	`TrigSimplifyAux(IExpr a0)`
`static IAST`	`TrigSimplifyQ(IExpr a0)`
`static IAST`	`TrigSimplifyRecur(IExpr a0)`
`static IAST`	`TrinomialDegree(IExpr a0, IExpr a1)`
`static IAST`	`TrinomialMatchQ(IExpr a0, IExpr a1)`
`static IAST`	`TrinomialQ(IExpr a0, IExpr a1)`
`static IAST`	`TrinomialTest(IExpr a0, IExpr a1)`
`static IAST`	`TryPureTanhSubst(IExpr a0, IExpr a1)`
`static IAST`	`TryPureTanSubst(IExpr a0, IExpr a1)`
`static IAST`	`TryTanhSubst(IExpr a0, IExpr a1)`
`static IAST`	`UnifyNegativeBaseFactors(IExpr a0)`
`static IAST`	`UnifySum(IExpr a0, IExpr a1)`
`static IAST`	`UnifyTerm(IExpr a0, IExpr a1, IExpr a2)`
`static IAST`	`UnifyTerms(IExpr a0, IExpr a1)`
`static IAST`	`ZeroQ(IExpr... a)`
`static IAST`	`ZeroQ(IExpr a0)`

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

Field Detail

INTEGRATE_PREFIX

public static final java.lang.String INTEGRATE_PREFIX

See Also:: Constant Field Values

INTEGRATE_TRIG_SIMPLIFY

public static ISymbol INTEGRATE_TRIG_SIMPLIFY

INTEGRATE_SMARTLEAFCOUNT

public static ISymbol INTEGRATE_SMARTLEAFCOUNT

INTEGRATE_SMARTNUMERATOR

public static ISymbol INTEGRATE_SMARTNUMERATOR

INTEGRATE_SMARTDENOMINATOR

public static ISymbol INTEGRATE_SMARTDENOMINATOR

INTEGRATE_SIMP
```
public static ISymbol INTEGRATE_SIMP
```

INTEGRATE_REAPLIST

public static ISymbol INTEGRATE_REAPLIST

A
```
public static final ISymbol A
```

B
```
public static final ISymbol B
```

C
```
public static final ISymbol C
```

F
```
public static final ISymbol F
```

G
```
public static final ISymbol G
```

H
```
public static final ISymbol H
```

J
```
public static final ISymbol J
```

K
```
public static final ISymbol K
```

L
```
public static final ISymbol L
```

M
```
public static final ISymbol M
```

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

P
```
public static final ISymbol P
```

Q
```
public static final ISymbol Q
```

R
```
public static final ISymbol R
```

S
```
public static final ISymbol S
```

T
```
public static final ISymbol T
```

U
```
public static final ISymbol U
```

V
```
public static final ISymbol V
```

W
```
public static final ISymbol W
```

X
```
public static final ISymbol X
```

Y
```
public static final ISymbol Y
```

Z
```
public static final ISymbol Z
```

AbortRubi
```
public static ISymbol AbortRubi
```

Constructor Detail
- UtilityFunctionCtors
```
public UtilityFunctionCtors()
```

Method Detail

AbortRubi

public static IAST AbortRubi(IExpr a0)

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

F

public static IAST F(IExpr a0,
                     IExpr a1)

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

G

public static IAST G(IExpr a0,
                     IExpr a1)

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

H

public static IAST H(IExpr a0,
                     IExpr a1)

H

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

Int

public static IAST Int(IExpr a0,
                       IExpr a1)

Convert to Integrate[]

Parameters:: a0 -; a1 -
Returns:

Dist

public static IAST Dist(IExpr a0,
                        IExpr a1)

Dist

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

AbsorbMinusSign

public static IAST AbsorbMinusSign(IExpr a0)

AbsurdNumberFactors

public static IAST AbsurdNumberFactors(IExpr a0)

AbsurdNumberGCD

public static IAST AbsurdNumberGCD(IExpr... a)

AbsurdNumberGCDList

public static IAST AbsurdNumberGCDList(IExpr a0,
                                       IExpr a1)

AbsurdNumberQ

public static IAST AbsurdNumberQ(IExpr a0)

ActivateTrig

public static IAST ActivateTrig(IExpr a0)

AlgebraicFunctionFactors

public static IAST AlgebraicFunctionFactors(IExpr a0,
                                            IExpr a1)

AlgebraicFunctionQ

public static IAST AlgebraicFunctionQ(IExpr a0,
                                      IExpr a1)

AlgebraicTrigFunctionQ

public static IAST AlgebraicTrigFunctionQ(IExpr a0,
                                          IExpr a1)

BinomialDegree

public static IAST BinomialDegree(IExpr a0,
                                  IExpr a1)

BinomialMatchQ

public static IAST BinomialMatchQ(IExpr a0,
                                  IExpr a1)

BinomialQ

public static IAST BinomialQ(IExpr a0,
                             IExpr a1)

BinomialQ

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

BinomialTest

public static IAST BinomialTest(IExpr a0,
                                IExpr a1)

CalculusFreeQ

public static IAST CalculusFreeQ(IExpr a0,
                                 IExpr a1)

CalculusQ

public static IAST CalculusQ(IExpr a0)

CancelCommonFactors

public static IAST CancelCommonFactors(IExpr a0,
                                       IExpr a1)

CollectReciprocals

public static IAST CollectReciprocals(IExpr a0,
                                      IExpr a1)

CombineExponents

public static IAST CombineExponents(IExpr a0)

CommonFactors

public static IAST CommonFactors(IExpr a0)

CommonNumericFactors

public static IAST CommonNumericFactors(IExpr a0)

ComplexFreeQ

public static IAST ComplexFreeQ(IExpr a0)

ConstantFactor

public static IAST ConstantFactor(IExpr a0,
                                  IExpr a1)

ContentFactor

public static IAST ContentFactor(IExpr a0)

ContentFactorAux

public static IAST ContentFactorAux(IExpr a0)

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

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

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

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

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

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

CubicMatchQ

public static IAST CubicMatchQ(IExpr a0,
                               IExpr a1)

DeactivateTrig

public static IAST DeactivateTrig(IExpr a0,
                                  IExpr a1)

DeactivateTrigAux

public static IAST DeactivateTrigAux(IExpr a0,
                                     IExpr a1)

DerivativeDivides

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

Distrib

public static IAST Distrib(IExpr a0,
                           IExpr a1)

DivideDegreesOfFactors

public static IAST DivideDegreesOfFactors(IExpr a0,
                                          IExpr a1)

Divides

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

EasyDQ

public static IAST EasyDQ(IExpr a0,
                          IExpr a1)

EulerIntegrandQ

public static IAST EulerIntegrandQ(IExpr a0,
                                   IExpr a1)

EvenQuotientQ

public static IAST EvenQuotientQ(IExpr a0,
                                 IExpr a1)

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

ExpandAlgebraicFunction

public static IAST ExpandAlgebraicFunction(IExpr a0,
                                           IExpr a1)

ExpandCleanup

public static IAST ExpandCleanup(IExpr a0,
                                 IExpr a1)

ExpandExpression

public static IAST ExpandExpression(IExpr a0,
                                    IExpr a1)

ExpandIntegrand

public static IAST ExpandIntegrand(IExpr a0,
                                   IExpr a1)

ExpandIntegrand

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

ExpandLinearProduct

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

ExpandToSum

public static IAST ExpandToSum(IExpr a0,
                               IExpr a1)

ExpandToSum

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

ExpandTrig

public static IAST ExpandTrig(IExpr a0,
                              IExpr a1)

ExpandTrig

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

ExpandTrigExpand

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

ExpandTrigReduce

public static IAST ExpandTrigReduce(IExpr a0,
                                    IExpr a1)

ExpandTrigReduce

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

ExpandTrigReduceAux

public static IAST ExpandTrigReduceAux(IExpr a0,
                                       IExpr a1)

ExpandTrigToExp

public static IAST ExpandTrigToExp(IExpr a0,
                                   IExpr a1)

ExpandTrigToExp

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

ExponentIn

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

ExponentInAux

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

FactorAbsurdNumber

public static IAST FactorAbsurdNumber(IExpr a0)

FactorNumericGcd

public static IAST FactorNumericGcd(IExpr a0)

FactorOrder

public static IAST FactorOrder(IExpr a0,
                               IExpr a1)

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

FindTrigFactor

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

FixInertTrigFunction

public static IAST FixInertTrigFunction(IExpr a0,
                                        IExpr a1)

FixIntRule

public static IAST FixIntRule(IExpr a0,
                              IExpr a1)

FixIntRules

public static IAST FixIntRules(IExpr a0)

FixRhsIntRule

public static IAST FixRhsIntRule(IExpr a0,
                                 IExpr a1)

FixSimplify

public static IAST FixSimplify(IExpr a0)

FractionOrNegativeQ

public static IAST FractionOrNegativeQ(IExpr... a)

FractionQ

public static IAST FractionQ(IExpr... a)

FractionalPowerFreeQ

public static IAST FractionalPowerFreeQ(IExpr a0)

FractionalPowerOfLinear

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

FractionalPowerOfQuotientOfLinears

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

FractionalPowerOfSquareQ

public static IAST FractionalPowerOfSquareQ(IExpr a0)

FractionalPowerQ

public static IAST FractionalPowerQ(IExpr a0)

FractionalPowerSubexpressionQ

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

FreeFactors

public static IAST FreeFactors(IExpr a0,
                               IExpr a1)

FreeTerms

public static IAST FreeTerms(IExpr a0,
                             IExpr a1)

FunctionOfCosQ

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

FunctionOfCoshQ

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

FunctionOfDensePolynomialsQ

public static IAST FunctionOfDensePolynomialsQ(IExpr a0,
                                               IExpr a1)

FunctionOfExpnQ

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

FunctionOfExponential

public static IAST FunctionOfExponential(IExpr a0,
                                         IExpr a1)

FunctionOfExponentialFunction

public static IAST FunctionOfExponentialFunction(IExpr a0,
                                                 IExpr a1)

FunctionOfExponentialFunctionAux

public static IAST FunctionOfExponentialFunctionAux(IExpr a0,
                                                    IExpr a1)

FunctionOfExponentialQ

public static IAST FunctionOfExponentialQ(IExpr a0,
                                          IExpr a1)

FunctionOfExponentialTest

public static IAST FunctionOfExponentialTest(IExpr a0,
                                             IExpr a1)

FunctionOfExponentialTestAux

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

FunctionOfHyperbolic

public static IAST FunctionOfHyperbolic(IExpr a0,
                                        IExpr a1)

FunctionOfHyperbolic

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

FunctionOfHyperbolicQ

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

FunctionOfInverseLinear

public static IAST FunctionOfInverseLinear(IExpr a0,
                                           IExpr a1)

FunctionOfInverseLinear

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

FunctionOfLinear

public static IAST FunctionOfLinear(IExpr a0,
                                    IExpr a1)

FunctionOfLinear

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

FunctionOfLinearSubst

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

FunctionOfLog

public static IAST FunctionOfLog(IExpr a0,
                                 IExpr a1)

FunctionOfLog

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

FunctionOfQ

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

FunctionOfQ

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

FunctionOfSinQ

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

FunctionOfSinhQ

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

FunctionOfSquareRootOfQuadratic

public static IAST FunctionOfSquareRootOfQuadratic(IExpr a0,
                                                   IExpr a1)

FunctionOfSquareRootOfQuadratic

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

FunctionOfTanQ

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

FunctionOfTanWeight

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

FunctionOfTanhQ

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

FunctionOfTanhWeight

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

FunctionOfTrig

public static IAST FunctionOfTrig(IExpr a0,
                                  IExpr a1)

FunctionOfTrig

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

FunctionOfTrigOfLinearQ

public static IAST FunctionOfTrigOfLinearQ(IExpr a0,
                                           IExpr a1)

FunctionOfTrigQ

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

GE

public static IAST GE(IExpr a0,
                      IExpr a1)

GE

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

GT

public static IAST GT(IExpr a0,
                      IExpr a1)

GT

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

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

Gcd

public static IAST Gcd(IExpr a0,
                       IExpr a1)

GeneralizedBinomialDegree

public static IAST GeneralizedBinomialDegree(IExpr a0,
                                             IExpr a1)

GeneralizedBinomialMatchQ

public static IAST GeneralizedBinomialMatchQ(IExpr a0,
                                             IExpr a1)

GeneralizedBinomialQ

public static IAST GeneralizedBinomialQ(IExpr a0,
                                        IExpr a1)

GeneralizedBinomialTest

public static IAST GeneralizedBinomialTest(IExpr a0,
                                           IExpr a1)

GeneralizedTrinomialDegree

public static IAST GeneralizedTrinomialDegree(IExpr a0,
                                              IExpr a1)

GeneralizedTrinomialMatchQ

public static IAST GeneralizedTrinomialMatchQ(IExpr a0,
                                              IExpr a1)

GeneralizedTrinomialQ

public static IAST GeneralizedTrinomialQ(IExpr a0,
                                         IExpr a1)

GeneralizedTrinomialTest

public static IAST GeneralizedTrinomialTest(IExpr a0,
                                            IExpr a1)

GensymSubst

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

HeldFormQ

public static IAST HeldFormQ(IExpr a0)

HyperbolicQ

public static IAST HyperbolicQ(IExpr a0)

ImaginaryNumericQ

public static IAST ImaginaryNumericQ(IExpr a0)

ImaginaryQ

public static IAST ImaginaryQ(IExpr a0)

IndependentQ

public static IAST IndependentQ(IExpr a0,
                                IExpr a1)

InertReciprocalQ

public static IAST InertReciprocalQ(IExpr a0,
                                    IExpr a1)

InertTrigFreeQ

public static IAST InertTrigFreeQ(IExpr a0)

InertTrigQ

public static IAST InertTrigQ(IExpr a0)

InertTrigQ

public static IAST InertTrigQ(IExpr a0,
                              IExpr a1)

InertTrigQ

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

InertTrigSumQ

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

IntSum

public static IAST IntSum(IExpr a0,
                          IExpr a1)

IntTerm

public static IAST IntTerm(IExpr a0,
                           IExpr a1)

IntegerPowerQ

public static IAST IntegerPowerQ(IExpr a0)

IntegerQuotientQ

public static IAST IntegerQuotientQ(IExpr a0,
                                    IExpr a1)

IntegersQ

public static IAST IntegersQ(IExpr... a)

InverseFunctionFreeQ

public static IAST InverseFunctionFreeQ(IExpr a0,
                                        IExpr a1)

InverseFunctionOfLinear

public static IAST InverseFunctionOfLinear(IExpr a0,
                                           IExpr a1)

InverseFunctionOfQuotientOfLinears

public static IAST InverseFunctionOfQuotientOfLinears(IExpr a0,
                                                      IExpr a1)

InverseFunctionQ

public static IAST InverseFunctionQ(IExpr a0)

InverseHyperbolicQ

public static IAST InverseHyperbolicQ(IExpr a0)

InverseTrigQ

public static IAST InverseTrigQ(IExpr a0)

KernelSubst

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

KnownCotangentIntegrandQ

public static IAST KnownCotangentIntegrandQ(IExpr a0,
                                            IExpr a1)

KnownSecantIntegrandQ

public static IAST KnownSecantIntegrandQ(IExpr a0,
                                         IExpr a1)

KnownSineIntegrandQ

public static IAST KnownSineIntegrandQ(IExpr a0,
                                       IExpr a1)

KnownTangentIntegrandQ

public static IAST KnownTangentIntegrandQ(IExpr a0,
                                          IExpr a1)

KnownTrigIntegrandQ

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

LE

public static IAST LE(IExpr a0,
                      IExpr a1)

LE

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

LT

public static IAST LT(IExpr a0,
                      IExpr a1)

LT

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

LeadBase

public static IAST LeadBase(IExpr a0)

LeadDegree

public static IAST LeadDegree(IExpr a0)

LeadFactor

public static IAST LeadFactor(IExpr a0)

LeadTerm

public static IAST LeadTerm(IExpr a0)

LinearMatchQ

public static IAST LinearMatchQ(IExpr a0,
                                IExpr a1)

LinearPairQ

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

LinearQ

public static IAST LinearQ(IExpr a0,
                           IExpr a1)

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

MakeAssocList

public static IAST MakeAssocList(IExpr a0,
                                 IExpr a1)

MakeAssocList

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

Map2

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

MapAnd

public static IAST MapAnd(IExpr a0,
                          IExpr a1)

MapAnd

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

MapOr

public static IAST MapOr(IExpr a0,
                         IExpr a1)

MergeFactor

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

MergeFactors

public static IAST MergeFactors(IExpr a0,
                                IExpr a1)

MergeMonomials

public static IAST MergeMonomials(IExpr a0,
                                  IExpr a1)

MergeableFactorQ

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

MinimumDegree

public static IAST MinimumDegree(IExpr a0,
                                 IExpr a1)

MinimumMonomialExponent

public static IAST MinimumMonomialExponent(IExpr a0,
                                           IExpr a1)

MonomialExponent

public static IAST MonomialExponent(IExpr a0,
                                    IExpr a1)

MonomialFactor

public static IAST MonomialFactor(IExpr a0,
                                  IExpr a1)

MonomialQ

public static IAST MonomialQ(IExpr a0,
                             IExpr a1)

MonomialSumQ

public static IAST MonomialSumQ(IExpr a0,
                                IExpr a1)

MostMainFactorPosition

public static IAST MostMainFactorPosition(IExpr a0)

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

NegativeCoefficientQ

public static IAST NegativeCoefficientQ(IExpr a0)

NegativeIntegerQ

public static IAST NegativeIntegerQ(IExpr... a)

NegativeOrZeroQ

public static IAST NegativeOrZeroQ(IExpr a0)

NegativeQ

public static IAST NegativeQ(IExpr a0)

NiceSqrtAuxQ

public static IAST NiceSqrtAuxQ(IExpr a0)

NiceSqrtQ

public static IAST NiceSqrtQ(IExpr a0)

NonabsurdNumberFactors

public static IAST NonabsurdNumberFactors(IExpr a0)

NonalgebraicFunctionFactors

public static IAST NonalgebraicFunctionFactors(IExpr a0,
                                               IExpr a1)

NonfreeFactors

public static IAST NonfreeFactors(IExpr a0,
                                  IExpr a1)

NonfreeTerms

public static IAST NonfreeTerms(IExpr a0,
                                IExpr a1)

NonnumericFactors

public static IAST NonnumericFactors(IExpr a0)

NonpolynomialTerms

public static IAST NonpolynomialTerms(IExpr a0,
                                      IExpr a1)

NonpositiveFactors

public static IAST NonpositiveFactors(IExpr a0)

NonrationalFunctionFactors

public static IAST NonrationalFunctionFactors(IExpr a0,
                                              IExpr a1)

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

NonzeroQ

public static IAST NonzeroQ(IExpr a0)

NormalizeIntegrand

public static IAST NormalizeIntegrand(IExpr a0,
                                      IExpr a1)

NormalizeIntegrandAux

public static IAST NormalizeIntegrandAux(IExpr a0,
                                         IExpr a1)

NormalizeIntegrandFactor

public static IAST NormalizeIntegrandFactor(IExpr a0,
                                            IExpr a1)

NormalizeIntegrandFactorBase

public static IAST NormalizeIntegrandFactorBase(IExpr a0,
                                                IExpr a1)

NormalizeLeadTermSigns

public static IAST NormalizeLeadTermSigns(IExpr a0)

NormalizePowerOfLinear

public static IAST NormalizePowerOfLinear(IExpr a0,
                                          IExpr a1)

NormalizeSumFactors

public static IAST NormalizeSumFactors(IExpr a0)

NormalizeTogether

public static IAST NormalizeTogether(IExpr a0)

NormalizeTrig

public static IAST NormalizeTrig(IExpr a0,
                                 IExpr a1)

NotFalseQ

public static IAST NotFalseQ(IExpr a0)

NotIntegrableQ

public static IAST NotIntegrableQ(IExpr a0,
                                  IExpr a1)

NumericFactor

public static IAST NumericFactor(IExpr a0)

OddHyperbolicPowerQ

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

OddQuotientQ

public static IAST OddQuotientQ(IExpr a0,
                                IExpr a1)

OddTrigPowerQ

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

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

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

PerfectPowerTest

public static IAST PerfectPowerTest(IExpr a0,
                                    IExpr a1)

PerfectSquareQ

public static IAST PerfectSquareQ(IExpr a0)

PiecewiseLinearQ

public static IAST PiecewiseLinearQ(IExpr a0,
                                    IExpr a1)

PiecewiseLinearQ

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

PolyQ

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

PolynomialDivide

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

PolynomialDivide

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

PolynomialInAuxQ

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

PolynomialInQ

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

PolynomialInSubst

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

PolynomialInSubstAux

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

PolynomialTermQ

public static IAST PolynomialTermQ(IExpr a0,
                                   IExpr a1)

PolynomialTerms

public static IAST PolynomialTerms(IExpr a0,
                                   IExpr a1)

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

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

PositiveFactors

public static IAST PositiveFactors(IExpr a0)

PositiveIntegerPowerQ

public static IAST PositiveIntegerPowerQ(IExpr a0)

PositiveIntegerQ

public static IAST PositiveIntegerQ(IExpr... a)

PositiveOrZeroQ

public static IAST PositiveOrZeroQ(IExpr a0)

PositiveQ

public static IAST PositiveQ(IExpr a0)

PowerOfLinearMatchQ

public static IAST PowerOfLinearMatchQ(IExpr a0,
                                       IExpr a1)

PowerOfLinearQ

public static IAST PowerOfLinearQ(IExpr a0,
                                  IExpr a1)

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

PowerVariableDegree

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

PowerVariableExpn

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

PowerVariableSubst

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

ProductOfLinearPowersQ

public static IAST ProductOfLinearPowersQ(IExpr a0,
                                          IExpr a1)

ProductQ

public static IAST ProductQ(IExpr a0)

PureFunctionOfCosQ

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

PureFunctionOfCoshQ

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

PureFunctionOfCotQ

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

PureFunctionOfCothQ

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

PureFunctionOfSinQ

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

PureFunctionOfSinhQ

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

PureFunctionOfTanQ

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

PureFunctionOfTanhQ

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

QuadraticMatchQ

public static IAST QuadraticMatchQ(IExpr a0,
                                   IExpr a1)

QuadraticQ

public static IAST QuadraticQ(IExpr a0,
                              IExpr a1)

QuotientOfLinearsMatchQ

public static IAST QuotientOfLinearsMatchQ(IExpr a0,
                                           IExpr a1)

QuotientOfLinearsP

public static IAST QuotientOfLinearsP(IExpr a0,
                                      IExpr a1)

QuotientOfLinearsParts

public static IAST QuotientOfLinearsParts(IExpr a0,
                                          IExpr a1)

QuotientOfLinearsQ

public static IAST QuotientOfLinearsQ(IExpr a0,
                                      IExpr a1)

RationalFunctionExpand

public static IAST RationalFunctionExpand(IExpr a0,
                                          IExpr a1)

RationalFunctionExponents

public static IAST RationalFunctionExponents(IExpr a0,
                                             IExpr a1)

RationalFunctionFactors

public static IAST RationalFunctionFactors(IExpr a0,
                                           IExpr a1)

RationalFunctionQ

public static IAST RationalFunctionQ(IExpr a0,
                                     IExpr a1)

RationalPowerQ

public static IAST RationalPowerQ(IExpr a0)

RationalQ

public static IAST RationalQ(IExpr... a)

RealNumericQ

public static IAST RealNumericQ(IExpr a0)

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

ReapList

public static IAST ReapList(IExpr a0)

RectifyCotangent

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

RectifyCotangent

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

RectifyTangent

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

RectifyTangent

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

RemainingFactors

public static IAST RemainingFactors(IExpr a0)

RemainingTerms

public static IAST RemainingTerms(IExpr a0)

RemoveContent

public static IAST RemoveContent(IExpr a0,
                                 IExpr a1)

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

Rt

public static IAST Rt(IExpr a0,
                      IExpr a1)

RtAux

public static IAST RtAux(IExpr a0,
                         IExpr a1)

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

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

SignOfFactor

public static IAST SignOfFactor(IExpr a0)

Simp

public static IAST Simp(IExpr a0,
                        IExpr a1)

SimpFixFactor

public static IAST SimpFixFactor(IExpr a0,
                                 IExpr a1)

SimpHelp

public static IAST SimpHelp(IExpr a0,
                            IExpr a1)

SimplerIntegrandQ

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

SimplerQ

public static IAST SimplerQ(IExpr a0,
                            IExpr a1)

SimplerSqrtQ

public static IAST SimplerSqrtQ(IExpr a0,
                                IExpr a1)

SimplifyAntiderivative

public static IAST SimplifyAntiderivative(IExpr a0,
                                          IExpr a1)

SimplifyAntiderivativeSum

public static IAST SimplifyAntiderivativeSum(IExpr a0,
                                             IExpr a1)

SimplifyIntegrand

public static IAST SimplifyIntegrand(IExpr a0,
                                     IExpr a1)

SimplifyTerm

public static IAST SimplifyTerm(IExpr a0,
                                IExpr a1)

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

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

SinhCoshQ

public static IAST SinhCoshQ(IExpr a0)

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

Smallest

public static IAST Smallest(IExpr a0)

Smallest

public static IAST Smallest(IExpr a0,
                            IExpr a1)

SmartApart

public static IAST SmartApart(IExpr a0,
                              IExpr a1)

SmartApart

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

SmartDenominator

public static IAST SmartDenominator(IExpr a0)

SmartNumerator

public static IAST SmartNumerator(IExpr a0)

SmartSimplify

public static IAST SmartSimplify(IExpr a0)

SplitFreeFactors

public static IAST SplitFreeFactors(IExpr a0,
                                    IExpr a1)

SqrtNumberQ

public static IAST SqrtNumberQ(IExpr a0)

SqrtNumberSumQ

public static IAST SqrtNumberSumQ(IExpr a0)

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

SquareRootOfQuadraticSubst

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

Subst

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

SubstAux

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

SubstFor

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

SubstFor

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

SubstForAux

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

SubstForExpn

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

SubstForFractionalPower

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

SubstForFractionalPowerAuxQ

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

SubstForFractionalPowerOfLinear

public static IAST SubstForFractionalPowerOfLinear(IExpr a0,
                                                   IExpr a1)

SubstForFractionalPowerOfQuotientOfLinears

public static IAST SubstForFractionalPowerOfQuotientOfLinears(IExpr a0,
                                                              IExpr a1)

SubstForFractionalPowerQ

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

SubstForHyperbolic

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

SubstForInverseFunction

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

SubstForInverseFunction

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

SubstForInverseFunctionOfQuotientOfLinears

public static IAST SubstForInverseFunctionOfQuotientOfLinears(IExpr a0,
                                                              IExpr a1)

SubstForTrig

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

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

SumSimplerAuxQ

public static IAST SumSimplerAuxQ(IExpr a0,
                                  IExpr a1)

SumSimplerQ

public static IAST SumSimplerQ(IExpr a0,
                               IExpr a1)

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

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

TogetherSimplify

public static IAST TogetherSimplify(IExpr a0)

TrigHyperbolicFreeQ

public static IAST TrigHyperbolicFreeQ(IExpr a0,
                                       IExpr a1)

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

TrigSimplify

public static IAST TrigSimplify(IExpr a0)

TrigSimplifyAux

public static IAST TrigSimplifyAux(IExpr a0)

TrigSimplifyQ

public static IAST TrigSimplifyQ(IExpr a0)

TrigSimplifyRecur

public static IAST TrigSimplifyRecur(IExpr a0)

TrinomialDegree

public static IAST TrinomialDegree(IExpr a0,
                                   IExpr a1)

TrinomialMatchQ

public static IAST TrinomialMatchQ(IExpr a0,
                                   IExpr a1)

TrinomialQ

public static IAST TrinomialQ(IExpr a0,
                              IExpr a1)

TrinomialTest

public static IAST TrinomialTest(IExpr a0,
                                 IExpr a1)

TryPureTanSubst

public static IAST TryPureTanSubst(IExpr a0,
                                   IExpr a1)

TryPureTanhSubst

public static IAST TryPureTanhSubst(IExpr a0,
                                    IExpr a1)

TryTanhSubst

public static IAST TryTanhSubst(IExpr a0,
                                IExpr a1)

UnifyNegativeBaseFactors

public static IAST UnifyNegativeBaseFactors(IExpr a0)

UnifySum

public static IAST UnifySum(IExpr a0,
                            IExpr a1)

UnifyTerm

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

UnifyTerms

public static IAST UnifyTerms(IExpr a0,
                              IExpr a1)

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

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

Class UtilityFunctionCtors

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INTEGRATE_PREFIX

INTEGRATE_TRIG_SIMPLIFY

INTEGRATE_SMARTLEAFCOUNT

INTEGRATE_SMARTNUMERATOR

INTEGRATE_SMARTDENOMINATOR

INTEGRATE_SIMP

INTEGRATE_REAPLIST

A

B

C

F

G

H

J

K

L

M

O

P

Q

R

S

T

U

V

W

X

Y

Z

AbortRubi

Constructor Detail

UtilityFunctionCtors

Method Detail

AbortRubi

F

F

G

G

H

H

H

Int

Dist

Dist

AbsorbMinusSign

AbsurdNumberFactors

AbsurdNumberGCD

AbsurdNumberGCDList

AbsurdNumberQ

ActivateTrig

AlgebraicFunctionFactors

AlgebraicFunctionQ

AlgebraicTrigFunctionQ

BinomialDegree

BinomialMatchQ

BinomialQ

BinomialQ

BinomialTest

CalculusFreeQ

CalculusQ

CancelCommonFactors

CollectReciprocals

CombineExponents

CommonFactors

CommonNumericFactors

ComplexFreeQ

ConstantFactor

ContentFactor

ContentFactorAux

CosQ

CoshQ

CotQ

CothQ

CscQ