login  home  contents  what's new  discussion  bug reports help  links  subscribe  changes  refresh  edit
 Topics FrontPage SandBox SandBoxExpr <-- You are here. Add conjugate spad)abbrev domain EXPR Expression ++ Top-level mathematical expressions ++ Author: Manuel Bronstein ++ Date Created: 19 July 1988 ++ Date Last Updated: October 1993 (P.Gianni), February 1995 (MB) ++ Description: Expressions involving symbolic functions. ++ Keywords: operator, kernel, function. Expression(R : Comparable) : Exports == Implementation where Q ==> Fraction Integer K ==> Kernel % MP ==> SparseMultivariatePolynomial(R, K) AF ==> AlgebraicFunction(R, %) EF ==> ElementaryFunction(R, %) CF ==> CombinatorialFunction(R, %) LF ==> LiouvillianFunction(R, %) AN ==> AlgebraicNumber KAN ==> Kernel AN FSF ==> FunctionalSpecialFunction(R, %) ESD ==> ExpressionSpace_&(%) FSD ==> FunctionSpace_&(%, R) POWER ==> '%power SUP ==> SparseUnivariatePolynomial Exports ==> FunctionSpace R with if R has IntegralDomain then AlgebraicallyClosedFunctionSpace R TranscendentalFunctionCategory CombinatorialOpsCategory LiouvillianFunctionCategory SpecialFunctionCategory reduce : % -> % ++ reduce(f) simplifies all the unreduced algebraic quantities ++ present in f by applying their defining relations. number? : % -> Boolean ++ number?(f) tests if f is rational simplifyPower : (%, Integer) -> % ++ simplifyPower(f, n) \undocumented{} if R has GcdDomain then factorPolynomial : SUP % -> Factored SUP % ++ factorPolynomial(p) \undocumented{} squareFreePolynomial : SUP % -> Factored SUP % ++ squareFreePolynomial(p) \undocumented{} if R has RetractableTo Integer then RetractableTo AN setSimplifyDenomsFlag : Boolean -> Boolean ++ setSimplifyDenomsFlag(x) sets flag affecting simplification ++ of denominators. If true irrational algebraics are removed from ++ denominators. If false they are kept. getSimplifyDenomsFlag : () -> Boolean ++ getSimplifyDenomsFlag() gets values of flag affecting ++ simplification of denominators. See setSimplifyDenomsFlag. Implementation ==> add import from KernelFunctions2(R, %) SYMBOL := '%symbol ALGOP := '%alg retNotUnit : % -> R retNotUnitIfCan : % -> Union(R, "failed") belong? op == true retNotUnit x == (u := constantIfCan(k := retract(x)@K)) case R => u::R error "Not retractable" retNotUnitIfCan x == (r := retractIfCan(x)@Union(K,"failed")) case "failed" => "failed" constantIfCan(r::K) if not(R has IntegralDomain) then operator op == belong?(op)$FSD => operator(op)$FSD belong?(op)$ESD => operator(op)$ESD nullary? op and has?(op, SYMBOL) => operator(kernel(name op)$K) (n := arity op) case "failed" => operator name op operator(name op, n::NonNegativeInteger) SPCH ==> SparsePolynomialCoercionHelpers(R, Symbol, K) if R has Ring then poly_to_MP(p : Polynomial(R)) : MP == ps := p pretend SparseMultivariatePolynomial(R, Symbol) vl1 : List Symbol := variables(ps) vl2 : List K := [kernel(z)$K for z in vl1] remap_variables(ps, vl1, vl2)$SPCH if R has IntegralDomain then reduc : (%, List Kernel %) -> % algreduc : (%, List Kernel %) -> % commonk : (%, %) -> List K commonk0 : (List K, List K) -> List K toprat : % -> % algkernels : List K -> List K evl : (MP, K, SparseUnivariatePolynomial %) -> Fraction MP evl0 : (MP, K) -> SparseUnivariatePolynomial Fraction MP Rep := Fraction MP 0 == 0$Rep 1 == 1$Rep -- one? x == one?(x)$Rep one? x == (x = 1)$Rep zero? x == zero?(x)$Rep - x : % == -$Rep x n : Integer * x : % == n *$Rep x coerce(n : Integer) == coerce(n)$Rep@Rep::% x : % * y : % == algreduc(x *$Rep y, commonk(x, y)) x : % + y : % == algreduc(x +$Rep y, commonk(x, y)) (x : % - y : %) : % == algreduc(x -$Rep y, commonk(x, y)) x : % / y : % == algreduc(x /$Rep y, commonk(x, y)) number?(x : %) : Boolean == if R has RetractableTo(Integer) then ground?(x) or ((retractIfCan(x)@Union(Q,"failed")) case Q) else ground?(x) simplifyPower(x : %, n : Integer) : % == k : List K := kernels x is?(x, POWER) => -- Look for a power of a number in case we can do -- a simplification args : List % := argument first k not(#args = 2) => error "Too many arguments to ^" number?(args.1) => reduc((args.1) ^$Rep n, algtower(args.1))^(args.2) (first args)^(n*second(args)) reduc(x ^$Rep n, algtower(x)) x : % ^ n : NonNegativeInteger == n = 0 => 1$% n = 1 => x simplifyPower(numerator x, n::Integer) / simplifyPower(denominator x, n::Integer) x : % ^ n : Integer == n = 0 => 1$% n = 1 => x n = -1 => 1/x simplifyPower(numerator x, n) / simplifyPower(denominator x, n) x : % ^ n : PositiveInteger == n = 1 => x simplifyPower(numerator x, n::Integer) / simplifyPower(denominator x, n::Integer) smaller?(x : %, y : %) == smaller?(x, y)$Rep x : % = y : % == (x - y) =$Rep 0$Rep numer x == numer(x)$Rep denom x == denom(x)$Rep EREP := Record(num : MP, den : MP) coerce(p : MP) : % == [p, 1]$EREP pretend % coerce(p : Polynomial(R)) : % == en := poly_to_MP(p) [en, 1]$EREP pretend % coerce(pq : Fraction(Polynomial(R))) : % == en := poly_to_MP(numer(pq)) ed := poly_to_MP(denom(pq)) [en, ed]$EREP pretend % reduce x == reduc(x, algtower x) commonk(x, y) == commonk0(algtower x, algtower y) algkernels l == select!(x +-> has?(operator x, ALGOP), l) toprat f == ratDenom(f, algtower f )$AlgebraicManipulations(R, %) simple_root(r : K) : Boolean == is?(r, 'nthRoot) => al := argument(r) al.2 ~= 2::% => false a := al.1 #algkernels(kernels(a)) > 0 => false true false root_reduce(x : %, r : K) : % == a := argument(r).1 an := numer(a) dn := denom(a) dp := univariate(denom x, r) n0 := numer x c1 := leadingCoefficient(dp) c0 := leadingCoefficient(reductum(dp)) n1 := dn*(c0*n0 - monomial(1, r, 1)$MP*c1*n0) d1 := c0*c0*dn - an*c1*c1 reduc(n1 /$Rep d1, [r]) DEFVAR(algreduc_flag$Lisp, false$Boolean)$Lisp getSimplifyDenomsFlag() == algreduc_flag$Lisp setSimplifyDenomsFlag(x) == res := getSimplifyDenomsFlag() SETF(algreduc_flag$Lisp, x)$Lisp res algreduc(x, ckl) == x1 := reduc(x, ckl) not(getSimplifyDenomsFlag()) => x1 akl := algtower(1$MP /$Rep denom x1) #akl = 0 => x1 if #akl = 1 then r := akl.1 simple_root(r) => return root_reduce(x, r) sas := create()$SingletonAsOrderedSet for k in akl repeat q := univariate(x1, k, minPoly k )$PolynomialCategoryQuotientFunctions(IndexedExponents K, K, R, MP, %) x1 := retract(eval(q, sas, k::%))@% reduc(x1, akl) x : MP / y : MP == reduc(x /$Rep y, commonk(x /$Rep 1$MP, y /$Rep 1$MP)) -- since we use the reduction from FRAC SMP which asssumes -- that the variables are independent, we must remove algebraic -- from the denominators reducedSystem(m : Matrix %) : Matrix(R) == mm : Matrix(MP) := reducedSystem(map(toprat, m))$Rep reducedSystem(mm)$MP reducedSystem(m : Matrix %, v : Vector %): Record(mat : Matrix R, vec : Vector R) == r : Record(mat : Matrix MP, vec : Vector MP) := reducedSystem(map(toprat, m), map(toprat, v))$Rep reducedSystem(r.mat, r.vec)$MP -- The result MUST be left sorted deepest first MB 3/90 commonk0(x, y) == ans := empty()$List(K) for k in reverse! x repeat if member?(k, y) then ans := concat(k, ans) ans rootOf(x : SparseUnivariatePolynomial %, v : Symbol) == rootOf(x, v)$AF rootSum(x : %, p : SparseUnivariatePolynomial %, v : Symbol) : % == rootSum(x, p, v)$AF pi() == pi()$EF exp x == exp(x)$EF log x == log(x)$EF sin x == sin(x)$EF cos x == cos(x)$EF tan x == tan(x)$EF cot x == cot(x)$EF sec x == sec(x)$EF csc x == csc(x)$EF asin x == asin(x)$EF acos x == acos(x)$EF atan x == atan(x)$EF acot x == acot(x)$EF asec x == asec(x)$EF acsc x == acsc(x)$EF sinh x == sinh(x)$EF cosh x == cosh(x)$EF tanh x == tanh(x)$EF coth x == coth(x)$EF sech x == sech(x)$EF csch x == csch(x)$EF asinh x == asinh(x)$EF acosh x == acosh(x)$EF atanh x == atanh(x)$EF acoth x == acoth(x)$EF asech x == asech(x)$EF acsch x == acsch(x)$EF abs x == abs(x)$FSF conjugate x == conjugate(x)$FSF Gamma x == Gamma(x)$FSF Gamma(a, x) == Gamma(a, x)$FSF Beta(x, y) == Beta(x, y)$FSF digamma x == digamma(x)$FSF polygamma(k, x) == polygamma(k, x)$FSF besselJ(v, x) == besselJ(v, x)$FSF besselY(v, x) == besselY(v, x)$FSF besselI(v, x) == besselI(v, x)$FSF besselK(v, x) == besselK(v, x)$FSF airyAi x == airyAi(x)$FSF airyAiPrime(x) == airyAiPrime(x)$FSF airyBi x == airyBi(x)$FSF airyBiPrime(x) == airyBiPrime(x)$FSF lambertW(x) == lambertW(x)$FSF polylog(s, x) == polylog(s, x)$FSF weierstrassP(g2, g3, x) == weierstrassP(g2, g3, x)$FSF weierstrassPPrime(g2, g3, x) == weierstrassPPrime(g2, g3, x)$FSF weierstrassSigma(g2, g3, x) == weierstrassSigma(g2, g3, x)$FSF weierstrassZeta(g2, g3, x) == weierstrassZeta(g2, g3, x)$FSF -- weierstrassPInverse(g2, g3, z) == weierstrassPInverse(g2, g3, z)$FSF whittakerM(k, m, z) == whittakerM(k, m, z)$FSF whittakerW(k, m, z) == whittakerW(k, m, z)$FSF angerJ(v, z) == angerJ(v, z)$FSF weberE(v, z) == weberE(v, z)$FSF struveH(v, z) == struveH(v, z)$FSF struveL(v, z) == struveL(v, z)$FSF hankelH1(v, z) == hankelH1(v, z)$FSF hankelH2(v, z) == hankelH2(v, z)$FSF lommelS1(mu, nu, z) == lommelS1(mu, nu, z)$FSF lommelS2(mu, nu, z) == lommelS2(mu, nu, z)$FSF kummerM(mu, nu, z) == kummerM(mu, nu, z)$FSF kummerU(mu, nu, z) == kummerU(mu, nu, z)$FSF legendreP(nu, mu, z) == legendreP(nu, mu, z)$FSF legendreQ(nu, mu, z) == legendreQ(nu, mu, z)$FSF kelvinBei(v, z) == kelvinBei(v, z)$FSF kelvinBer(v, z) == kelvinBer(v, z)$FSF kelvinKei(v, z) == kelvinKei(v, z)$FSF kelvinKer(v, z) == kelvinKer(v, z)$FSF ellipticK(m) == ellipticK(m)$FSF ellipticE(m) == ellipticE(m)$FSF ellipticE(z, m) == ellipticE(z, m)$FSF ellipticF(z, m) == ellipticF(z, m)$FSF ellipticPi(z, n, m) == ellipticPi(z, n, m)$FSF jacobiSn(z, m) == jacobiSn(z, m)$FSF jacobiCn(z, m) == jacobiCn(z, m)$FSF jacobiDn(z, m) == jacobiDn(z, m)$FSF jacobiZeta(z, m) == jacobiZeta(z, m)$FSF jacobiTheta(q, z) == jacobiTheta(q, z)$FSF lerchPhi(z, s, a) == lerchPhi(z, s, a)$FSF riemannZeta(z) == riemannZeta(z)$FSF charlierC(n, a, z) == charlierC(n, a, z)$FSF hermiteH(n, z) == hermiteH(n, z)$FSF jacobiP(n, a, b, z) == jacobiP(n, a, b, z)$FSF laguerreL(n, a, z) == laguerreL(n, a, z)$FSF meixnerM(n, b, c, z) == meixnerM(n, b, c, z)$FSF if % has RetractableTo(Integer) then hypergeometricF(la, lb, x) == hypergeometricF(la, lb, x)$FSF meijerG(la, lb, lc, ld, x) == meijerG(la, lb, lc, ld, x)$FSF x : % ^ y : % == x ^$CF y factorial x == factorial(x)$CF binomial(n, m) == binomial(n, m)$CF permutation(n, m) == permutation(n, m)$CF factorials x == factorials(x)$CF factorials(x, n) == factorials(x, n)$CF summation(x : %, n : Symbol) == summation(x, n)$CF summation(x : %, s : SegmentBinding %) == summation(x, s)$CF product(x : %, n : Symbol) == product(x, n)$CF product(x : %, s : SegmentBinding %) == product(x, s)$CF erf x == erf(x)$LF erfi x == erfi(x)$LF Ei x == Ei(x)$LF Si x == Si(x)$LF Ci x == Ci(x)$LF Shi x == Shi(x)$LF Chi x == Chi(x)$LF li x == li(x)$LF dilog x == dilog(x)$LF fresnelS x == fresnelS(x)$LF fresnelC x == fresnelC(x)$LF integral(x : %, n : Symbol) == integral(x, n)$LF integral(x : %, s : SegmentBinding %) == integral(x, s)$LF operator op == belong?(op)$AF => operator(op)$AF belong?(op)$EF => operator(op)$EF belong?(op)$CF => operator(op)$CF belong?(op)$LF => operator(op)$LF belong?(op)$FSF => operator(op)$FSF belong?(op)$FSD => operator(op)$FSD belong?(op)$ESD => operator(op)$ESD nullary? op and has?(op, SYMBOL) => operator(kernel(name op)$K) (n := arity op) case "failed" => operator name op operator(name op, n::NonNegativeInteger) reduc(x, l) == for k in l repeat p := minPoly k x := evl(numer x, k, p) /$Rep evl(denom x, k, p) x evl0(p, k) == numer univariate(p::Fraction(MP), k)$PolynomialCategoryQuotientFunctions(IndexedExponents K, K, R, MP, Fraction MP) -- uses some operations from Rep instead of % in order not to -- reduce recursively during those operations. evl(p, k, m) == degree(p, k) < degree m => p::Fraction(MP) (((evl0(p, k) pretend SparseUnivariatePolynomial(%)) rem m) pretend SparseUnivariatePolynomial Fraction MP) (k::MP::Fraction(MP)) if R has GcdDomain then noalg? : SUP % -> Boolean noalg? p == while p ~= 0 repeat not empty? algkernels kernels leadingCoefficient p => return false p := reductum p true gcdPolynomial(p : SUP %, q : SUP %) == noalg? p and noalg? q => gcdPolynomial(p, q)$Rep gcdPolynomial(p, q)$GcdDomain_&(%) factorPolynomial(x : SUP %) : Factored SUP % == uf := factor(x pretend SUP(Rep))$SupFractionFactorizer( IndexedExponents K, K, R, MP) uf pretend Factored SUP % squareFreePolynomial(x : SUP %) : Factored SUP % == uf := squareFree(x pretend SUP(Rep))$SupFractionFactorizer( IndexedExponents K, K, R, MP) uf pretend Factored SUP % if R is AN then -- this is to force the coercion R -> EXPR R to be used -- instead of the coercioon AN -> EXPR R which loops. -- simpler looking code will fail! MB 10/91 coerce(x : AN) : % == (monomial(x, 0$IndexedExponents(K))$MP)::% if (R has RetractableTo Integer) then x : % ^ r : Q == x ^$AF r minPoly k == minPoly(k)$AF definingPolynomial x == definingPolynomial(x)$AF retract(x : %) : Q == retract(x)$Rep retractIfCan(x : %) : Union(Q, "failed") == retractIfCan(x)$Rep if not(R is AN) then k2expr : KAN -> % smp2expr : SparseMultivariatePolynomial(Integer, KAN) -> % R2AN : R -> Union(AN, "failed") k2an : K -> Union(AN, "failed") smp2an : MP -> Union(AN, "failed") coerce(x : AN) : % == smp2expr(numer x) / smp2expr(denom x) k2expr k == map(x +-> x::%, k)$ExpressionSpaceFunctions2(AN, %) smp2expr p == map(k2expr, x +-> x::%, p )$PolynomialCategoryLifting(IndexedExponents KAN, KAN, Integer, SparseMultivariatePolynomial( Integer, KAN), %) retractIfCan(x : %) : Union(AN, "failed") == ((n := smp2an numer x) case AN) and ((d := smp2an denom x) case AN) => (n::AN) / (d::AN) "failed" R2AN r == (u := retractIfCan(r::%)@Union(Q, "failed")) case Q => u::Q::AN "failed" k2an k == not(belong?(op := operator k)$AN) => "failed" is?(op, 'rootOf) => args := argument(k) a2 := args.2 k1u := retractIfCan(a2)@Union(K, "failed") k1u case "failed" => "failed" k1 := k1u::K s1u := retractIfCan(a2)@Union(Symbol, "failed") s1u case "failed" => "failed" s1 := s1u::Symbol a1 := args.1 denom(a1) ~= 1 => error "Bad argument to rootOf" eq := univariate(numer(a1), k1) eqa : SUP(AN) := 0 while eq ~= 0 repeat cc := leadingCoefficient(eq)::% ccu := retractIfCan(cc)@Union(AN, "failed") ccu case "failed" => return "failed" eqa := eqa + monomial(ccu::AN, degree eq) eq := reductum eq rootOf(eqa, s1)$AN arg : List(AN) := empty() for x in argument k repeat if (a := retractIfCan(x)@Union(AN, "failed")) case "failed" then return "failed" else arg := concat(a::AN, arg) (operator(op)$AN) reverse!(arg) smp2an p == (x1 := mainVariable p) case "failed" => R2AN leadingCoefficient p up := univariate(p, k := x1::K) (t := k2an k) case "failed" => "failed" ans : AN := 0 while not ground? up repeat (c := smp2an leadingCoefficient up) case "failed" => return "failed" ans := ans + (c::AN) * (t::AN) ^ (degree up) up := reductum up (c := smp2an leadingCoefficient up) case "failed" => "failed" ans + c::AN if R has ConvertibleTo InputForm then convert(x : %) : InputForm == convert(x)$Rep import from MakeUnaryCompiledFunction(%, %, %) eval(f : %, op : BasicOperator, g : %, x : Symbol) : % == eval(f, [op], [g], x) eval(f : %, ls : List BasicOperator, lg : List %, x : Symbol) == -- handle subscripted symbols by renaming -> eval -- -> renaming back llsym : List List Symbol := [variables g for g in lg] lsym : List Symbol := removeDuplicates concat llsym lsd : List Symbol := select (scripted?, lsym) empty? lsd => eval(f, ls, [compiledFunction(g, x) for g in lg]) ns : List Symbol := [new()$Symbol for i in lsd] lforwardSubs : List Equation % := [(i::%)= (j::%) for i in lsd for j in ns] lbackwardSubs : List Equation % := [(j::%)= (i::%) for i in lsd for j in ns] nlg : List % := [subst(g, lforwardSubs) for g in lg] res : % := eval(f, ls, [compiledFunction(g, x) for g in nlg]) subst(res, lbackwardSubs) if R has PatternMatchable Integer then patternMatch(x : %, p : Pattern Integer, l : PatternMatchResult(Integer, %)) == patternMatch(x, p, l)$PatternMatchFunctionSpace(Integer, R, %) if R has PatternMatchable Float then patternMatch(x : %, p : Pattern Float, l : PatternMatchResult(Float, %)) == patternMatch(x, p, l)$PatternMatchFunctionSpace(Float, R, %) else -- ring R is not an integral domain Rep := MP 0 == 0$Rep 1 == 1$Rep - x : % == -$Rep x n : Integer *x : % == n *$Rep x x : % * y : % == x *$Rep y x : % + y : % == x +$Rep y x : % = y : % == x =$Rep y smaller?(x : %, y : %) == smaller?(x, y)$Rep numer x == x@Rep coerce(p : MP) : % == p coerce(p : Polynomial(R)) : % == poly_to_MP(p) pretend % reducedSystem(m : Matrix %) : Matrix(R) == reducedSystem(m)$Rep reducedSystem(m : Matrix %, v : Vector %): Record(mat : Matrix R, vec : Vector R) == reducedSystem(m, v)$Rep if R has ConvertibleTo InputForm then convert(x : %) : InputForm == convert(x)$Rep if R has PatternMatchable Integer then kintmatch : (K, Pattern Integer, PatternMatchResult(Integer, Rep)) -> PatternMatchResult(Integer, Rep) kintmatch(k, p, l) == patternMatch(k, p, l pretend PatternMatchResult(Integer, %) )$PatternMatchKernel(Integer, %) pretend PatternMatchResult(Integer, Rep) patternMatch(x : %, p : Pattern Integer, l : PatternMatchResult(Integer, %)) == patternMatch(x@Rep, p, l pretend PatternMatchResult(Integer, Rep), kintmatch )$PatternMatchPolynomialCategory(Integer, IndexedExponents K, K, R, Rep) pretend PatternMatchResult(Integer, %) if R has PatternMatchable Float then kfltmatch : (K, Pattern Float, PatternMatchResult(Float, Rep)) -> PatternMatchResult(Float, Rep) kfltmatch(k, p, l) == patternMatch(k, p, l pretend PatternMatchResult(Float, %) )$PatternMatchKernel(Float, %) pretend PatternMatchResult(Float, Rep) patternMatch(x : %, p : Pattern Float, l : PatternMatchResult(Float, %)) == patternMatch(x@Rep, p, l pretend PatternMatchResult(Float, Rep), kfltmatch )$PatternMatchPolynomialCategory(Float, IndexedExponents K, K, R, Rep) pretend PatternMatchResult(Float, %) else -- R is not even a ring if R has AbelianMonoid then import from ListToMap(K, %) kereval : (K, List K, List %) -> % subeval : (K, List K, List %) -> % Rep := FreeAbelianGroup K 0 == 0$Rep x : % + y : % == x +$Rep y x : % = y : % == x =$Rep y smaller?(x : %, y : %) == smaller?(x, y)$Rep coerce(k : K) : % == coerce(k)$Rep kernels(x : %) : List(K) == [f.gen for f in terms x] coerce(x : R) : % == (zero? x => 0; constantKernel(x)::%) retract(x : %) : R == (zero? x => 0; retNotUnit x) coerce(x : %) : OutputForm == coerce(x)$Rep kereval(k, lk, lv) == match(lk, lv, k, (x2 : K) : % +-> map(x1+->eval(x1, lk, lv), x2)) subeval(k, lk, lv) == match(lk, lv, k, (x : K) : % +-> kernel(operator x, [subst(a, lk, lv) for a in argument x])) isPlus x == empty?(l := terms x) or empty? rest l => "failed" [t.exp *$Rep t.gen for t in l]$List(%) isMult x == empty?(l := terms x) or not empty? rest l => "failed" t := first l [t.exp, t.gen] eval(x : %, lk : List K, lv : List %) == _+/[t.exp * kereval(t.gen, lk, lv) for t in terms x] subst(x : %, lk : List K, lv : List %) == _+/[t.exp * subeval(t.gen, lk, lv) for t in terms x] retractIfCan(x:%):Union(R, "failed") == zero? x => 0 retNotUnitIfCan x if R has AbelianGroup then -(x : %) == -$Rep x -- else -- R is not an AbelianMonoid -- if R has SemiGroup then -- Rep := FreeGroup K -- 1 == 1$Rep -- x: % * y: % == x *$Rep y -- x: % = y: % == x =$Rep y -- coerce(k: K): % == k::Rep -- kernels(x : %) : List(K) == [f.gen for f in factors x] -- coerce(x: R): % == (one? x => 1; constantKernel x) -- retract(x: %): R == (one? x => 1; retNotUnit x) -- coerce(x: %): OutputForm == coerce(x)$Rep -- retractIfCan(x:%):Union(R, "failed") == -- one? x => 1 -- retNotUnitIfCan x -- if R has Group then inv(x: %): % == inv(x)$Rep else -- R is nothing import from ListToMap(K, %) Rep := K smaller?(x : %, y : %) == smaller?(x, y)$Rep x : % = y : % == x =$Rep y coerce(k : K) : % == k kernels(x : %) : List(K) == [x pretend K] coerce(x : R) : % == constantKernel x retract(x : %) : R == retNotUnit x retractIfCan(x:%):Union(R, "failed") == retNotUnitIfCan x coerce(x : %) : OutputForm == coerce(x)$Rep eval(x : %, lk : List K, lv : List %) == match(lk, lv, x pretend K, (x1 : K) : % +-> map(x2+->eval(x2, lk, lv), x1)) subst(x, lk, lv) == match(lk, lv, x pretend K, (x1 : K) : % +-> kernel(operator x1, [subst(a, lk, lv) for a in argument x1])) if R has ConvertibleTo InputForm then convert(x : %) : InputForm == convert(x)$Rep -- if R has PatternMatchable Integer then -- convert(x: %): Pattern(Integer) == convert(x)$Rep -- -- patternMatch(x: %, p: Pattern Integer, -- l: PatternMatchResult(Integer, %)) == -- patternMatch(x pretend K, p, l)$PatternMatchKernel(Integer, %) -- -- if R has PatternMatchable Float then -- convert(x: %): Pattern(Float) == convert(x)$Rep -- -- patternMatch(x: %, p: Pattern Float, -- l: PatternMatchResult(Float, %)) == -- patternMatch(x pretend K, p, l)$PatternMatchKernel(Float, %) )abbrev package PAN2EXPR PolynomialAN2Expression ++ Author: Barry Trager ++ Date Created: 8 Oct 1991 ++ Description: This package provides a coerce from polynomials over ++ algebraic numbers to \spadtype{Expression AlgebraicNumber}. PolynomialAN2Expression() : Target == Implementation where EXPR ==> Expression(Integer) AN ==> AlgebraicNumber PAN ==> Polynomial AN SY ==> Symbol Target ==> with coerce : Polynomial AlgebraicNumber -> Expression(Integer) ++ coerce(p) converts the polynomial \spad{p} with algebraic number ++ coefficients to \spadtype{Expression Integer}. coerce : Fraction Polynomial AlgebraicNumber -> Expression(Integer) ++ coerce(rf) converts \spad{rf}, a fraction of polynomial \spad{p} with ++ algebraic number coefficients to \spadtype{Expression Integer}. Implementation ==> add coerce(p : PAN) : EXPR == map(x+->x::EXPR, x+->x::EXPR, p)$PolynomialCategoryLifting( IndexedExponents SY, SY, AN, PAN, EXPR) coerce(rf : Fraction PAN) : EXPR == numer(rf)::EXPR / denom(rf)::EXPR )abbrev package EXPR2 ExpressionFunctions2 ++ Lifting of maps to Expressions ++ Author: Manuel Bronstein ++ Description: Lifting of maps to Expressions. ++ Date Created: 16 Jan 1989 ++ Date Last Updated: 22 Jan 1990 ExpressionFunctions2(R : Comparable, S : Comparable): Exports == Implementation where K ==> Kernel R F2 ==> FunctionSpaceFunctions2(R, Expression R, S, Expression S) E2 ==> ExpressionSpaceFunctions2(Expression R, Expression S) Exports ==> with map : (R -> S, Expression R) -> Expression S ++ map(f, e) applies f to all the constants appearing in e. Implementation == add if S has Ring and R has Ring then map(f, r) == map(f, r)$F2 else map(f, r) == map(x+->map(f, x), retract r)$E2 )abbrev package PMPREDFS FunctionSpaceAttachPredicates ++ Predicates for pattern-matching. ++ Author: Manuel Bronstein ++ Description: Attaching predicates to symbols for pattern matching. ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. FunctionSpaceAttachPredicates(R, F, D) : Exports == Implementation where R : Comparable F : FunctionSpace R D : Type K ==> Kernel F Exports ==> with suchThat : (F, D -> Boolean) -> F ++ suchThat(x, foo) attaches the predicate foo to x; ++ error if x is not a symbol. suchThat : (F, List(D -> Boolean)) -> F ++ suchThat(x, [f1, f2, ..., fn]) attaches the predicate ++ f1 and f2 and ... and fn to x. ++ Error: if x is not a symbol. Implementation ==> add import from AnyFunctions1(D -> Boolean) PMPRED := '%pmpredicate st : (K, List Any) -> F preds : K -> List Any mkk : BasicOperator -> F suchThat(p : F, f : D -> Boolean) == suchThat(p, [f]) mkk op == kernel(op, empty()$List(F)) preds k == (u := property(operator k, PMPRED)) case "failed" => empty() (u::None) pretend List(Any) -- st(k, l) == -- mkk assert(setProperty(copy operator k, PMPRED, -- concat(preds k, l) pretend None), string(new()$Symbol)) -- Looks fishy, but we try to preserve meaning st(k, l) == kk := copy operator k setProperty(kk, PMPRED, concat(preds k, l) pretend None) kernel(kk, empty()$List(F)) suchThat(p : F, l : List(D -> Boolean)) == retractIfCan(p)@Union(Symbol, "failed") case Symbol => st(retract(p)@K, [f::Any for f in l]) error "suchThat must be applied to symbols only" )abbrev package PMASSFS FunctionSpaceAssertions ++ Assertions for pattern-matching ++ Author: Manuel Bronstein ++ Description: Attaching assertions to symbols for pattern matching; ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. FunctionSpaceAssertions(R, F) : Exports == Implementation where R : Comparable F : FunctionSpace R K ==> Kernel F PMOPT ==> '%pmoptional PMMULT ==> '%pmmultiple PMCONST ==> '%pmconstant Exports ==> with -- assert : (F, String) -> F -- ++ assert(x, s) makes the assertion s about x. -- ++ Error: if x is not a symbol. constant : F -> F ++ constant(x) tells the pattern matcher that x should ++ match only the symbol 'x and no other quantity. ++ Error: if x is not a symbol. optional : F -> F ++ optional(x) tells the pattern matcher that x can match ++ an identity (0 in a sum, 1 in a product or exponentiation). ++ Error: if x is not a symbol. multiple : F -> F ++ multiple(x) tells the pattern matcher that x should ++ preferably match a multi-term quantity in a sum or product. ++ For matching on lists, multiple(x) tells the pattern matcher ++ that x should match a list instead of an element of a list. ++ Error: if x is not a symbol. Implementation ==> add ass : (K, Symbol) -> F asst : (K, Symbol) -> F mkk : BasicOperator -> F mkk op == kernel(op, empty()$List(F)) ass(k, s) == has?(op := operator k, s) => k::F mkk assert(copy op, s) asst(k, s) == has?(op := operator k, s) => k::F mkk assert(op, s) -- assert(x, s) == -- retractIfCan(x)@Union(Symbol, "failed") case Symbol => -- asst(retract(x)@K, s) -- error "assert must be applied to symbols only" constant x == retractIfCan(x)@Union(Symbol, "failed") case Symbol => ass(retract(x)@K, PMCONST) error "constant must be applied to symbols only" optional x == retractIfCan(x)@Union(Symbol, "failed") case Symbol => ass(retract(x)@K, PMOPT) error "optional must be applied to symbols only" multiple x == retractIfCan(x)@Union(Symbol, "failed") case Symbol => ass(retract(x)@K, PMMULT) error "multiple must be applied to symbols only" )abbrev package PMPRED AttachPredicates ++ Predicates for pattern-matching, unused ++ Author: Manuel Bronstein ++ Description: Attaching predicates to symbols for pattern matching. ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. AttachPredicates(D : Type) : Exports == Implementation where FE ==> Expression Integer Exports ==> with suchThat : (Symbol, D -> Boolean) -> FE ++ suchThat(x, foo) attaches the predicate foo to x. suchThat : (Symbol, List(D -> Boolean)) -> FE ++ suchThat(x, [f1, f2, ..., fn]) attaches the predicate ++ f1 and f2 and ... and fn to x. Implementation ==> add import from FunctionSpaceAttachPredicates(Integer, FE, D) suchThat(p : Symbol, f : D -> Boolean) == suchThat(p::FE, f) suchThat(p : Symbol, l : List(D -> Boolean)) == suchThat(p::FE, l) )abbrev package PMASS PatternMatchAssertions ++ Assertions for pattern-matching, unused ++ Author: Manuel Bronstein ++ Description: Attaching assertions to symbols for pattern matching. ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. PatternMatchAssertions() : Exports == Implementation where FE ==> Expression Integer Exports ==> with -- assert : (Symbol, String) -> FE -- ++ assert(x, s) makes the assertion s about x. constant : Symbol -> FE ++ constant(x) tells the pattern matcher that x should ++ match only the symbol 'x and no other quantity. optional : Symbol -> FE ++ optional(x) tells the pattern matcher that x can match ++ an identity (0 in a sum, 1 in a product or exponentiation).; multiple : Symbol -> FE ++ multiple(x) tells the pattern matcher that x should ++ preferably match a multi-term quantity in a sum or product. ++ For matching on lists, multiple(x) tells the pattern matcher ++ that x should match a list instead of an element of a list. Implementation ==> add import from FunctionSpaceAssertions(Integer, FE) constant x == constant(x::FE) multiple x == multiple(x::FE) optional x == optional(x::FE) -- assert(x, s) == assert(x::FE, s) )abbrev domain HACKPI Pi ++ Expressions in %pi only ++ Author: Manuel Bronstein ++ Description: ++ Symbolic fractions in %pi with integer coefficients; ++ The point for using Pi as the default domain for those fractions ++ is that Pi is coercible to the float types, and not Expression. ++ Date Created: 21 Feb 1990 ++ Date Last Updated: 12 Mai 1992 Pi() : Exports == Implementation where PZ ==> Polynomial Integer UP ==> SparseUnivariatePolynomial Integer RF ==> Fraction UP Exports ==> Join(Field, CharacteristicZero, RetractableTo Integer, RetractableTo Fraction Integer, RealConstant, CoercibleTo DoubleFloat, CoercibleTo Float, ConvertibleTo RF, ConvertibleTo InputForm) with pi : () -> % ++ pi() returns the symbolic %pi. Implementation ==> RF add Rep := RF sympi := '%pi p2sf : UP -> DoubleFloat p2f : UP -> Float p2o : UP -> OutputForm p2i : UP -> InputForm p2p : UP -> PZ pi() == (monomial(1, 1)$UP :: RF) pretend % convert(x : %) : RF == x pretend RF convert(x : %) : Float == x::Float convert(x : %) : DoubleFloat == x::DoubleFloat coerce(x : %) : DoubleFloat == p2sf(numer x) / p2sf(denom x) coerce(x : %) : Float == p2f(numer x) / p2f(denom x) p2o p == outputForm(p, sympi::OutputForm) p2i p == convert p2p p p2p p == ans : PZ := 0 while p ~= 0 repeat ans := ans + monomial(leadingCoefficient(p)::PZ, sympi, degree p) p := reductum p ans coerce(x : %) : OutputForm == (r := retractIfCan(x)@Union(UP, "failed")) case UP => p2o(r::UP) p2o(numer x) / p2o(denom x) convert(x : %) : InputForm == (r := retractIfCan(x)@Union(UP, "failed")) case UP => p2i(r::UP) p2i(numer x) / p2i(denom x) p2sf p == map((x : Integer) : DoubleFloat+->x::DoubleFloat, p)$SparseUnivariatePolynomialFunctions2(Integer, DoubleFloat) (pi()$DoubleFloat) p2f p == map((x : Integer) : Float+->x::Float, p)$SparseUnivariatePolynomialFunctions2(Integer, Float) (pi()$Float) )abbrev package PICOERCE PiCoercions ++ Coercions from %pi to symbolic or numeric domains ++ Author: Manuel Bronstein ++ Description: ++ Provides a coercion from the symbolic fractions in %pi with ++ integer coefficients to any Expression type. ++ Date Created: 21 Feb 1990 ++ Date Last Updated: 21 Feb 1990 PiCoercions(R : Join(Comparable, IntegralDomain)) : with coerce : Pi -> Expression R ++ coerce(f) returns f as an Expression(R). == add p2e : SparseUnivariatePolynomial Integer -> Expression R coerce(x : Pi) : Expression(R) == f := convert(x)@Fraction(SparseUnivariatePolynomial Integer) p2e(numer f) / p2e(denom f) p2e p == map((x1 : Integer) : Expression(R)+->x1::Expression(R), p)$SparseUnivariatePolynomialFunctions2(Integer, Expression R) (pi()$Expression(R)) )abbrev package ELINSOL ExpressionLinearSolve ++ Author: Waldek Hebisch ++ Description: Solver for linear systems represented as list ++ of expressions. More efficient than using solve because ++ it does not check that system really is linear. ExpressionLinearSolve(R : Join(IntegralDomain, Comparable), F : FunctionSpace(R)) : Exports == Implementation where K ==> Kernel(F) MP ==> SparseMultivariatePolynomial(R, K) Exports ==> with lin_sol : (List(F), List Symbol) -> Union(List(F), "failed") ++ lin_sol(eql, vl) solves system of equations eql for ++ variables in vl. Equations must be linear in variables ++ from vl. Implementation ==> add lin_coeff(x : MP, v : K) : F == ux := univariate(x, v) d := degree(ux) d < 1 => 0 d > 1 => error "lin_coeff: x is nonlinear" leadingCoefficient(ux)::F -- works only if numer(x) is linear in v from vl F_to_LF(x : F, vl : List(K)) : List(F) == nx := numer(x) res0 := [lin_coeff(nx, v) for v in vl] ml := [numer(c)*monomial(1, v, 1)$MP for v in vl for c in res0] nx1 := reduce(_+, ml, 0) nx0 := nx - nx1 reduce(max, [degree(nx0, v) for v in vl]@List(Integer)) > 0 => error "x is nonlinear in vl" cons(nx0::F, res0) lin_sol(eql : List(F), vl : List Symbol) : Union(List(F), "failed") == coefk := [retract(c::F)@K for c in vl] eqll := [F_to_LF(p, coefk) for p in eql] rh : Vector(F) := -vector([first(ll) for ll in eqll])$Vector(F) eqm := matrix([rest(ll) for ll in eqll])$Matrix(F) ss := solve(eqm, rh)$LinearSystemMatrixPackage1(F) ss.particular case "failed" => "failed" parts((ss.particular)::Vector(F)) --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. --All rights reserved. -- --Redistribution and use in source and binary forms, with or without --modification, are permitted provided that the following conditions are --met: -- -- - Redistributions of source code must retain the above copyright -- notice, this list of conditions and the following disclaimer. -- -- - Redistributions in binary form must reproduce the above copyright -- notice, this list of conditions and the following disclaimer in -- the documentation and/or other materials provided with the -- distribution. -- -- - Neither the name of The Numerical ALgorithms Group Ltd. nor the -- names of its contributors may be used to endorse or promote products -- derived from this software without specific prior written permission. -- --THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS --IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED --TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A --PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER --OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, --EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, --PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -- SPAD files for the functional world should be compiled in the -- following order: -- -- op kl fspace algfunc elemntry combfunc EXPR spad Compiling FriCAS source code from file /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/8559392771214273401-25px001.spad using old system compiler. EXPR abbreviates domain Expression ------------------------------------------------------------------------ initializing NRLIB EXPR for Expression compiling into NRLIB EXPR importing KernelFunctions2(R,$) compiling exported belong? : BasicOperator -> Boolean EXPR;belong?;BoB;1 is replaced by QUOTET Time: 0.11 SEC. compiling local retNotUnit : $-> R Time: 0 SEC. compiling local retNotUnitIfCan :$ -> Union(R,failed) Time: 0 SEC. ****** Domain: R already in scope augmenting R: (IntegralDomain) compiling exported operator : BasicOperator -> BasicOperator Time: 0.01 SEC. processing macro definition SPCH ==> SparsePolynomialCoercionHelpers(R,Symbol,Kernel $) ****** Domain: R already in scope augmenting R: (Ring) compiling local poly_to_MP : Polynomial R -> SparseMultivariatePolynomial(R,Kernel$) Time: 0.02 SEC. ****** Domain: R already in scope augmenting R: (IntegralDomain) compiling exported Zero : () -> $Time: 0.03 SEC. compiling exported One : () ->$ Time: 0 SEC. compiling exported one? : $-> Boolean Time: 0 SEC. compiling exported zero? :$ -> Boolean Time: 0 SEC. compiling exported - : $->$ Time: 0 SEC. compiling exported * : (Integer,$) ->$ Time: 0 SEC. compiling exported coerce : Integer -> $Time: 0 SEC. compiling exported * : ($,$) ->$ Time: 0.01 SEC. compiling exported + : ($,$) -> $Time: 0 SEC. compiling exported - : ($,$) ->$ Time: 0 SEC. compiling exported / : ($,$) -> $Time: 0.01 SEC. compiling exported number? :$ -> Boolean ****** Domain: R already in scope augmenting R: (RetractableTo (Integer)) Time: 0 SEC. compiling exported simplifyPower : ($,Integer) ->$ Time: 0.24 SEC. compiling exported ^ : ($,NonNegativeInteger) ->$ Time: 0.01 SEC. compiling exported ^ : ($,Integer) ->$ Time: 0.01 SEC. compiling exported ^ : ($,PositiveInteger) ->$ Time: 0.01 SEC. compiling exported smaller? : ($,$) -> Boolean Time: 0 SEC. compiling exported = : ($,$) -> Boolean Time: 0 SEC. compiling exported numer : $-> SparseMultivariatePolynomial(R,Kernel$) Time: 0 SEC. compiling exported denom : $-> SparseMultivariatePolynomial(R,Kernel$) Time: 0 SEC. compiling exported coerce : SparseMultivariatePolynomial(R,Kernel $) ->$ Time: 0 SEC. compiling exported coerce : Polynomial R -> $Time: 0.01 SEC. compiling exported coerce : Fraction Polynomial R ->$ Time: 0.02 SEC. compiling exported reduce : $->$ Time: 0 SEC. compiling local commonk : ($,$) -> List Kernel $Time: 0.01 SEC. compiling local algkernels : List Kernel$ -> List Kernel $Time: 0 SEC. compiling local toprat :$ -> $Time: 0.01 SEC. compiling local simple_root : Kernel$ -> Boolean Time: 0.02 SEC. compiling local root_reduce : ($,Kernel$) -> $Time: 3.22 SEC. compiling exported getSimplifyDenomsFlag : () -> Boolean EXPR;getSimplifyDenomsFlag;B;35 is replaced by algreduc_flag Time: 0.01 SEC. compiling exported setSimplifyDenomsFlag : Boolean -> Boolean Time: 0 SEC. compiling local algreduc : ($,List Kernel $) ->$ Time: 0.04 SEC. compiling exported / : (SparseMultivariatePolynomial(R,Kernel $),SparseMultivariatePolynomial(R,Kernel$)) -> $Time: 0.02 SEC. compiling exported reducedSystem : Matrix$ -> Matrix R Time: 0.01 SEC. compiling exported reducedSystem : (Matrix $,Vector$) -> Record(mat: Matrix R,vec: Vector R) Time: 0.02 SEC. compiling local commonk0 : (List Kernel $,List Kernel$) -> List Kernel $Time: 0.01 SEC. compiling exported rootOf : (SparseUnivariatePolynomial$,Symbol) -> $Time: 0.01 SEC. compiling exported rootSum : ($,SparseUnivariatePolynomial $,Symbol) ->$ Time: 0 SEC. compiling exported pi : () -> $Time: 0.01 SEC. compiling exported exp :$ -> $Time: 0 SEC. compiling exported log :$ -> $Time: 0 SEC. compiling exported sin :$ -> $Time: 0 SEC. compiling exported cos :$ -> $Time: 0 SEC. compiling exported tan :$ -> $Time: 0 SEC. compiling exported cot :$ -> $Time: 0 SEC. compiling exported sec :$ -> $Time: 0 SEC. compiling exported csc :$ -> $Time: 0 SEC. compiling exported asin :$ -> $Time: 0.01 SEC. compiling exported acos :$ -> $Time: 0 SEC. compiling exported atan :$ -> $Time: 0 SEC. compiling exported acot :$ -> $Time: 0 SEC. compiling exported asec :$ -> $Time: 0 SEC. compiling exported acsc :$ -> $Time: 0 SEC. compiling exported sinh :$ -> $Time: 0.01 SEC. compiling exported cosh :$ -> $Time: 0 SEC. compiling exported tanh :$ -> $Time: 0 SEC. compiling exported coth :$ -> $Time: 0 SEC. compiling exported sech :$ -> $Time: 0 SEC. compiling exported csch :$ -> $Time: 0 SEC. compiling exported asinh :$ -> $Time: 0 SEC. compiling exported acosh :$ -> $Time: 0 SEC. compiling exported atanh :$ -> $Time: 0 SEC. compiling exported acoth :$ -> $Time: 0 SEC. compiling exported asech :$ -> $Time: 0 SEC. compiling exported acsch :$ -> $Time: 0 SEC. compiling exported abs :$ -> $Time: 0 SEC. compiling exported conjugate :$ -> $Time: 0.01 SEC. compiling exported Gamma :$ -> $Time: 0 SEC. compiling exported Gamma : ($,$) ->$ Time: 0 SEC. compiling exported Beta : ($,$) -> $Time: 0 SEC. compiling exported digamma :$ -> $Time: 0 SEC. compiling exported polygamma : ($,$) ->$ Time: 0 SEC. compiling exported besselJ : ($,$) -> $Time: 0 SEC. compiling exported besselY : ($,$) ->$ Time: 0 SEC. compiling exported besselI : ($,$) -> $Time: 0.01 SEC. compiling exported besselK : ($,$) ->$ Time: 0 SEC. compiling exported airyAi : $->$ Time: 0 SEC. compiling exported airyAiPrime : $->$ Time: 0 SEC. compiling exported airyBi : $->$ Time: 0 SEC. compiling exported airyBiPrime : $->$ Time: 0.01 SEC. compiling exported lambertW : $->$ Time: 0 SEC. compiling exported polylog : ($,$) -> $Time: 0 SEC. compiling exported weierstrassP : ($,$,$) -> $Time: 0 SEC. compiling exported weierstrassPPrime : ($,$,$) -> $Time: 0 SEC. compiling exported weierstrassSigma : ($,$,$) -> $Time: 0 SEC. compiling exported weierstrassZeta : ($,$,$) -> $Time: 0 SEC. compiling exported whittakerM : ($,$,$) -> $Time: 0.01 SEC. compiling exported whittakerW : ($,$,$) -> $Time: 0 SEC. compiling exported angerJ : ($,$) ->$ Time: 0 SEC. compiling exported weberE : ($,$) -> $Time: 0 SEC. compiling exported struveH : ($,$) ->$ Time: 0 SEC. compiling exported struveL : ($,$) -> $Time: 0 SEC. compiling exported hankelH1 : ($,$) ->$ Time: 0 SEC. compiling exported hankelH2 : ($,$) -> $Time: 0 SEC. compiling exported lommelS1 : ($,$,$) -> $Time: 0 SEC. compiling exported lommelS2 : ($,$,$) -> $Time: 0 SEC. compiling exported kummerM : ($,$,$) -> $Time: 0 SEC. compiling exported kummerU : ($,$,$) -> $Time: 0.01 SEC. compiling exported legendreP : ($,$,$) -> $Time: 0 SEC. compiling exported legendreQ : ($,$,$) -> $Time: 0 SEC. compiling exported kelvinBei : ($,$) ->$ Time: 0 SEC. compiling exported kelvinBer : ($,$) -> $Time: 0.01 SEC. compiling exported kelvinKei : ($,$) ->$ Time: 0 SEC. compiling exported kelvinKer : ($,$) -> $Time: 0 SEC. compiling exported ellipticK :$ -> $Time: 0 SEC. compiling exported ellipticE :$ -> $Time: 0 SEC. compiling exported ellipticE : ($,$) ->$ Time: 0 SEC. compiling exported ellipticF : ($,$) -> $Time: 0 SEC. compiling exported ellipticPi : ($,$,$) -> $Time: 0 SEC. compiling exported jacobiSn : ($,$) ->$ Time: 0 SEC. compiling exported jacobiCn : ($,$) -> $Time: 0.01 SEC. compiling exported jacobiDn : ($,$) ->$ Time: 0 SEC. compiling exported jacobiZeta : ($,$) -> $Time: 0 SEC. compiling exported jacobiTheta : ($,$) ->$ Time: 0 SEC. compiling exported lerchPhi : ($,$,$) ->$ Time: 0 SEC. compiling exported riemannZeta : $->$ Time: 0.01 SEC. compiling exported charlierC : ($,$,$) ->$ Time: 0 SEC. compiling exported hermiteH : ($,$) -> $Time: 0 SEC. compiling exported jacobiP : ($,$,$,$) ->$ Time: 0 SEC. compiling exported laguerreL : ($,$,$) ->$ Time: 0 SEC. compiling exported meixnerM : ($,$,$,$) -> $Time: 0 SEC. ****** Domain:$ already in scope augmenting $: (RetractableTo (Integer)) compiling exported hypergeometricF : (List$,List $,$) -> $Time: 0.04 SEC. compiling exported meijerG : (List$,List $,List$,List $,$) -> $Time: 0.01 SEC. compiling exported ^ : ($,$) ->$ Time: 0 SEC. compiling exported factorial : $->$ Time: 0 SEC. compiling exported binomial : ($,$) -> $Time: 0 SEC. compiling exported permutation : ($,$) ->$ Time: 0 SEC. compiling exported factorials : $->$ Time: 0 SEC. compiling exported factorials : ($,Symbol) ->$ Time: 0 SEC. compiling exported summation : ($,Symbol) ->$ Time: 0 SEC. compiling exported summation : ($,SegmentBinding$) -> $Time: 0 SEC. compiling exported product : ($,Symbol) -> $Time: 0.01 SEC. compiling exported product : ($,SegmentBinding $) ->$ Time: 0 SEC. compiling exported erf : $->$ Time: 0.01 SEC. compiling exported erfi : $->$ Time: 0.01 SEC. compiling exported Ei : $->$ Time: 0 SEC. compiling exported Si : $->$ Time: 0 SEC. compiling exported Ci : $->$ Time: 0 SEC. compiling exported Shi : $->$ Time: 0 SEC. compiling exported Chi : $->$ Time: 0 SEC. compiling exported li : $->$ Time: 0 SEC. compiling exported dilog : $->$ Time: 0 SEC. compiling exported fresnelS : $->$ Time: 0 SEC. compiling exported fresnelC : $->$ Time: 0 SEC. compiling exported integral : ($,Symbol) ->$ Time: 0 SEC. compiling exported integral : ($,SegmentBinding$) -> $Time: 0 SEC. compiling exported operator : BasicOperator -> BasicOperator Time: 0.01 SEC. compiling local reduc : ($,List Kernel $) ->$ Time: 0.01 SEC. compiling local evl0 : (SparseMultivariatePolynomial(R,Kernel $),Kernel$) -> SparseUnivariatePolynomial Fraction SparseMultivariatePolynomial(R,Kernel $) Time: 0.05 SEC. compiling local evl : (SparseMultivariatePolynomial(R,Kernel$),Kernel $,SparseUnivariatePolynomial$) -> Fraction SparseMultivariatePolynomial(R,Kernel $) Time: 0.10 SEC. ****** Domain: R already in scope augmenting R: (GcdDomain) compiling local noalg? : SparseUnivariatePolynomial$ -> Boolean Time: 0.03 SEC. compiling exported gcdPolynomial : (SparseUnivariatePolynomial $,SparseUnivariatePolynomial$) -> SparseUnivariatePolynomial $Time: 0.01 SEC. compiling exported factorPolynomial : SparseUnivariatePolynomial$ -> Factored SparseUnivariatePolynomial $Semantic Errors: [1] factorPolynomial: SupFractionFactorizer is not a known type Warnings: [1] retNotUnit: $$has no value [2] poly_to_MP:$$ has no value [3] simplifyPower: $$has no value [4] algreduc:$$ has no value [5] reducedSystem: $$has no value [6] reducedSystem: mat has no value [7] reducedSystem: vec has no value [8] pi: not known that (RadicalCategory) is of mode (CATEGORY domain (IF (has R (IntegralDomain)) (PROGN (ATTRIBUTE (AlgebraicallyClosedFunctionSpace R)) (ATTRIBUTE (TranscendentalFunctionCategory)) (ATTRIBUTE (CombinatorialOpsCategory)) (ATTRIBUTE (LiouvillianFunctionCategory)) (ATTRIBUTE (SpecialFunctionCategory)) (SIGNATURE reduce ( )) (SIGNATURE number? ((Boolean) )) (SIGNATURE simplifyPower ( (Integer))) (IF (has R (GcdDomain)) (PROGN (SIGNATURE factorPolynomial ((Factored (SparseUnivariatePolynomial )) (SparseUnivariatePolynomial ))) (SIGNATURE squareFreePolynomial ((Factored (SparseUnivariatePolynomial )) (SparseUnivariatePolynomial )))) noBranch) (IF (has R (RetractableTo (Integer))) (ATTRIBUTE (RetractableTo (AlgebraicNumber))) noBranch) (SIGNATURE setSimplifyDenomsFlag ((Boolean) (Boolean))) (SIGNATURE getSimplifyDenomsFlag ((Boolean)))) noBranch)) [9] summation:$$ has no value [10] erf: not known that (RadicalCategory) is of mode (CATEGORY domain (IF (has R (IntegralDomain)) (PROGN (ATTRIBUTE (AlgebraicallyClosedFunctionSpace R)) (ATTRIBUTE (TranscendentalFunctionCategory)) (ATTRIBUTE (CombinatorialOpsCategory)) (ATTRIBUTE (LiouvillianFunctionCategory)) (ATTRIBUTE (SpecialFunctionCategory)) (SIGNATURE reduce ($ $)) (SIGNATURE number? ((Boolean)$)) (SIGNATURE simplifyPower ( (Integer))) (IF (has R (GcdDomain)) (PROGN (SIGNATURE factorPolynomial ((Factored (SparseUnivariatePolynomial $)) (SparseUnivariatePolynomial$))) (SIGNATURE squareFreePolynomial ((Factored (SparseUnivariatePolynomial $)) (SparseUnivariatePolynomial$)))) noBranch) (IF (has R (RetractableTo (Integer))) (ATTRIBUTE (RetractableTo (AlgebraicNumber))) noBranch) (SIGNATURE setSimplifyDenomsFlag ((Boolean) (Boolean))) (SIGNATURE getSimplifyDenomsFlag ((Boolean)))) noBranch)) [11] erf: not known that (TranscendentalFunctionCategory) is of mode (CATEGORY domain (IF (has R (IntegralDomain)) (PROGN (ATTRIBUTE (AlgebraicallyClosedFunctionSpace R)) (ATTRIBUTE (TranscendentalFunctionCategory)) (ATTRIBUTE (CombinatorialOpsCategory)) (ATTRIBUTE (LiouvillianFunctionCategory)) (ATTRIBUTE (SpecialFunctionCategory)) (SIGNATURE reduce ()) (SIGNATURE number? ((Boolean) $)) (SIGNATURE simplifyPower ($ $(Integer))) (IF (has R (GcdDomain)) (PROGN (SIGNATURE factorPolynomial ((Factored (SparseUnivariatePolynomial$)) (SparseUnivariatePolynomial $))) (SIGNATURE squareFreePolynomial ((Factored (SparseUnivariatePolynomial$)) (SparseUnivariatePolynomial $)))) noBranch) (IF (has R (RetractableTo (Integer))) (ATTRIBUTE (RetractableTo (AlgebraicNumber))) noBranch) (SIGNATURE setSimplifyDenomsFlag ((Boolean) (Boolean))) (SIGNATURE getSimplifyDenomsFlag ((Boolean)))) noBranch)) [12] evl0: $$has no value ****** comp fails at level 3 with expression: ****** error in function factorPolynomial (SEQ (|:=| |uf| | << | ((|Sel| (|SupFractionFactorizer| (|IndexedExponents| (|Kernel| )) (|Kernel| ) R (|SparseMultivariatePolynomial| R (|Kernel| ))) |factor|) (|pretend| |x| (|SparseUnivariatePolynomial| |Rep|))) | >> |) (|exit| 1 (|pretend| |uf| (|Factored| (|SparseUnivariatePolynomial| ))))) ****** level 3 ****** x:= ((Sel (SupFractionFactorizer (IndexedExponents (Kernel )) (Kernel ) R (SparseMultivariatePolynomial R (Kernel ))) factor) (pretend x (SparseUnivariatePolynomial Rep))) m:= EmptyMode f:= (((($$ #) (|x| # #) (* #) (+ #) ...) ((|root_reduce| #) (|simple_root| #)) ((|simple_root| #) (|copy| #) (|setelt!| #) (|den| #) ...) ((|poly_to_MP| #) (* #) (+ #) (- #) ...))) >> Apparent user error: Cannot coerce x of mode (SparseUnivariatePolynomial$) to mode (SparseUnivariatePolynomial Rep)

 Subject:   Be Bold !! ( 15 subscribers )