JuliaWSExpression

jwsexpr.spad line 1 [edit on github]

Julia Wolfram Symbolic expressions using Wolfram Symbolic Transport Protocol.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

#: % -> JuliaWSInteger

from JuliaWSAggregate %

*: (%, %) -> %

from Magma

*: (%, Fraction Integer) -> %

from RightModule Fraction Integer

*: (Fraction Integer, %) -> %

from LeftModule Fraction Integer

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Group

/: (SparseMultivariatePolynomial(%, Kernel %), SparseMultivariatePolynomial(%, Kernel %)) -> %

from FunctionSpace2(%, Kernel %)

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

^: (%, %) -> %

from ElementaryFunctionCategory

^: (%, Fraction Integer) -> %

from RadicalCategory

^: (%, Integer) -> %

from Group

^: (%, JuliaWSRational) -> %

^ is the exponentiation by a rational.

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs: % -> %

from ComplexCategory %

acos: % -> %

from ArcTrigonometricFunctionCategory

acosh: % -> %

from ArcHyperbolicFunctionCategory

acot: % -> %

from ArcTrigonometricFunctionCategory

acoth: % -> %

from ArcHyperbolicFunctionCategory

acsc: % -> %

from ArcTrigonometricFunctionCategory

acsch: % -> %

from ArcHyperbolicFunctionCategory

airyAi: % -> %

from SpecialFunctionCategory

airyAiPrime: % -> %

from SpecialFunctionCategory

airyBi: % -> %

from SpecialFunctionCategory

airyBiPrime: % -> %

from SpecialFunctionCategory

algtower: % -> List Kernel %

from FunctionSpace2(%, Kernel %)

algtower: List % -> List Kernel %

from FunctionSpace2(%, Kernel %)

angerJ: (%, %) -> %

from SpecialFunctionCategory

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

apart: % -> %

apart(expr) converts a rational expression as a sum of terms, reducing denominator(s).

apart: (%, %) -> %

apart(expr, vars) converts a rational expression as a sum of terms as one arg apart do but only for vars (the others are considered as constants).

append: (%, %) -> %

from JuliaWSAggregate %

applyQuote: (Symbol, %) -> %

from FunctionSpace2(%, Kernel %)

applyQuote: (Symbol, %, %) -> %

from FunctionSpace2(%, Kernel %)

applyQuote: (Symbol, %, %, %) -> %

from FunctionSpace2(%, Kernel %)

applyQuote: (Symbol, %, %, %, %) -> %

from FunctionSpace2(%, Kernel %)

applyQuote: (Symbol, List %) -> %

from FunctionSpace2(%, Kernel %)

argument: % -> %

from ComplexCategory %

asec: % -> %

from ArcTrigonometricFunctionCategory

asech: % -> %

from ArcHyperbolicFunctionCategory

asin: % -> %

from ArcTrigonometricFunctionCategory

asinh: % -> %

from ArcHyperbolicFunctionCategory

associates?: (%, %) -> Boolean

from EntireRing

associator: (%, %, %) -> %

from NonAssociativeRng

atan: % -> %

from ArcTrigonometricFunctionCategory

atan: (%, %) -> %

atan(x,y) computes the arc tangent of y/x.

atanh: % -> %

from ArcHyperbolicFunctionCategory

barnesG: % -> %

barnesG(z) computes the Barnes G-function of z.

basis: () -> Vector %

from FramedModule %

belong?: BasicOperator -> Boolean

from ExpressionSpace2 Kernel %

besselI: (%, %) -> %

from SpecialFunctionCategory

besselJ: (%, %) -> %

from SpecialFunctionCategory

besselK: (%, %) -> %

from SpecialFunctionCategory

besselY: (%, %) -> %

from SpecialFunctionCategory

Beta: (%, %) -> %

from SpecialFunctionCategory

Beta: (%, %, %) -> %

from SpecialFunctionCategory

BetaRegularized: (%, %, %) -> %

BetaRegularized(x,a,b) computes the regularized incomplete beta function.

binomial: (%, %) -> %

from CombinatorialFunctionCategory

box: % -> %

from ExpressionSpace2 Kernel %

cancel: % -> %

cancel(expr) cancels common factors in numerators and denominators of the rational expression expr.

cancel: (%, %) -> %

cancel(expr, opt) cancels common factors in numerators and denominators of the rational expression expr with options opt, for example an Extension rule.

catalan: () -> %

catalan() returns Catalan's contant.

ceiling: % -> %

ceiling(x) returns the smallest integer greater than or equal to x.

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

characteristicPolynomial: % -> SparseUnivariatePolynomial %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

charlierC: (%, %, %) -> %

from SpecialFunctionCategory

chebyshevT: (%, %) -> %

chebyshevT(n, expr) returns the chebyshev polynomial of the first kind or evaluates it at x if x is a number.

chebyshevU: (%, %) -> %

chebyshevU(n, expr) returns chebyshev polynomial of the second kind or evaluates it at x if x is a number.

Chi: % -> %

from LiouvillianFunctionCategory

Ci: % -> %

from LiouvillianFunctionCategory

coefficient: (%, %) -> %

coefficient(p,expr) returns the coefficient of expr in p. example{x:= jWSExpr x} example{coefficient((x - y)^4, x * y^3)}

coefficient: (%, %, %) -> %

coefficient(p, expr, n) returns the coefficient of expr^n in p.

coefficientList: (%, %) -> %

coefficientList(p,expr) returns the list of coefficients of expr in p.

coefficientRules: % -> %

coefficientRules(p) returns the coefficients and exponents of p as WS rules.

coefficientRules: (%, %) -> %

coefficientRules(p,vars) returns the coefficients and exponents of p with respect to var(s) as WS rules.

coerce: % -> %

from CoercibleFrom %

coerce: % -> JuliaWSExpression

from JuliaWSAggregate %

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Complex Integer -> %

coerce(gi) coerce gi to a JuliaWSExpression. Convenience function.

coerce: Float -> %

coerce(f) coerces the floating point number f to a JuliaWSExpression. Convenience function.

coerce: Fraction % -> %

from FunctionSpace2(%, Kernel %)

coerce: Fraction Integer -> %

coerce(q) coerces the rational q to a JuliaWSExpression. Convenience function.

coerce: Fraction Polynomial % -> %

from CoercibleFrom Fraction Polynomial %

coerce: Fraction Polynomial Fraction % -> %

from FunctionSpace2(%, Kernel %)

coerce: Integer -> %

coerce(z) coerces the integer z to a JuliaWSExpression. Convenience function.

coerce: Kernel % -> %

from CoercibleFrom Kernel %

coerce: List % -> %

coerce(list) coerces list of JuliaWSExpression.

coerce: Polynomial % -> %

from CoercibleFrom Polynomial %

coerce: Polynomial Fraction % -> %

from FunctionSpace2(%, Kernel %)

coerce: SparseMultivariatePolynomial(%, Kernel %) -> %

from FunctionSpace2(%, Kernel %)

coerce: String -> %

coerce(str) coerces the string str to a JuliaWSExpression evaluating str as a Wolfram Symbolic Language Expression. For example: example{expr := “Sqrt[x]”::JWSEXPR;jlEval(expr,”x=2.0”)}

coerce: Symbol -> %

coerce(sym) coerces sym to a JuliaWSExpression.

collect: (%, %) -> %

collect(expr, var) collects same power terms with respect to variable var.

collect: (%, JuliaWSList %) -> %

collect(expr, vars) collects same power terms with respect to variables in vars.

commutator: (%, %) -> %

from NonAssociativeRng

complex: (%, %) -> %

from ComplexCategory %

complexExpand: % -> %

complexExpand(expr) expands expr assuming variables are real.

complexExpand: (%, %) -> %

complexExpand(expr, cvars) expands expr assuming all but cvars variables are real.

conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and % has PolynomialFactorizationExplicit or % has FiniteFieldCategory

from PolynomialFactorizationExplicit

conjugate: % -> %

from ComplexCategory %

convert: % -> SparseUnivariatePolynomial %

from ConvertibleTo SparseUnivariatePolynomial %

convert: % -> String

from ConvertibleTo String

convert: % -> Vector %

from FramedModule %

convert: Factored % -> %

from FunctionSpace2(%, Kernel %)

convert: SparseUnivariatePolynomial % -> %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

convert: Vector % -> %

from FramedModule %

coordinates: % -> Vector %

from FramedModule %

coordinates: (%, Vector %) -> Vector %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

coordinates: (Vector %, Vector %) -> Matrix %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

coordinates: Vector % -> Matrix %

from FramedModule %

cos: % -> %

from TrigonometricFunctionCategory

cosh: % -> %

from HyperbolicFunctionCategory

cot: % -> %

from TrigonometricFunctionCategory

coth: % -> %

from HyperbolicFunctionCategory

coulombF: (%, %, %) -> %

coulombF(l,eta,ro) is the regular Coulomb wave function.

coulombG: (%, %, %) -> %

coulombG(l,eta,ro) is the irregular Coulomb wave function.

coulombH1: (%, %, %) -> %

coulombH1(l,eta,ro) is the incoming irregular Coulomb wave function H^(+).

coulombH2: (%, %, %) -> %

coulombH2(l,eta,ro) is the incoming irregular Coulomb wave function H^(-).

csc: % -> %

from TrigonometricFunctionCategory

csch: % -> %

from HyperbolicFunctionCategory

D: (%, % -> %) -> %

from DifferentialExtension %

D: (%, % -> %, NonNegativeInteger) -> %

from DifferentialExtension %

D: (%, %) -> %

from PartialDifferentialRing %

D: (%, %, NonNegativeInteger) -> %

from PartialDifferentialRing %

D: (%, List %) -> %

from PartialDifferentialRing %

D: (%, List %, List NonNegativeInteger) -> %

from PartialDifferentialRing %

D: (%, List Symbol) -> %

from PartialDifferentialRing Symbol

D: (%, List Symbol, List NonNegativeInteger) -> %

from PartialDifferentialRing Symbol

D: (%, Symbol) -> %

from PartialDifferentialRing Symbol

D: (%, Symbol, NonNegativeInteger) -> %

from PartialDifferentialRing Symbol

dawson: % -> %

dawson(x) computes the Dawson integral of x.

decompose: (%, %) -> JuliaWSList %

decompose(poly, x) is a polynomial decomposition function, here, related to x.

dedekindEta: % -> %

dedekindEta(tau) computes the Dedekind modular elliptic eta.

definingPolynomial: % -> %

from ExpressionSpace2 Kernel %

definingPolynomial: () -> SparseUnivariatePolynomial %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

degree: () -> %

degree() returns conversion factor from degrees to radians, π/180.

delete: (%, JuliaWSList JuliaWSInteger) -> %

from JuliaWSAggregate %

denom: % -> SparseMultivariatePolynomial(%, Kernel %)

from FunctionSpace2(%, Kernel %)

denominator: % -> %

denominator(expr) returns the denominator of expr.

derivationCoordinates: (Vector %, % -> %) -> Matrix %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

derivative: (BasicOperator, %) -> %

derivative(func,n) returns the derivative of order n of func. example{fprime:=derivative(operator(‘f),1)}

derivative: (BasicOperator, %, %) -> %

derivative(func, n, var) returns the derivative of order n of func applied to var. example{x := jWSExpr x} example{fprimex:=derivative(operator(‘f),1,x)}

differentiate: (%, % -> %) -> %

from DifferentialExtension %

differentiate: (%, % -> %, NonNegativeInteger) -> %

from DifferentialExtension %

differentiate: (%, %) -> %

from PartialDifferentialRing %

differentiate: (%, %, NonNegativeInteger) -> %

from PartialDifferentialRing %

differentiate: (%, List %) -> %

from PartialDifferentialRing %

differentiate: (%, List %, List NonNegativeInteger) -> %

from PartialDifferentialRing %

differentiate: (%, List Symbol) -> %

from PartialDifferentialRing Symbol

differentiate: (%, List Symbol, List NonNegativeInteger) -> %

from PartialDifferentialRing Symbol

differentiate: (%, Symbol) -> %

from PartialDifferentialRing Symbol

differentiate: (%, Symbol, NonNegativeInteger) -> %

from PartialDifferentialRing Symbol

digamma: % -> %

from SpecialFunctionCategory

digamma: (%, %) -> %

digamma(n,z) the n-th derivative of the digamma function

dilog: % -> %

from LiouvillianFunctionCategory

dimensions: % -> JuliaWSList JuliaWSInteger

from JuliaWSAggregate %

diracDelta: % -> %

from SpecialFunctionCategory

dirichletEta: % -> %

dirichletEta(z) computes the Dirichlet eta.

dirichletL: (%, %, %) -> %

dirichletL(k,j,s) returns Dirichlet L-function of s, modulus k, index j.

discriminant: (%, %) -> %

discriminant(p, x) returns the discriminant of p with respect to x.

discriminant: () -> %

from FramedAlgebra(%, SparseUnivariatePolynomial %)

discriminant: Vector % -> %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

distribute: % -> %

distribute(expr) distributes expr over addition. For illustration: example{distribute(jWSExpr “(x + y) * (a + b + c)”)}

distribute: (%, %) -> %

distribute(f,g) distributes f over g.

divide: (%, %) -> Record(quotient: %, remainder: %)

from EuclideanDomain

dSolve: (%, %, %) -> %

dSolve(expr, funcs, vars) solves the (list of) differential equation(s) expr for the function(s) funcs with independant variable(s) vars. example{x:=jWSExpr x;} example{fx:=derivative(operator(‘f),0,x)} example{fprimex:=derivative(operator(‘f),1,x)} example{dSolve(jWSEqual(fprimex + fx , a *sin(x)),fx,x)}

dSolve: (Equation %, %, %) -> %

dSolve(eq, func,var) solves the differential equation eq for the function(s) funcs with independant variable(s) vars. example{x:=jWSExpr x;} example{fx:=derivative(operator(‘f),0,x)} example{fprimex:=derivative(operator(‘f),1,x)} example{dSolve(fprimex + fx = a * sin(x)/cos(x),fx,x)}

dSolveValue: (%, %, %) -> %

dSolveValue(expr,funcs, vars)returns the value determined by the differential equation(s) in expr for the function(s) funcs with independant variable(s) vars. example{x:=jWSExpr x;} example{f:=derivative(operator(‘f),0)} example{f0:=derivative(operator(‘f),0,0)} example{fx:=derivative(operator(‘f),0,x)} example{fprimex:=derivative(operator(‘f),1,x)} example{dSolveValue(jWSExpr([jWSEqual(fprimex + fx , a *sin(x)/cos(x)), jWSEqual(f0,0)]),f,x)}

dSolveValue: (Equation %, %, %) -> %

dSolveValue(eq, func,var) returns the value determined by the differential equation eq for the function func with independant variable var.

Ei: % -> %

from LiouvillianFunctionCategory

EiEn: (%, %) -> %

EiEn(n,z) returns the exponential integral En(z).

ellipticE: % -> %

ellipticE(x) computes the complete elliptic integral of the second kind.

ellipticE: (%, %) -> %

ellipticE(phi,m) computes the elliptic integral of the second kind.

ellipticF: (%, %) -> %

ellipticF(phi,m) computes the elliptic integral of the first kind.

ellipticK: % -> %

ellipticK(m) computes the complete elliptic integral of the first kind.

ellipticPi: (%, %) -> %

ellipticPi(n,m) computes the complete elliptic integral of the third kind.

ellipticPi: (%, %, %) -> %

ellipticPi(n,phi,m) computes the elliptic integral of the third kind.

ellipticTheta: (%, %, %) -> %

ellipticTheta(a, u, q) computes the theta function, a ranges from 1 to 4.

ellipticThetaPrime: (%, %, %) -> %

ellipticThetaPrime(a, u, q) computes the derivative of the theta function, a ranges from 1 to 4.

elt: (%, Integer) -> %

from JuliaWSAggregate %

elt: (BasicOperator, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, List %) -> %

from ExpressionSpace2 Kernel %

erf: % -> %

from LiouvillianFunctionCategory

erf: (%, %) -> %

erf(x,x1) computes the generalized error function.

erfc: % -> %

erfc(x) computes the complementary error function.

erfi: % -> %

from LiouvillianFunctionCategory

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

eulerE: % -> %

eulerE(n) returns the Euler number En.

eulerE: (%, %) -> %

eulerE(n,z) return the Euler E polynomial of degree n.

eulerGamma: () -> %

eulerGamma() returns the Euler's constant gamma (γ).

eulerPhi: % -> %

eulerPhi(n) is the totient function i.e. the number of integers that are relatively prime to n in the range [1,n].

eval: (%, %, %) -> %

from InnerEvalable(%, %)

eval: (%, BasicOperator, % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, BasicOperator, List % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, Equation %) -> %

from Evalable %

eval: (%, Kernel %, %) -> %

from InnerEvalable(Kernel %, %)

eval: (%, List %, List %) -> %

from InnerEvalable(%, %)

eval: (%, List BasicOperator, List(% -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, List BasicOperator, List(List % -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, List Equation %) -> %

from Evalable %

eval: (%, List Kernel %, List %) -> %

from InnerEvalable(Kernel %, %)

eval: (%, List Symbol, List NonNegativeInteger, List(% -> %)) -> %

from FunctionSpace2(%, Kernel %)

eval: (%, List Symbol, List NonNegativeInteger, List(List % -> %)) -> %

from FunctionSpace2(%, Kernel %)

eval: (%, List Symbol, List(% -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, List Symbol, List(List % -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, Symbol, % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, Symbol, List % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, Symbol, NonNegativeInteger, % -> %) -> %

from FunctionSpace2(%, Kernel %)

eval: (%, Symbol, NonNegativeInteger, List % -> %) -> %

from FunctionSpace2(%, Kernel %)

exp: % -> %

from ElementaryFunctionCategory

exp: () -> %

exp() returns ℯ (%e or exp(1)).

expand: % -> %

expand(expr) puts out products and positive powers of integers of the expression expr.

expand: (%, %) -> %

expand(expr, opt) this the expand version with excluded pattern-s or any other options avaiable (for example “Modulus->p").

expandDenominator: % -> %

expandDenominator(expr) expands denominators of rational expression expr.

expandNumerator: % -> %

expandNumerator(expr) expands numerators of rational expression expr.

exponent: (%, %) -> %

exponent(p,expr) returns the maximaum exponent of p for expr. example{x:= jWSExpr x;y := jWSExpr y} example{p:=(x^2-2)^3*(y*x^3+x^11*y^7)*(y^5+x*y^2+x^11+y)} example{exponent(%,(x^2-2))}

exponent: (%, %, %) -> %

exponent(p, expr, map) applies map to the exponents related to expr and returns it. By default map = “Max”. example{x:= jWSExpr x;y := jWSExpr y} example{p:=expand((x^2-2)^3*(y*x^3+x^11*y^7)*(y^5+x*y^2+x^11+y))} example{exponent(p,x,”Min”)}

expressIdealMember: (List %, %) -> Union(List %, failed)

from PrincipalIdealDomain

expToTrig: % -> %

expToTrig(expr) returns expr with exponentials converted to (hyperbolic) trigonometric functions.

exquo: (%, %) -> Union(%, failed)

from EntireRing

extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)

from EuclideanDomain

extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)

from EuclideanDomain

extendedExpand: % -> %

extendedExpand(expr) puts out all products and positive powers of integers.

extendedSimplify: % -> %

extendedSimplify(expr) extended version of simplify. This is the full version of simplify.

extendedSimplify: (%, %) -> %

extendedSimplify(expr, assumptions) extended version of simplify with respect to assumptions or ExcludedForms. This is the full version.

extract: (%, JuliaWSExpression) -> %

from JuliaWSAggregate %

extract: (%, NonNegativeInteger) -> %

extract(expr,i) returns the i-th element of expr seen as a list.

factor: % -> %

factor(expr) factors the expression or polynomial expr.

factor: % -> Factored %

from UniqueFactorizationDomain

factor: (%, %) -> %

factor(expr, opt) factors the expression or polynomial expr. For example: example{x := jWSExpr x;} example{factor(1 + x^2, “GaussianIntegers -> True”)}

factorial: % -> %

from CombinatorialFunctionCategory

factorials: % -> %

from CombinatorialOpsCategory

factorials: (%, Symbol) -> %

from CombinatorialOpsCategory

factorList: % -> JuliaWSList JuliaWSList %

factorList(expr) factor the expression or polynomial expr, but returns result as a list of pair (factor, exponent).

factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if % has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

factorSquareFree: % -> %

factorSquareFree(expr) factors the expression or polynomial expr in square free factors.

factorSquareFreeList: % -> JuliaWSList JuliaWSList %

factorSquareFreeList(expr) factors the expression or polynomial expr in square free factors but returns result as a list of pair (factor, exponent).

factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if % has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

factorTerms: % -> %

factorTerms(p) factors out numerical factor of the expression or polynomial expr.

factorTerms: (%, %) -> %

factorTerms(p, var) factors out numerical factor of the expression or polynomial expr without those related to var.

factorTerms: (%, JuliaWSList %) -> %

factorTerms(p, vars) factors the expression or polynomial expr by putting out numerical factors without those related to var(s).

factorTermsList: % -> JuliaWSList %

factorTermsList(expr) is the counterpart of factorTerms but here returned as a list of pair (numerical factor, polynomial factor).

factorTermsList: (%, %) -> JuliaWSList %

factorTermsList(expr, vars) is the counterpart of factorTerms but here returned as a list of pair (numerical factor, polynomial factor). The numerical factors related to var(s) are not factored.

fibonacci: (%, %) -> %

fibonacci(n, x) returns the Fibonacci polynomial or evaluates it at x if x is a number.

findInstance: (%, %) -> JuliaWSList JuliaWSList %

findInstance(expr,lvars) tries to find an instance the (in)equation in expr.

findInstance: (%, %, %) -> JuliaWSList JuliaWSList %

findInstance(expr,lvars,dom) tries to find an instance to the equation in expr.

findInstance: (%, %, %, %) -> JuliaWSList JuliaWSList %

findInstance(expr,lvars,dom, n) tries to find n instance(s) to the (in)equation in expr.

findInstance: (Equation %, %) -> JuliaWSList JuliaWSList %

findInstance(expr,lvars) tries to find an instance the equation in expr.

findInstance: (Equation %, %, %) -> JuliaWSList JuliaWSList %

findInstance(expr,lvars,dom) tries to find an instance the equation in expr.

findInstance: (Equation %, %, %, %) -> JuliaWSList JuliaWSList %

findInstance(expr,lvars,dom,n) tries to find n instance(s) to the equation in expr.

findRoot: (%, %) -> %

findRoot(exp,start) try to find the root of expr starting at start. example{findRoot(sin(x) + cos(x), “{x, 0}”)}

first: % -> %

from JuliaWSAggregate %

floor: % -> %

floor(x) returns the greatest integer less than or equal to x

fractionPart: % -> %

from SpecialFunctionCategory

freeOf?: (%, %) -> Boolean

from ExpressionSpace2 Kernel %

freeOf?: (%, Symbol) -> Boolean

from ExpressionSpace2 Kernel %

fresnelC: % -> %

from LiouvillianFunctionCategory

fresnelS: % -> %

from LiouvillianFunctionCategory

fromCoefficientRules: (%, %) -> %

fromCoefficientRules(list, vars) constructs the polynomial from the list of coefficients and exponents rules. example{x:= jWSExpr x;y := jWSExpr y} example{coefficientRules((x + y)^2+x^11,jWSExpr [x,y])} example{fromCoefficientRules(%, jWSExpr [x,y])}

functionExpand: % -> %

functionExpand(expr) tries to expand functions in expr to more elementary functions. For example: example{functionExpand sphericalBesselJ(3,8)}

functionExpand: (%, %) -> %

functionExpand(expr,assumptions) tries to expand functions in expr to more elementary functions assuming that assumptions are satisfied.

Gamma: % -> %

from SpecialFunctionCategory

Gamma: (%, %) -> %

from SpecialFunctionCategory

Gamma: (%, %, %) -> %

Gamma(a,z1,z2) computes the generalized incomplete gamma function.

GammaRegularized: (%, %) -> %

GammaRegularized(a,x) computes the regularized incomplete gamma function.

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %

from GcdDomain

gegenbauerC: (%, %) -> %

gegenbauerC(n,x) returns the renormalized form of the Gegenbauer polynomial or evaluates it at x if x is a number.

gegenbauerC: (%, %, %) -> %

gegenbauerC(n,lambda,x) returns the Gegenbauer polynomial or evaluates it at x if x is a number.

generator: () -> %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

goldenRatio: () -> %

goldenRatio() returns the golden ratio.

groebnerBasis: (%, %) -> JuliaWSList %

groebnerBasis(lpoly, lvar) computes a Groebner basis from the list of polynomials lpoly relative to the list of vars lvars.

groebnerBasis: (%, %, %) -> JuliaWSList %

groebnerBasis(lpoly, lvar, opt) computes a Groebner basis from the list of polynomials lpoly relative to the list of variables in lvars without variables in opt. Opt can also give the modulus to compute it: “Modulus -> p".

ground?: % -> Boolean

from FunctionSpace2(%, Kernel %)

ground: % -> %

from FunctionSpace2(%, Kernel %)

gudermannian: % -> %

gudermannian(z) computes the gudermannian of z.

hahn_p: (%, %, %, %, %) -> %

from SpecialFunctionCategory

hahnQ: (%, %, %, %, %) -> %

from SpecialFunctionCategory

hahnR: (%, %, %, %, %) -> %

from SpecialFunctionCategory

hahnS: (%, %, %, %, %) -> %

from SpecialFunctionCategory

hankelH1: (%, %) -> %

from SpecialFunctionCategory

hankelH2: (%, %) -> %

from SpecialFunctionCategory

hash: % -> SingleInteger if % has Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if % has Hashable

from Hashable

haversine: % -> %

haversine(z) computes the haversine of z.

height: % -> NonNegativeInteger

from ExpressionSpace2 Kernel %

hermiteH: (%, %) -> %

hermiteH(n, x) returns the Hermite polynomial or evaluates it at x if x is a number.

hornerForm: (%, %) -> %

hornerForm(expr, x) returns the Horner form of expr (minimizing multiplications).

hurwitzLerchPhi: (%, %, %) -> %

hurwitzLerchPhi(z,s,a) computes the Hurwitz–Lerch transcendent phi function.

hurwitzZeta: (%, %) -> %

hurwitzZeta(s,a) computes the Hurwitz zeta.

hyperFactorial: % -> %

hyperFactorial(n) computes the hyperfactorial of n.

hypergeometric0F1: (%, %) -> %

hypergeometric0F1(a,z) is the hypergeometric 0F1.

hypergeometric0F1Regularized: (%, %) -> %

hypergeometric0F1Regularized(a,z) is the regularized hypergeometric 0F1.

hypergeometric1F1: (%, %, %) -> %

hypergeometric1F1(a,b,z) is the Kummer confluent hypergeometric function 1F1.

hypergeometric1F1Regularized: (%, %, %) -> %

hypergeometric1F1Regularized(a,b,z) is the regularized confluent hypergeometric function 1F1.

hypergeometricU: (%, %, %) -> %

hypergeometricU(a,b,z) is the confluent hypergeometric function U.

imag: % -> %

from ComplexCategory %

imaginary: () -> %

from ComplexCategory %

insert: (%, %, JuliaWSInteger) -> %

from JuliaWSAggregate %

integral: (%, SegmentBinding %) -> %

from PrimitiveFunctionCategory

integral: (%, Symbol) -> %

from PrimitiveFunctionCategory

integrate: (%, %) -> %

integrate(expr, opts|var) integrate expr with respect to opt or var as options. For example: example{x:=jWSExpr x;integrate(1/(x^4-1),x)} example{opt:=jWSList [x,-1,1]} example{integrate(cos(x),opt)} => 2 sin(1) example{integrate(cos(x),”{x,-1.0,1.0}”)} => 1.68294

integrate: (%, %, Segment Integer) -> %

integrate(expr, var, seg) is the definite integration of expr with respect to var using segment seg.

integrate: (%, Symbol) -> %

integrate(expr, var) is the indefinite integration of expr with repect to var.

interpolatingPolynomial: (%, %) -> %

interpolatingPolynomial(lpoly,x) interpolates the list of polynomials lpoly with respect to x.

intersection: (%, %) -> %

from JuliaWSAggregate %

inv: % -> %

from Group

inverseBetaRegularized: (%, %, %) -> %

inverseBetaRegularized(s,a,b) computes the beta inverse.

inverseErf: % -> %

inverseErf(x) computes the inverse error function of x.

inverseErfc: % -> %

inverseErfc(x) computes the inverse complementary error function of x.

inverseGammaRegularized: (%, %) -> %

inverseGammaRegularized(a,s) computes the gamma inverse.

inverseGudermannian: % -> %

inverseGudermannian(z) computes the inverse gudermannian.

inverseHaversine: % -> %

inverseHaversine(z) computes the inverse haversine.

inverseJacobiCn: (%, %) -> %

inverseJacobiCn(nu, m) computes the inverse JacobiCN elliptic function.

inverseJacobiSn: (%, %) -> %

inverseJacobiSn(nu, m) computes the inverse JacobiSN elliptic function.

irreducible?: % -> Boolean

irreducible?(p) checks whether or not p is irreducible.

irreducible?: (%, %) -> Boolean

irreducible?(p) checks whether or not p is irreducible over Gaussian rationals or algebraic extensions.

is?: (%, BasicOperator) -> Boolean

from ExpressionSpace2 Kernel %

is?: (%, Symbol) -> Boolean

from ExpressionSpace2 Kernel %

isExpt: % -> Union(Record(var: Kernel %, exponent: Integer), failed)

from FunctionSpace2(%, Kernel %)

isExpt: (%, BasicOperator) -> Union(Record(var: Kernel %, exponent: Integer), failed)

from FunctionSpace2(%, Kernel %)

isExpt: (%, Symbol) -> Union(Record(var: Kernel %, exponent: Integer), failed)

from FunctionSpace2(%, Kernel %)

isMult: % -> Union(Record(coef: Integer, var: Kernel %), failed)

from FunctionSpace2(%, Kernel %)

isPlus: % -> Union(List %, failed)

from FunctionSpace2(%, Kernel %)

isPower: % -> Union(Record(val: %, exponent: Integer), failed)

from FunctionSpace2(%, Kernel %)

isTimes: % -> Union(List %, failed)

from FunctionSpace2(%, Kernel %)

jacobiAmplitude: (%, %) -> %

jacobiAmplitude(u,m) computes the amplitude function am.

jacobiCn: (%, %) -> %

from SpecialFunctionCategory

jacobiDn: (%, %) -> %

from SpecialFunctionCategory

jacobiP: (%, %, %, %) -> %

jacobiP(n, a, b, x) returns the Jacobi polynomial or evaluates it at x if x is a number.

jacobiSn: (%, %) -> %

from SpecialFunctionCategory

jacobiTheta: (%, %) -> %

from SpecialFunctionCategory

jacobiZeta: (%, %) -> %

jacobiZeta(phi,m) computes the Jacobi Zeta function.

jlAbout: % -> Void

from JuliaObjectType

jlApply: (String, %) -> %

from JuliaObjectType

jlApply: (String, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %, %, %) -> %

from JuliaObjectType

jlEval: % -> %

from JuliaWSObject

jlEval: (%, String) -> %

jlEval(expr, param) evaluates expression expr with param as parameter(s). For example: example{x:=jWSExpr(“x”);jlEval(sqrt(x),”x=2.0”)}

jlEval: (%, String, String) -> %

jlEval(expr, param11, param2) evaluates expression expr with param1 and param2 as parameters. example{a:=jWSExpr(“a”);b:=jWSExpr(“b”);} example{jlEval(sqrt(a^2+b^2),”a=1.0”,”b=1.0”)}

jlEval: (%, String, String, String) -> %

jlEval(expr, param11, param2, param3) evaluates expression expr with param1, param2 and param3 as parameters.

jlHead: % -> JuliaWSSymbol

from JuliaWSObject

jlId: % -> String

from JuliaObjectType

jlNumeric: % -> %

from JuliaWSObject

jlNumeric: (%, PositiveInteger) -> %

from JuliaWSObject

jlRef: % -> SExpression

from JuliaObjectType

jlref: String -> %

from JuliaObjectType

jlSymbolic: % -> String

from JuliaWSObject

jlType: % -> String

from JuliaObjectType

jlWSAccuracy: % -> %

jlWSAccuracy(expr) get accuracy of expr.

jlWSPrecision: % -> %

jlWSPrecision get precision of expr.

jlWSSetAccuracy: (%, %) -> %

jlWSSetAccuracy(expr, acc) set accuracy of expr to acc.

jlWSSetOptions: (%, %) -> %

jlWSSetOptions(type, opts) sets some internal engine options.

jlWSSetPrecision: (%, %) -> %

jlWSSetPrecision(expr, prec) set precision of expr to prec.

join: (%, %) -> %

from JuliaWSAggregate %

jWSAggregate: List % -> %

from JuliaWSAggregate %

jWSEqual: (%, %) -> %

jWSEqual(lhs,rhs) returns the Julia WS equality lhs == rhs.

jWSExpr: DoubleFloat -> %

jWSExpr(r) returns the DoubleFloat as a JuliaWSExpression.

jWSExpr: Float -> %

jWSExpr(r) returns the Float r as a JuliaWSExpression.

jWSExpr: Fraction Integer -> %

jWSExpr(q) returns the Fraction(Integer) q as a JuliaWSExpression.

jWSExpr: Integer -> %

jWSExpr(z) returns the Integer z as a JuliaWSExpression.

jWSExpr: JuliaFloat64 -> %

jWSExpr(r) returns the JuliaFloat64 as a JuliaWSExpression.

jWSExpr: List % -> %

jWSExpr(list) returns the list of JuliaWSExpression as a JuliaWSExpression.

jWSExpr: String -> %

jWSExpr(str) constructs str as a JuliaWSExpression evaluating str as a Wolfram Symbolic Language Expression. For example: example{jWSExpr “Factorial[5]”} example{jWSExpr “3.14159”} example{jWSExpr “Today”}

jWSExpr: Symbol -> %

jWSExpr(sym) coerces sym to a JuliaWSExpression.

jWSGreater: (%, %) -> %

jWSGreater(lhs,rhs) returns the Julia WS inequality lhs > rhs.

jWSGreaterEqual: (%, %) -> %

jWSGreaterEqual(lhs,rhs) returns the Julia WS inequality lhs >= rhs.

jWSInterpret: (String, String) -> %

from JuliaWSObject

jWSLess: (%, %) -> %

jWSLess(lhs,rhs) returns the Julia WS inequality lhs < rhs.

jWSLessEqual: (%, %) -> %

jWSLessEqual(lhs,rhs) returns the Julia WS inequality lhs <= rhs.

jWSNotEqual: (%, %) -> %

jWSNotEqual(lhs,rhs) returns the Julia WS inequality lhs != rhs.

jWSQuantity: % -> %

jWSQuantity(jWSString(u)) returns quantity unit u of 1. For example: example{jWSQuantity jWSString “Meter”}

jWSQuantity: (%, %) -> %

jWSQuantity(x,jWSString(u)) returns quantity unit u of x. For example: example{jWSQuantity(1.2, jWSString “Meter”)}

jWSRule: (%, %) -> %

jWSRule(lhs,rhs) returns the Julia WS rule lhs->rhs.

jWSString: String -> %

jWSString(str) returns str as a WS String.

jWSTable: (%, %) -> JuliaWSList %

jWSTable(expr, range) applies the expr to the define range.

jWSTable: (%, %, %) -> JuliaWSList JuliaWSList %

jWSTable(expr, range1, range2) applies the expr to the define ranges.

kelvinBei: (%, %) -> %

from SpecialFunctionCategory

kelvinBer: (%, %) -> %

from SpecialFunctionCategory

kelvinKei: (%, %) -> %

from SpecialFunctionCategory

kelvinKer: (%, %) -> %

from SpecialFunctionCategory

kernel: (BasicOperator, %) -> %

from ExpressionSpace2 Kernel %

kernel: (BasicOperator, List %) -> %

from ExpressionSpace2 Kernel %

kernels: % -> List Kernel %

from ExpressionSpace2 Kernel %

kernels: List % -> List Kernel %

from ExpressionSpace2 Kernel %

key?: (%, %) -> Boolean

key?(assoc,key) checks wheter or not key exist in the association assoc.

keys: % -> %

keys(expr) returns the key elements in expr if any.

kleinInvariantJ: % -> %

kleinInvariantJ(tau) computes the Klein's absolute invariant.

krawtchoukK: (%, %, %, %) -> %

from SpecialFunctionCategory

kummerM: (%, %, %) -> %

from SpecialFunctionCategory

kummerU: (%, %, %) -> %

from SpecialFunctionCategory

laguerreL: (%, %) -> %

laguerreL(n, x) returns the laguerre polynomial or evaluates it at x if x is a number. For example: example{laguerreL(5, jWSExpr x)}

laguerreL: (%, %, %) -> %

laguerreL(n, a, x) returns the genralized laguerre polynomial or evaluates it at x if x is a number.

lambertW: % -> %

from SpecialFunctionCategory

lambertW: (%, %) -> %

lambertW(k,z) returns the k-th solution to LambertW function.

last: % -> %

from JuliaWSAggregate %

latex: % -> String

from SetCategory

lcm: (%, %) -> %

from GcdDomain

lcm: List % -> %

from GcdDomain

lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %)

from LeftOreRing

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

legendreP: (%, %) -> %

legendreP(n, x) returns the legendre polynomial of the first kind or evaluates it at x is x a number.

legendreP: (%, %, %) -> %

legendreP(n, m, x) returns the associated Legendre polynomial of the first type or evaluates it at x if x is a number.

legendreQ: (%, %) -> %

legendreQ(n, x) returns the Legendre function of the second kind or evaluates it at x if x is a number. example{legendreQ(3,jWSExpr x)}

legendreQ: (%, %, %) -> %

legendreQ(n, m, x) returns the associated Legendre function of the second kind or evaluates it at x if x is a number.

length: % -> %

length(expr) returns the length of expr seen as a list.

length: % -> JuliaWSInteger

from JuliaWSAggregate %

lerchPhi: (%, %, %) -> %

lerchPhi(z,s,a) returns Lerch's transcendent phi of arguments.

level: (%, %) -> JuliaWSList %

level(expr, lev) returns the list of expression expr at level lev.

level: (%, %, Boolean) -> JuliaWSList %

level(expr, lev, head) returns the list of expression expr at level lev with heads if head is true.

li: % -> %

from LiouvillianFunctionCategory

lift: % -> SparseUnivariatePolynomial %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

limit: (%, %) -> %

limit(expr, params) returns the limit, eventually nested or multivariate, of expr. For example: example{x:=jWSExpr x; limit(sin(x)-sin(x-1/x),”x->Infinity”)}

log10: % -> %

log10(x) computes logarithm of x in base 10.

log2: % -> %

log2(x) computes logarithm of x in base 2.

log: % -> %

from ElementaryFunctionCategory

logBarnesG: % -> %

logBarnesG(x) is the logarithm of Barnes-G.

logGamma: % -> %

logGamma(z) returns the log-gamma of z.

lommelS1: (%, %, %) -> %

from SpecialFunctionCategory

lommelS2: (%, %, %) -> %

from SpecialFunctionCategory

lookup: % -> PositiveInteger if % has Finite

from Finite

lookup: (%, %) -> %

lookup(assocs,keys) returns value(s) associated to key(s).

lookup: (%, %, %) -> %

lookup(assocs,keys, defaultval) returns value(s) associated to key(s) if key(s) exist(s), otherwise defaultval

mainKernel: % -> Union(Kernel %, failed)

from ExpressionSpace2 Kernel %

map: (% -> %, %) -> %

from FullyEvalableOver %

map: (% -> %, Kernel %) -> %

from ExpressionSpace2 Kernel %

mathieuC: (%, %, %) -> %

mathieuC(a,q,z) is the even Mathieu function with characteristic a and parameter q.

mathieuCharacteristicA: (%, %) -> %

mathieuCharacteristicA(r,q) returns the characteristic for even Mathieu function.

mathieuCharacteristicB: (%, %) -> %

mathieuCharacteristicB(r,q) returns the characteristic for odd Mathieu function.

mathieuCharacteristicExponent: (%, %) -> %

mathieuCharacteristicExponent(a,q) returns the characterisitc exponent o he Mathieu function.

mathieuCPrime: (%, %, %) -> %

mathieuCPrime(a,q,z) derivative of the even Mathieu function.

mathieuS: (%, %, %) -> %

mathieuS(b,q,z) is the odd Mathieu function with characteristic b and parameter q.

mathieuSPrime: (%, %, %) -> %

mathieuSPrime(b,q,z) derivative of the odd Mathieu function.

matrixForm: % -> %

matrixForm(mat) returns a pretty-printable form of mat i.e. its WS ‘MatrixForm’.

maximize: (%, %) -> %

maximize(expr, vars) is the WS symbolic maximization function. expr can contain constraints if it is a WS list of constraints with function to maximize as the first element. Global optimization function otherwise.

maximize: (%, %, %) -> %

maximize(expr, vars, dom) is the WS symbolic maximization function. dom restricts the domain of variables, for example, Integers.

maximize: (%, Symbol) -> %

maximize(expr, sym) symbolically maximizes expression function expr with respect to sym. expr can contain constraints if it is a WS list of constraints with function to maximize as the first element. Global optimization function otherwise.

maxLimit: (%, %) -> %

maxLimit(expr, params) returns the max limit, eventually nested or multivariate, of expr.

meixnerM: (%, %, %, %) -> %

from SpecialFunctionCategory

meixnerP: (%, %, %, %) -> %

from SpecialFunctionCategory

member?: (%, %) -> Boolean

member?(list, expr) checks if expr is in list.

minimalPolynomial: % -> SparseUnivariatePolynomial %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

minimalPolynomial: (%, %) -> %

minimalPolynomial(expr,var) returns the minimal polynomial in the variable var of the expression expr.

minimalPolynomial: (%, %, %) -> %

minimalPolynomial(expr,var, elem) returns the minimal polynomial in the variable var of the expression expr.

minimize: (%, %) -> %

minimize(expr, vars) is the WS symbolic minimization function. expr can contain constraints if it is a WS list of constraints with function to minimize as the first element. Global optimization function otherwise.

minimize: (%, %, %) -> %

minimize(expr, vars, dom) is the WS symbolic minimization function. dom restricts the domain of variables, for example, Integers.

minimize: (%, Symbol) -> %

minimize(expr, sym) symbolically minimizes expression function expr with respect to sym. expr can contain constraints if it is a WS list of constraints with function to minimize as the first element. Global optimization function otherwise.

minLimit: (%, %) -> %

minLimit(expr, params) returns the min limit, eventually nested or multivariate, of expr.

minPoly: Kernel % -> SparseUnivariatePolynomial %

from ExpressionSpace2 Kernel %

modularLambda: % -> %

modularLambda() computes the lambda modular function.

monomialList: % -> %

monomialList(p) returns the list of monomials in p.

multiEuclidean: (List %, %) -> Union(List %, failed)

from EuclideanDomain

mutable?: % -> Boolean

from JuliaObjectType

negative?: % -> Boolean

negative?(expr) checks whether or not expr is negative.

norm: % -> %

from ComplexCategory %

normal: % -> %

normal(expr) converts expr to a normal expression from different expression types. Can be applied to a power serie for example.

normal: (%, %) -> %

normal(expr, list(Head)||Head) converts objects in expr to a normal expression form from different expression types, with Head, or a list of Head-s.

nothing?: % -> Boolean

from JuliaObjectType

nthRoot: (%, Integer) -> %

from RadicalCategory

numer: % -> SparseMultivariatePolynomial(%, Kernel %)

from FunctionSpace2(%, Kernel %)

numerator: % -> %

numerator(expr) returns the numerator of expr.

numerDenom: % -> JuliaWSList %

numerDenom(expr) returns the numerator and denominator of expr.

numericDSolve: (%, %, %) -> %

numericDSolve(expr,fun,xrange) solves numerically the differential equation(s) in expr for the function fun, in the range xrange. Other combinaisons of parameters are also available.

numericDSolve: (%, %, %, %) -> %

numericDSolve(expr,fun,xrange,yrange) solves numerically the differential equation(s) in expr for the function fun, in the ranges xrange and yrange. Other combinaisons of parameters are also available (see documentation).

numericDSolve: (Equation %, %, %) -> %

numericDSolve(eq,fun,xrange) solves numerically the differential equation eq for the function fun, in the range xrange.

numericDSolveValue: (%, %, %) -> %

numericDSolveValue(expr,fun,xrange) returns the numerical value solution of the differential equation(s) in expr for the function fun, in the range xrange. Other combinaisons of parameters are also available (see documentation).

numericDSolveValue: (%, %, %, %) -> %

numericDSolveValue(expr,fun,xrange,yrange) returns the numerical solution of the differential equation(s) in expr for the function fun, in the ranges xrange and yrange. Other combinaisons of parameters are also available (see documentation).

numericDSolveValue: (Equation %, %, %) -> %

numericDSolveValue(eq,fun,xrange) return the numerical solution of the differential equation eq for the function fun, in the range xrange.

numericIntegrate: (%, %) -> %

numericIntegrate(expr, opt|var) integrate numerically expr with respect to opt or var as options.

numericIntegrate: (%, %, Segment Integer) -> %

numericIntegrate(expr, var, seg) integrates expr using segment seg with respect to var.

numericMaximize: (%, %) -> %

numericMaximize(expr, vars) maximizes numerically the expression function expr with respect to vars.

numericMaximize: (%, %, %) -> %

numericMaximize(expr, vars, dom) maximizes numerically the expression function expr with respect to vars and vars restricted to the domain dom.

numericMaximize: (%, Symbol) -> %

numericMaximize(expr, sym) maximizes numerically the expression function expr with respect to sym.

numericMinimize: (%, %) -> %

numericMinimize(expr, vars) minimizes numerically the expression function expr with respect to vars. For example, global optimization from the SIAM 100 digits challenge: example{x := jWSExpr(x);y:=jWSExpr y;} example{expr := exp(sin(50*x))+sin(60*exp(y))+ sin(70*sin(x))+ sin(sin(80*y))-sin(10*(x+y))+(x^2+y^2)/4} example{numericMinimize(expr, jWSList [x,y])}

numericMinimize: (%, %, %) -> %

numericMinimize(expr, vars, dom) minimizes numerically the expression function expr with respect to vars and vars restricted to the domain dom.

numericMinimize: (%, Symbol) -> %

numericMinimize(expr, sym) minimizes numerically the expression function expr with respect to sym.

numericProduct: (%, %) -> %

numericProduct(f(n),range) an evaluated numerical approximation of the sum f(imin) + .. + f(imax) defined by the list range, for example example{jWSExpr(”{i, imin, imax}”)}. See Wolfram language specifications.

numericProduct: (%, %, Segment Integer) -> %

numericProduct(f(n),n, a..b) returns an evaluated numerical approximation product f(a) * f(a2) * .. * f(b).

numericSolve: (%, %) -> %

numericSolve(expr, vars) returns the solution(s) to the expression expr.

numericSolve: (Equation %, %) -> %

numericSolve(eq, vars) returns the solution(s) to the equation eq.

numericSum: (%, %) -> %

numericSum(f(n),range) an evaluated numerical approximation of the sum f(imin) + .. + f(imax) defined by the list range, for example example{jWSExpr(”{i, imin, imax}”)}. See Wolfram language specifications.

numericSum: (%, %, Segment Integer) -> %

numericSum(f(n),n, a..b) returns an evaluated numerical approximation sum f(a) + f(a2) + .. + f(b).

one?: % -> Boolean

from MagmaWithUnit

operator: BasicOperator -> BasicOperator

from ExpressionSpace2 Kernel %

operators: % -> List BasicOperator

from ExpressionSpace2 Kernel %

opposite?: (%, %) -> Boolean

from AbelianMonoid

padeApproximant: (%, %) -> %

padeApproximant(expr, {x,x0, {n,m}}) returns the Padé approximant at x0.

parabolicCylinderD: (%, %) -> %

parabolicCylinderD(nu,x) computes the parabolic cylinder function D of x.

paren: % -> %

from ExpressionSpace2 Kernel %

part: (%, JuliaWSInteger) -> %

from JuliaWSAggregate %

permutation: (%, %) -> %

from CombinatorialFunctionCategory

pi: () -> %

from TranscendentalFunctionCategory

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra %

pochhammer: (%, %) -> %

pochhammer(a,n) returns the Pochhammer symbol.

polygamma: (%, %) -> %

from SpecialFunctionCategory

polylog: (%, %) -> %

from SpecialFunctionCategory

polylog: (%, %, %) -> %

polylog(n,p,x) is the Nielsen generalized polylogarithm function.

polynomial?: (%, %) -> Boolean

polynomial?(p,x) check whether or not p is a polynomial in x.

polynomial?: (%, JuliaWSList %) -> Boolean

polynomial?(p,vlist) check whether or not p is a polynomial in the list of variables vlist.

polynomialExtendedGCD: (%, %, %) -> %

polynomialExtendedGCD(p1, p2, x) returns the greatest common divisor of p1 and p2 considered as univariate polynomial in x

polynomialFactor: % -> %

polynomialFactor(p) factorizes the polynomial p. For example: example{x := jWSExpr x} example{p:=expand(chebyshevT(7,x)* chebyshevU(9,x))} example{polynomialFactor p}

polynomialGCD: (%, %) -> %

polynomialGCD(p1, p2) returns the greatest common divisor of p1 and p2.

polynomialGCD: (%, %, %) -> %

polynomialGCD(p1, p2, opt) returns the greatest common divisor of p1 and p2 with options opt, for example Modulus->p.

polynomialLCM: (%, %) -> %

polynomialLCM(p1,p2) returns the least common divisor of p1 and p2.

polynomialLCM: (%, %, %) -> %

polynomialLCM(p1,p2,opt) returns the least common divisor of p1 and p2 with options opt, for example an Extension rule.

polynomialMod: (%, %) -> %

polynomialMod(p,mod) reduces modulo p the intger coefficients of the polynomial p.

polynomialQuotient: (%, %, %) -> %

polynomialQuotient(p1, p2, x) returns the quotient of p1 and p2 in x.

polynomialQuotientRemainder: (%, %, %) -> JuliaWSList %

polynomialQuotientRemainder(p1,p2,var) returns the quotient and remainder of p1 and p2 in x.

polynomialReduce: (%, %, %) -> %

polynomialReduce(poly,lpoly,lvar) returns a minimal representation of the polynomial poly in terms of the polynomial list lpoly with respect to the list of variables lvar.

polynomialRemainder: (%, %, %) -> %

polynomialRemainder(p1,p2, x) returns the remainder of p1 and p2 in x.

positive?: % -> Boolean

positive?(expr) checks whether or not expr is positive.

positiveInfinity: () -> %

positiveInfinity() returns positive infinity (∞).

powerExpand: % -> %

powerExpand(expr) expands powers in expr assuming no branch cut.

powerExpand: (%, %) -> %

powerExpand(expr, sym) expands powers in expr with respect to sym, assuming no branch cut.

prepend: (%, %) -> %

from JuliaWSAggregate %

prime?: % -> Boolean

from UniqueFactorizationDomain

principalIdeal: List % -> Record(coef: List %, generator: %)

from PrincipalIdealDomain

product: (%, %) -> %

product(f(n),range) returns the product f(imin) * .. * f(imax) defined by the list range, for example example{jWSExpr(”{i, imin, imax}”)}. See Wolfram language specifications.

product: (%, %, Segment Integer) -> %

product(f(n),n, a..b) returns the product f(a) * .. * f(b).

product: (%, SegmentBinding %) -> %

from CombinatorialOpsCategory

product: (%, Symbol) -> %

product(f(n),n) returns the indefinite product of f(n).

QBinomial: (%, %, %) -> %

QBinomial(n,m,q) returns the q-analog of binomial coefficient.

qelt: (%, Integer) -> %

from JuliaWSAggregate %

QFactorial: (%, %) -> %

QFactorial(x,q) returns the q-analog of factorial of x.

QGamma: (%, %) -> %

QGamma(x,q) returns the q-analog of Euler gamma of x.

QPochhammer: (%, %) -> %

QPochhammer(x,q) returns the q-Pochammer symbol of x.

QPochhammer: (%, %, %) -> %

QPochhammer(x,q,n) returns the q-Pochammer symbol of x.

QPolyGamma: (%, %) -> %

QPolyGamma(x,q) returs the q-digamma of x.

QPolyGamma: (%, %, %) -> %

QPolyGamma(n,x,q) returns the n-th derivative of the q-digamma function of x.

qsetelt!: (%, Integer, %) -> %

from JuliaWSAggregate %

qsetelt: (%, Integer, %) -> %

from JuliaWSAggregate %

quantityForm: (%, %) -> %

quantityForm(expr,form) returns expr as a quantity with format form.

quantityForm: (%, JuliaWSList %) -> %

quantityForm(expr,lform) returns expr as a quantity with a list of formats lform.

quantityMagnitude: % -> %

quantityMagnitude(val) returns magnitude of val.

quantityUnit: % -> %

quantityUnit(val) returns unit of val.

quo: (%, %) -> %

from EuclideanDomain

racahR: (%, %, %, %, %, %) -> %

from SpecialFunctionCategory

ramanujanTau: % -> %

ramanujanTau(n) returns the Ramanujan tau of n.

ramanujanTauL: % -> %

ramanujanTauL(s) computes the Ramanujan tau Dirichlet L-function of s.

ramanujanTauTheta: % -> %

ramanujanTauTheta(z) returns the Ramanujan tau theta of z.

ramanujanTauZ: % -> %

ramanujanTauZ(t) computes the Ramanujan tau Z-function of t.

random: () -> % if % has Finite

from Finite

rank: () -> PositiveInteger

from FramedModule %

rationalApproximation: % -> %

rationalApproximation(expr) try to find a rational approximation of the expression expr.

rationalApproximation: (%, %) -> %

rationalApproximation(expr, dx) try to find a rational approximation of the expression expr within tolerance dx.

real: % -> %

from ComplexCategory %

recip: % -> Union(%, failed)

from MagmaWithUnit

reduce: (%, %) -> %

reduce(expr,lvars) tries to reduce the (in)equation in expr.

reduce: (%, %, %) -> %

reduce(expr,lvars,dom) tries to reduce the (in)equation in expr.

reduce: (%, String, %, %) -> %

reduce(lhs, rel, rhs,lvars) tries to reduce the (in)equation in expr where rel is the relation operator (“==” or “<=” for example).

reduce: (%, String, %, %, %) -> %

reduce(lhs, rel,rhs,lvars,dom) tries to reduce the (in)equation in expr where rel is the relation operator ("=" or “<=” for example).

reduce: (Equation %, %) -> %

reduce(expr,lvars) tries to reduce the equation in expr.

reduce: (Equation %, %, %) -> %

reduce(expr,lvars,dom) tries to reduce the equation in expr.

reduce: Fraction SparseUnivariatePolynomial % -> Union(%, failed)

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

reduce: SparseUnivariatePolynomial % -> %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix %, vec: Vector %)

from LinearlyExplicitOver %

reducedSystem: Matrix % -> Matrix %

from LinearlyExplicitOver %

refine: (%, %) -> %

refine(expr, assums) refines the expression expr with assumptions assums.

regularRepresentation: % -> Matrix %

from FramedAlgebra(%, SparseUnivariatePolynomial %)

regularRepresentation: (%, Vector %) -> Matrix %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

rem: (%, %) -> %

from EuclideanDomain

removeDuplicates: % -> %

from JuliaWSAggregate %

replace: (%, %) -> %

replace(expr, rule) applies rule(s) to expr.

replace: (%, %, %) -> %

replace(expr, rule, lev) applies rule to expr with level lev.

replaceAll: (%, %) -> %

replaceAll(expr, rule) applies rule(s) to expr.

replaceAt: (%, %, %) -> %

replaceAt(expr, part, n) replaces the n-th element of expr using rule(s).

replacePart: (%, %) -> %

replacePart(expr, part) replaces expr using rule(s) expressing position(s).

replaceRepeated: (%, %) -> %

replaceRepeated(expr, rule) applies rule(s) to expr, but repeatedly.

represents: (Vector %, Vector %) -> %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

represents: Vector % -> %

from FramedModule %

residue: (%, %) -> %

residue(expr, {x,x0}) returns the residue of expr at x0.

residueSum: (%, %) -> %

residueSum(expr, var) returns the residue of expr. example{residueSum(Gamma(x),x)}

rest: % -> %

from JuliaWSAggregate %

resultant: (%, %, %) -> %

resultant(p1,p2,x) returns the resultant of p1 and p2.

retract: % -> %

from RetractableTo %

retract: % -> Expression Integer

retract(expr) tries to retract expr to an Expression(Integer). Throws an error otherwise.

retract: % -> Fraction Integer if % has RetractableTo Integer or % has RetractableTo Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Fraction Polynomial %

from RetractableTo Fraction Polynomial %

retract: % -> Kernel %

from RetractableTo Kernel %

retract: % -> Polynomial %

from RetractableTo Polynomial %

retract: % -> Symbol

from RetractableTo Symbol

retractIfCan: % -> Union(%, failed)

from RetractableTo %

retractIfCan: % -> Union(DoubleFloat, failed)

retractIfCan(expr) retracts expr to a DoubleFloat if it can be retracted to a Lisp machine float.

retractIfCan: % -> Union(Expression Integer, failed)

retractIfCan(expr) tries to retract expr to an Expression(Integer).

retractIfCan: % -> Union(Fraction Integer, failed) if % has RetractableTo Integer or % has RetractableTo Fraction Integer

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Fraction Polynomial %, failed)

from RetractableTo Fraction Polynomial %

retractIfCan: % -> Union(JuliaFloat64, failed)

retractIfCan(expr) retracts expr to a JuliaFloat64 if it can be retracted to a 64 bits machine float.

retractIfCan: % -> Union(Kernel %, failed)

from RetractableTo Kernel %

retractIfCan: % -> Union(Polynomial %, failed)

from RetractableTo Polynomial %

retractIfCan: % -> Union(Symbol, failed)

from RetractableTo Symbol

reverse: % -> %

from JuliaWSAggregate %

reverse: (%, JuliaWSInteger) -> %

from JuliaWSAggregate %

reverse: (%, JuliaWSList JuliaWSInteger) -> %

from JuliaWSAggregate %

riemannSiegelTheta: % -> %

riemannSiegelTheta(t) returns the Riemann-Siegel theta function of t.

riemannSiegelZ: % -> %

riemannSiegelZ(t) computes the Riemann-Siegel Z function of t.

riemannZeta: % -> %

from SpecialFunctionCategory

riemannZeta: (%, %) -> %

riemannZeta(s,a) is the generalized Riemann zeta function.

riffle: (%, %) -> %

from JuliaWSAggregate %

riffle: (%, %, %) -> %

from JuliaWSAggregate %

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

rootOf: % -> %

from AlgebraicallyClosedFunctionSpace %

rootOf: (%, Symbol) -> %

from AlgebraicallyClosedFunctionSpace %

rootOf: (SparseUnivariatePolynomial %, Symbol) -> %

from AlgebraicallyClosedField

rootOf: Polynomial % -> %

from AlgebraicallyClosedField

rootOf: SparseUnivariatePolynomial % -> %

from AlgebraicallyClosedField

rootReduce: % -> %

rootReduce(expr) reduces root functions.

rootsOf: % -> List %

from AlgebraicallyClosedFunctionSpace %

rootsOf: (%, Symbol) -> List %

from AlgebraicallyClosedFunctionSpace %

rootsOf: (SparseUnivariatePolynomial %, Symbol) -> List %

from AlgebraicallyClosedField

rootsOf: Polynomial % -> List %

from AlgebraicallyClosedField

rootsOf: SparseUnivariatePolynomial % -> List %

from AlgebraicallyClosedField

rootSum: (%, SparseUnivariatePolynomial %, Symbol) -> %

from AlgebraicallyClosedFunctionSpace %

round: % -> %

round(x) returns the integer closest to x.

sample: %

from AbelianMonoid

sec: % -> %

from TrigonometricFunctionCategory

sech: % -> %

from HyperbolicFunctionCategory

series: (%, %) -> %

series(expr, opt) returns a serie from expr. example{x:=jWSExpr(x)} example{opt:=jWSList [x,pi()$JWSEXPR/4,7]} example{series(sin(a*x),opt)} example{series(cos(x),”{x, 0, 12}”)}

setelt!: (%, Integer, %) -> %

from JuliaWSAggregate %

setelt: (%, Integer, %) -> %

from JuliaWSAggregate %

setIntersection: (%, %) -> %

from JuliaWSAggregate %

Shi: % -> %

from LiouvillianFunctionCategory

Si: % -> %

from LiouvillianFunctionCategory

siegelTheta: (%, %) -> %

siegelTheta(tau, s) computes the Siegel theta function.

siegelTheta: (%, %, %) -> %

siegelTheta(nu, tau, s) computes the Siegel theta function.

sign: % -> %

from SpecialFunctionCategory

simplify: % -> %

simplify(expr) simplifies the expr. example{x:=jWSExpr(“x”); simplify(sqrt(x^2)^2)}

simplify: (%, %) -> %

simplify(expr, assumptions) simplifies the expression expr assuming that assumptions are satisfied. For example: example{x:=jWSExpr(“x”); simplify(sqrt(x^2), “x>0”)}

sin: % -> %

from TrigonometricFunctionCategory

sinc: % -> %

sinc(x) computes the unormalized sinc of x, sin(x)/x and 0 if x = 0.

sinh: % -> %

from HyperbolicFunctionCategory

size: () -> NonNegativeInteger if % has Finite

from Finite

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

solve: (%, %) -> JuliaWSList JuliaWSList %

solve(expr, vars) tries to solve the expression expr.

solve: (%, %, %) -> JuliaWSList JuliaWSList %

solve(expr, vars, dom) tries to solve the expression expr.

solve: (%, String, %, %) -> JuliaWSList JuliaWSList %

solve(lhs, rel, rhs,lvars) tries to solve the (in)equation in expr where rel is the relation operator (“==” for example).

solve: (%, String, %, %, %) -> JuliaWSList JuliaWSList %

solve(lhs, rel,rhs,lvars,dom) tries to solve the (in)equation in expr where rel is the relation operator (“==” for example).

solve: (Equation %, %) -> JuliaWSList JuliaWSList %

solve(eq, vars) tries to solve the equation eq.

solve: (Equation %, %, %) -> JuliaWSList JuliaWSList %

solve(expr, vars, dom) tries to solve the expression expr.

solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if % has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

sort: % -> %

from JuliaWSAggregate %

sorted?: % -> Boolean

from JuliaWSAggregate %

sphericalBesselJ: (%, %) -> %

sphericalBesselJ(n,z) returns the spherical Bessel of the first kind of z.

sphericalBesselY: (%, %) -> %

sphericalBesselY(n,z) returns the spherical Bessel of the second kind of z.

sphericalHankelH1: (%, %) -> %

sphericalHankelH1(n,z) returns the spherical Hankel of the first kind of z.

sphericalHankelH2: (%, %) -> %

sphericalHankelH2(n,z) computes the spherical Hankel of the second kind of z.

sphericalHarmonicY: (%, %, %, %) -> %

sphericalHarmonicY(l, m, theta, phi) returns the spherical harmonic Y or evaluates it.

sqrt: % -> %

from RadicalCategory

squareFree: % -> Factored %

from UniqueFactorizationDomain

squareFreePart: % -> %

from UniqueFactorizationDomain

squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if % has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

stieltjesGamma: % -> %

stieltjesGamma(n) returns the n-th Stieltjes constant.

stieltjesGamma: (%, %) -> %

stieltjesGamma(n,a) returns the generalized n-th Stieltjes constant.

string: % -> String

from JuliaObjectType

struveH: (%, %) -> %

from SpecialFunctionCategory

struveL: (%, %) -> %

from SpecialFunctionCategory

subResultants: (%, %, %) -> %

subResultants(p1,p2,x) returns the subresultant of p1 and p2 with respect to x.

subst: (%, Equation %) -> %

from ExpressionSpace2 Kernel %

subst: (%, List Equation %) -> %

from ExpressionSpace2 Kernel %

subst: (%, List Kernel %, List %) -> %

from ExpressionSpace2 Kernel %

subtractIfCan: (%, %) -> Union(%, failed)

from CancellationAbelianMonoid

sum: (%, %) -> %

sum(f(n),range) returns the sum f(imin) + .. + f(imax) defined by the list range, for example example{jWSExpr(”{i, imin, imax}”)}. See Wolfram Language specifications.

sum: (%, %, Segment Integer) -> %

sum(f(n),n, a..b) returns the sum f(a) + .. + f(b).

sum: (%, Symbol) -> %

sum(f(n),n) returns the indefinite sum of f(n).

summation: (%, SegmentBinding %) -> %

from CombinatorialOpsCategory

summation: (%, Symbol) -> %

from CombinatorialOpsCategory

symmetricPolynomial: (%, JuliaWSList %) -> %

symmetricPolynomial(n,lvars) returns the n-th elementary symmetric polynomial with respect to variables in lvars.

symmetricReduction: (%, JuliaWSList %) -> JuliaWSList %

symmetricReduction(f,lvars) return a pair of polynomial representing f = p+q where p is a symmetric polynomial, q the remainder.

symmetricReduction: (%, JuliaWSList %, JuliaWSList %) -> JuliaWSList %

symmetricReduction(f, lvars, replnt) return a pair of polynomial representing f = p+q where p is a symmetric polynomial, q the remainder where variables in p replaced by the ones in replnt.

take: (%, Integer) -> %

from JuliaWSAggregate %

take: (%, JuliaWSList JuliaWSInteger) -> %

from JuliaWSAggregate %

tan: % -> %

from TrigonometricFunctionCategory

tanh: % -> %

from HyperbolicFunctionCategory

together: % -> %

together(expr) put together terms over a common denominator cancelling common factors in numerator and denominator.

toString: % -> String

from JuliaWSObject

toString: (%, %) -> String

toString(expr, form) returns the string representation of expr with WS language format form.

tower: % -> List Kernel %

from ExpressionSpace2 Kernel %

tower: List % -> List Kernel %

from ExpressionSpace2 Kernel %

trace: % -> %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

traceMatrix: () -> Matrix %

from FramedAlgebra(%, SparseUnivariatePolynomial %)

traceMatrix: Vector % -> Matrix %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

traditionalForm: % -> %

traditionalForm(expr) returns a traditional form of expr i.e. its WS ‘TraditionalForm’.

trigExpand: % -> %

trigExpand(expr) tries to expand (hyperbolic) trigonometric functions in expr.

trigFactor: % -> %

trigFactor(expr) factors (hyperbolic) trigonometric functions in expr.

trigFactorList: % -> JuliaWSList %

trigFactorList(expr) returns a list of factors of (hyperbolic) trigonometric functions in expr.

trigReduce: % -> %

trigReduce(expr) reduces power and products of trigonometric functions.

trigToExp: % -> %

trigToExp(expr) returns expr with (hyperbolic) trigonometric functions converted to, evetually complex, exponentials.

union: (%, %) -> %

from JuliaWSAggregate %

unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

unitNormal: % -> Record(unit: %, canonical: %, associate: %)

from EntireRing

unitStep: % -> %

from SpecialFunctionCategory

univariate: (%, Kernel %) -> Fraction SparseUnivariatePolynomial %

from FunctionSpace2(%, Kernel %)

values: % -> %

values(expr) returns the values elements in expr.

variables: % -> JuliaWSList %

variables(p) returns the list of variables in p.

variables: % -> List Symbol

from FunctionSpace2(%, Kernel %)

variables: List % -> List Symbol

from FunctionSpace2(%, Kernel %)

weberE: (%, %) -> %

from SpecialFunctionCategory

weierstrassP: (%, %, %) -> %

from SpecialFunctionCategory

weierstrassPInverse: (%, %, %) -> %

from SpecialFunctionCategory

weierstrassPPrime: (%, %, %) -> %

from SpecialFunctionCategory

weierstrassSigma: (%, %, %) -> %

from SpecialFunctionCategory

weierstrassZeta: (%, %, %) -> %

from SpecialFunctionCategory

whittakerM: (%, %, %) -> %

whittakerM(k,m,x) computes the Whittaker function M de x.

whittakerW: (%, %, %) -> %

whittakerW(k,m,z) computes the Whittaker function W de x.

wilsonW: (%, %, %, %, %, %) -> %

from SpecialFunctionCategory

zernikeR: (%, %, %) -> %

zernikeR(n, m, x) returns the Zernike radial polynomial or evaluates it at x if x is a number.

zero?: % -> Boolean

zero? x tries to determine if x is 0. For example: example{expr:=0$JWSEXPR/1*sqrt(17::JWSEXPR); zero? expr}

zeroOf: % -> %

from AlgebraicallyClosedFunctionSpace %

zeroOf: (%, Symbol) -> %

from AlgebraicallyClosedFunctionSpace %

zeroOf: (SparseUnivariatePolynomial %, Symbol) -> %

from AlgebraicallyClosedField

zeroOf: Polynomial % -> %

from AlgebraicallyClosedField

zeroOf: SparseUnivariatePolynomial % -> %

from AlgebraicallyClosedField

zerosOf: % -> List %

from AlgebraicallyClosedFunctionSpace %

zerosOf: (%, Symbol) -> List %

from AlgebraicallyClosedFunctionSpace %

zerosOf: (SparseUnivariatePolynomial %, Symbol) -> List %

from AlgebraicallyClosedField

zerosOf: Polynomial % -> List %

from AlgebraicallyClosedField

zerosOf: SparseUnivariatePolynomial % -> List %

from AlgebraicallyClosedField

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

AlgebraicallyClosedField

AlgebraicallyClosedFunctionSpace %

ArcHyperbolicFunctionCategory

ArcTrigonometricFunctionCategory

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CoercibleFrom %

CoercibleFrom Fraction Integer if % has RetractableTo Integer or % has RetractableTo Fraction Integer

CoercibleFrom Fraction Polynomial %

CoercibleFrom Kernel %

CoercibleFrom Polynomial %

CoercibleFrom Symbol

CoercibleTo OutputForm

CombinatorialFunctionCategory

CombinatorialOpsCategory

CommutativeRing

CommutativeStar

Comparable

ComplexCategory %

ConvertibleTo SparseUnivariatePolynomial %

ConvertibleTo String

DifferentialExtension %

DivisionRing

ElementaryFunctionCategory

EntireRing

EuclideanDomain

Evalable %

ExpressionSpace

ExpressionSpace2 Kernel %

Field

FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

FramedAlgebra(%, SparseUnivariatePolynomial %)

FramedModule %

FullyEvalableOver %

FullyLinearlyExplicitOver %

FullyPatternMatchable %

FullyRetractableTo %

FunctionSpace %

FunctionSpace2(%, Kernel %)

GcdDomain

HyperbolicFunctionCategory

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

IntegralDomain

JuliaObjectRing

JuliaObjectType

JuliaRing

JuliaType

JuliaWSAggregate %

JuliaWSObject

JuliaWSRing

LeftModule %

LeftModule Fraction Integer

LeftOreRing

LinearlyExplicitOver %

LiouvillianFunctionCategory

Magma

MagmaWithUnit

Module %

Module Fraction Integer

MonogenicAlgebra(%, SparseUnivariatePolynomial %)

Monoid

NonAssociativeAlgebra %

NonAssociativeAlgebra Fraction Integer

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PartialDifferentialRing %

PartialDifferentialRing Symbol

PartialOrder

Patternable %

PolynomialFactorizationExplicit

PrimitiveFunctionCategory

PrincipalIdealDomain

RadicalCategory

RetractableTo %

RetractableTo Fraction Polynomial %

RetractableTo Kernel %

RetractableTo Polynomial %

RetractableTo Symbol

RightModule %

RightModule Fraction Integer

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

SpecialFunctionCategory

TranscendentalFunctionCategory

TrigonometricFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown