login  home  contents  what's new  discussion  bug reports help  links  subscribe  changes  refresh  edit

)abbrev domain RR Real
++ ===================================
++ THE REAL LINE MODELLED AS EXPR(INT)
++ ===================================
++ Modified version of Expression R
++ 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.
Real : Exports == Implementation where
R   ==> Integer
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.
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)
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
algtower  : % -> 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           == (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, %)
alg_ker_set(x : %) : List(K) ==
resl : List(K) := []
ak1 : List(K) := []
for k in kernels x repeat
not(is?(k, 'nthRoot) or is?(k, 'rootOf)) => "iterate"
ak1 := cons(k, ak1)
while not(empty?(ak1)) repeat
ak := ak1
ak1 := []
for k in ak repeat
needed := true
for k1 in resl while needed repeat
if EQ(k1, k)$Lisp then needed := false for k1 in resl while needed repeat if k1 = k then needed := false not(needed) => "iterate" resl := cons(k, resl) ak1 := cons(k, ak1) arg := argument(k) for k1 in kernels(arg.1) repeat if (is?(k1, 'nthRoot) or is?(k1, 'rootOf)) then ak1 := cons(k1, ak1) resl algtower(x : %) : List K == reverse!(sort! alg_ker_set(x)) 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 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 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 =>
eq := univariate(numer(a1), k1)
eqa : SUP(AN) := 0
while eq ~= 0 repeat
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" =>
up := univariate(p, k := x1::K)
(t  := k2an k) case "failed" => "failed"
ans : AN := 0
while not ground? up repeat
case "failed" => return "failed"
ans := ans + (c::AN) * (t::AN) ^ (degree up)
up  := reductum 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, %) )abbrev domain RSPACE RealSpace ++ Author: kfp ++ Date Created: Thu Nov 06 03:51:56 CET 2014 ++ License: BSD (same as Axiom) ++ Date Last Updated: ++ Basic Operations: ++ Related Domains: ++ Also See: ++ AMS Classifications: ++ Keywords: ++ Examples: ++ References: ++ ++ Description: ++ ++ RealSpace(n) : Exports == Implementation where NNI ==> NonNegativeInteger PI ==> PositiveInteger I ==> Integer R ==> Real n:NNI Exports == Join(CoercibleTo OutputForm, ConvertibleTo String) with coerce : % -> OutputForm coerce : List R -> % coerce : R -> % dot : (%,%) -> R dim : % -> NNI "+" : (%,%) -> % "-" : (%,%) -> % "*" : (R,%) -> % "*" : (NNI,%) -> % "*" : (PI,%) -> % "*" : (I,%) -> % "/" : (%,R) -> % "#" : % -> NNI "-" : % -> % "=" : (%,%) -> Boolean "~=": (%,%) -> Boolean unitVector : PI -> % elt : (%,I) -> R eval: (%, Equation R) -> % eval: (%, List Equation R) -> % every?: (R -> Boolean, %) -> Boolean map: (R -> R, %) -> % -- strange, to check member?: (R, %) -> Boolean any?: (R -> Boolean, %) -> Boolean copy: % -> % D: (%, Symbol) -> % D: (%, Symbol, NonNegativeInteger) -> % D: (%, List Symbol) -> % D: (%, List Symbol, List NonNegativeInteger) -> % dist : (%,%) -> R Implementation == DirectProduct(n,R) add Rep := DirectProduct(n,R) coerce(l:List R):% == #l=n => directProduct((vector l)::Vector(R))$Rep
coerce(x:R):% == x*unitVector(1)$Rep if n=1 then coerce(x:%):OutputForm == elt(x,1)::OutputForm dim(x:%):NNI == n dist(x:%,y:%):R == sqrt dot(x-y,x-y) spad  Compiling FriCAS source code from file /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/5840138844114655499-25px001.spad using old system compiler. RR abbreviates domain Real ------------------------------------------------------------------------ initializing NRLIB RR for Real compiling into NRLIB RR importing KernelFunctions2(Integer,$)
compiling exported belong? : BasicOperator -> Boolean
RR;belong?;BoB;1 is replaced by QUOTET
Time: 0.06 SEC.
compiling local retNotUnit : $-> Integer Time: 0 SEC. compiling local retNotUnitIfCan :$ -> Union(Integer,failed)
Time: 0 SEC.
processing macro definition SPCH ==> SparsePolynomialCoercionHelpers(Integer,Symbol,Kernel $) compiling local poly_to_MP : Polynomial Integer -> SparseMultivariatePolynomial(Integer,Kernel$)
Time: 0.01 SEC.
compiling exported Zero : () -> $Time: 0.01 SEC. compiling exported One : () ->$
Time: 0 SEC.
compiling exported one? : $-> Boolean Time: 0.01 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 SEC.
compiling exported + : ($,$) -> $Time: 0 SEC. compiling exported - : ($,$) ->$
Time: 0 SEC.
compiling exported / : ($,$) -> $Time: 0.01 SEC. compiling exported number? :$ -> Boolean
Time: 0 SEC.
compiling exported simplifyPower : ($,Integer) ->$
Time: 0.06 SEC.
compiling exported ^ : ($,NonNegativeInteger) ->$
Time: 0 SEC.
compiling exported ^ : ($,Integer) ->$
Time: 0.01 SEC.
compiling exported ^ : ($,PositiveInteger) ->$
Time: 0 SEC.
compiling exported smaller? : ($,$) -> Boolean
Time: 0 SEC.
compiling exported = : ($,$) -> Boolean
Time: 0.01 SEC.
compiling exported numer : $-> SparseMultivariatePolynomial(Integer,Kernel$)
Time: 0 SEC.
compiling exported denom : $-> SparseMultivariatePolynomial(Integer,Kernel$)
Time: 0 SEC.
compiling exported coerce : SparseMultivariatePolynomial(Integer,Kernel $) ->$
Time: 0 SEC.
compiling exported coerce : Polynomial Integer -> $Time: 0.01 SEC. compiling exported coerce : Fraction Polynomial Integer ->$
Time: 0 SEC.
compiling exported reduce : $->$
Time: 0 SEC.
compiling local commonk : ($,$) -> List Kernel $Time: 0 SEC. compiling local algkernels : List Kernel$ -> List Kernel $Time: 0.01 SEC. compiling local toprat :$ -> $Time: 0 SEC. compiling local alg_ker_set :$ -> List Kernel $Time: 0.01 SEC. compiling local algtower :$ -> List Kernel $Time: 0 SEC. compiling local simple_root : Kernel$ -> Boolean
Time: 0.01 SEC.
compiling local root_reduce : ($,Kernel$) -> $Time: 0.84 SEC. compiling exported getSimplifyDenomsFlag : () -> Boolean RR;getSimplifyDenomsFlag;B;36 is replaced by algreduc_flag Time: 0 SEC. compiling exported setSimplifyDenomsFlag : Boolean -> Boolean Time: 0 SEC. compiling local algreduc : ($,List Kernel $) ->$
Time: 0.02 SEC.
compiling exported / : (SparseMultivariatePolynomial(Integer,Kernel $),SparseMultivariatePolynomial(Integer,Kernel$)) -> $Time: 0 SEC. compiling exported reducedSystem : Matrix$ -> Matrix Integer
Time: 0.02 SEC.
compiling exported reducedSystem : (Matrix $,Vector$) -> Record(mat: Matrix Integer,vec: Vector Integer)
Time: 0.01 SEC.
compiling local commonk0 : (List Kernel $,List Kernel$) -> List Kernel $Time: 0 SEC. compiling exported rootOf : (SparseUnivariatePolynomial$,Symbol) -> $Time: 0 SEC. compiling exported rootSum : ($,SparseUnivariatePolynomial $,Symbol) ->$
Time: 0 SEC.
compiling exported pi : () -> $Time: 0 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 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.01 SEC. compiling exported sinh :$ -> $Time: 0 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.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.01 SEC.
compiling exported besselI : ($,$) -> $Time: 0 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 SEC.
compiling exported lambertW : $->$
Time: 0 SEC.
compiling exported polylog : ($,$) -> $Time: 0 SEC. compiling exported weierstrassP : ($,$,$) -> $Time: 0.01 SEC. compiling exported weierstrassPPrime : ($,$,$) -> $Time: 0 SEC. compiling exported weierstrassSigma : ($,$,$) -> $Time: 0 SEC. compiling exported weierstrassZeta : ($,$,$) -> $Time: 0 SEC. compiling exported whittakerM : ($,$,$) -> $Time: 0 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.01 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 SEC. compiling exported legendreP : ($,$,$) -> $Time: 0 SEC. compiling exported legendreQ : ($,$,$) -> $Time: 0 SEC. compiling exported kelvinBei : ($,$) ->$
Time: 0.01 SEC.
compiling exported kelvinBer : ($,$) -> $Time: 0 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.01 SEC. compiling exported jacobiSn : ($,$) ->$
Time: 0 SEC.
compiling exported jacobiCn : ($,$) -> $Time: 0 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 SEC.
compiling exported charlierC : ($,$,$) ->$
Time: 0.01 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. compiling exported hypergeometricF : (List$,List $,$) -> $Time: 0.03 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.01 SEC. compiling exported product : ($,Symbol) -> $Time: 0 SEC. compiling exported product : ($,SegmentBinding $) ->$
Time: 0 SEC.
compiling exported erf : $->$
Time: 0 SEC.
compiling exported erfi : $->$
Time: 0 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.01 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.02 SEC.
compiling local evl0 : (SparseMultivariatePolynomial(Integer,Kernel $),Kernel$) -> SparseUnivariatePolynomial Fraction SparseMultivariatePolynomial(Integer,Kernel $) Time: 0.01 SEC. compiling local evl : (SparseMultivariatePolynomial(Integer,Kernel$),Kernel $,SparseUnivariatePolynomial$) -> Fraction SparseMultivariatePolynomial(Integer,Kernel $) Time: 0.07 SEC. compiling local noalg? : SparseUnivariatePolynomial$ -> Boolean
Time: 0 SEC.
compiling exported gcdPolynomial : (SparseUnivariatePolynomial $,SparseUnivariatePolynomial$) -> SparseUnivariatePolynomial $Time: 0 SEC. compiling exported factorPolynomial : SparseUnivariatePolynomial$ -> Factored SparseUnivariatePolynomial $Time: 0.02 SEC. compiling exported squareFreePolynomial : SparseUnivariatePolynomial$ -> Factored SparseUnivariatePolynomial $Time: 0 SEC. compiling exported ^ : ($,Fraction Integer) -> $Time: 0.01 SEC. compiling exported minPoly : Kernel$ -> SparseUnivariatePolynomial $Time: 0 SEC. compiling exported definingPolynomial :$ -> $Time: 0 SEC. compiling exported retract :$ -> Fraction Integer
Time: 0 SEC.
compiling exported retractIfCan : $-> Union(Fraction Integer,failed) Time: 0 SEC. compiling exported coerce : AlgebraicNumber ->$
Time: 0.01 SEC.
compiling local k2expr : Kernel AlgebraicNumber -> $Time: 0 SEC. compiling local smp2expr : SparseMultivariatePolynomial(Integer,Kernel AlgebraicNumber) ->$
Time: 0 SEC.
compiling exported retractIfCan : $-> Union(AlgebraicNumber,failed) Time: 0.01 SEC. compiling local R2AN : Integer -> Union(AlgebraicNumber,failed) Time: 0 SEC. compiling local k2an : Kernel$ -> Union(AlgebraicNumber,failed)
Time: 0.03 SEC.
compiling local smp2an : SparseMultivariatePolynomial(Integer,Kernel $) -> Union(AlgebraicNumber,failed) Time: 0.01 SEC. compiling exported convert :$ -> InputForm
Time: 0.01 SEC.
importing MakeUnaryCompiledFunction($,$,$) compiling exported eval : ($,BasicOperator,$,Symbol) ->$
Time: 0.01 SEC.
compiling exported eval : ($,List BasicOperator,List$,Symbol) -> $Time: 0.02 SEC. compiling exported patternMatch : ($,Pattern Integer,PatternMatchResult(Integer,$)) -> PatternMatchResult(Integer,$)
Time: 0 SEC.
****** Domain: (Integer) already in scope
augmenting (Integer): (CharacteristicNonZero)
****** Domain: (Integer) already in scope
augmenting (Integer): (ConvertibleTo (Pattern (Float)))
****** Domain: (Integer) already in scope
augmenting (Integer): (Group)
****** Domain: (Integer) already in scope
augmenting (Integer): (PatternMatchable (Float))
(time taken in buildFunctor:  210)
;;;     ***       |Real| REDEFINED
;;;     ***       |Real| REDEFINED
Time: 0.27 SEC.
Warnings:
[1] retNotUnit:  $$has no value [2] poly_to_MP:$$ has no value
[3] simplifyPower:  $$has no value [4] alg_ker_set: ak1 has no value [5] alg_ker_set: resl has no value [6] algreduc:$$ has no value
[7] reducedSystem:  $$has no value [8] reducedSystem: mat has no value [9] reducedSystem: vec has no value [10] pi: not known that (RadicalCategory) is of mode (CATEGORY domain (IF (has (Integer) (IntegralDomain)) (PROGN (ATTRIBUTE (AlgebraicallyClosedFunctionSpace (Integer))) (ATTRIBUTE (TranscendentalFunctionCategory)) (ATTRIBUTE (CombinatorialOpsCategory)) (ATTRIBUTE (LiouvillianFunctionCategory)) (ATTRIBUTE (SpecialFunctionCategory)) (SIGNATURE reduce ( )) (SIGNATURE number? ((Boolean) )) (SIGNATURE simplifyPower (  (Integer))) (IF (has (Integer) (GcdDomain)) (PROGN (SIGNATURE factorPolynomial ((Factored (SparseUnivariatePolynomial )) (SparseUnivariatePolynomial ))) (SIGNATURE squareFreePolynomial ((Factored (SparseUnivariatePolynomial )) (SparseUnivariatePolynomial )))) noBranch) (IF (has (Integer) (RetractableTo (Integer))) (ATTRIBUTE (RetractableTo (AlgebraicNumber))) noBranch) (SIGNATURE setSimplifyDenomsFlag ((Boolean) (Boolean))) (SIGNATURE getSimplifyDenomsFlag ((Boolean)))) noBranch)) [11] summation:$$ has no value
[12] erf: not known that (RadicalCategory) is of mode (CATEGORY domain (IF (has (Integer) (IntegralDomain)) (PROGN (ATTRIBUTE (AlgebraicallyClosedFunctionSpace (Integer))) (ATTRIBUTE (TranscendentalFunctionCategory)) (ATTRIBUTE (CombinatorialOpsCategory)) (ATTRIBUTE (LiouvillianFunctionCategory)) (ATTRIBUTE (SpecialFunctionCategory)) (SIGNATURE reduce ()) (SIGNATURE number? ((Boolean) $)) (SIGNATURE simplifyPower ($ $(Integer))) (IF (has (Integer) (GcdDomain)) (PROGN (SIGNATURE factorPolynomial ((Factored (SparseUnivariatePolynomial$)) (SparseUnivariatePolynomial $))) (SIGNATURE squareFreePolynomial ((Factored (SparseUnivariatePolynomial$)) (SparseUnivariatePolynomial $)))) noBranch) (IF (has (Integer) (RetractableTo (Integer))) (ATTRIBUTE (RetractableTo (AlgebraicNumber))) noBranch) (SIGNATURE setSimplifyDenomsFlag ((Boolean) (Boolean))) (SIGNATURE getSimplifyDenomsFlag ((Boolean)))) noBranch)) [13] erf: not known that (TranscendentalFunctionCategory) is of mode (CATEGORY domain (IF (has (Integer) (IntegralDomain)) (PROGN (ATTRIBUTE (AlgebraicallyClosedFunctionSpace (Integer))) (ATTRIBUTE (TranscendentalFunctionCategory)) (ATTRIBUTE (CombinatorialOpsCategory)) (ATTRIBUTE (LiouvillianFunctionCategory)) (ATTRIBUTE (SpecialFunctionCategory)) (SIGNATURE reduce ($ $)) (SIGNATURE number? ((Boolean)$)) (SIGNATURE simplifyPower ( (Integer))) (IF (has (Integer) (GcdDomain)) (PROGN (SIGNATURE factorPolynomial ((Factored (SparseUnivariatePolynomial $)) (SparseUnivariatePolynomial$))) (SIGNATURE squareFreePolynomial ((Factored (SparseUnivariatePolynomial $)) (SparseUnivariatePolynomial$)))) noBranch) (IF (has (Integer) (RetractableTo (Integer))) (ATTRIBUTE (RetractableTo (AlgebraicNumber))) noBranch) (SIGNATURE setSimplifyDenomsFlag ((Boolean) (Boolean))) (SIGNATURE getSimplifyDenomsFlag ((Boolean)))) noBranch))
[14] evl0:  $$has no value [15] factorPolynomial:$$ has no value
[16] patternMatch:   has no value
[17] unknown Functor code (DEFVAR algreduc_flag (call (XLAM ignore (QUOTE ))))
Cumulative Statistics for Constructor Real
Time: 1.76 seconds
finalizing NRLIB RR
Processing Real for Browser database:
--------constructor---------
--------(reduce (% %))---------
--------(number? ((Boolean) %))---------
--------(simplifyPower (% % (Integer)))---------
--------(factorPolynomial ((Factored (SparseUnivariatePolynomial %)) (SparseUnivariatePolynomial %)))---------
--------(squareFreePolynomial ((Factored (SparseUnivariatePolynomial %)) (SparseUnivariatePolynomial %)))---------
--------(setSimplifyDenomsFlag ((Boolean) (Boolean)))---------
--------(getSimplifyDenomsFlag ((Boolean)))---------
; compiling file "/var/aw/var/LatexWiki/RR.NRLIB/RR.lsp" (written 01 DEC 2014 05:54:49 PM):
; /var/aw/var/LatexWiki/RR.NRLIB/RR.fasl written
; compilation finished in 0:00:00.777
------------------------------------------------------------------------
Real is now explicitly exposed in frame initial
Real will be automatically loaded when needed from
/var/aw/var/LatexWiki/RR.NRLIB/RR
RSPACE abbreviates domain RealSpace
------------------------------------------------------------------------
initializing NRLIB RSPACE for RealSpace
compiling into NRLIB RSPACE
Local variable Rep type redefined: (DirectProductCategory n (Real)) to (Join (QuotientFieldCategory (SparseMultivariatePolynomial (Integer) (Kernel $))) (CATEGORY package (IF (has (SparseMultivariatePolynomial (Integer) (Kernel$)) (IntegerNumberSystem)) (IF (has (SparseMultivariatePolynomial (Integer) (Kernel $)) (OpenMath)) (ATTRIBUTE (OpenMath)) noBranch) noBranch) (IF (has (SparseMultivariatePolynomial (Integer) (Kernel$)) (Canonical)) (IF (has (SparseMultivariatePolynomial (Integer) (Kernel $)) (GcdDomain)) (IF (has (SparseMultivariatePolynomial (Integer) (Kernel$)) (canonicalUnitNormal)) (ATTRIBUTE (Canonical)) noBranch) noBranch) noBranch)))
compiling exported coerce : List Real -> $Time: 0.01 SEC. compiling exported coerce : Real ->$
Time: 0.01 SEC.
compiling exported coerce : $-> OutputForm Time: 0 SEC. compiling exported dim :$ -> NonNegativeInteger
Time: 0 SEC.
compiling exported dist : ($,$) -> Real
Time: 0 SEC.
(time taken in buildFunctor:  0)
;;;     ***       |RealSpace| REDEFINED
;;;     ***       |RealSpace| REDEFINED
Time: 0 SEC.
Cumulative Statistics for Constructor RealSpace
Time: 0.02 seconds
--------------non extending category----------------------
.. RealSpace(#1) of cat
(|Join| (|CoercibleTo| (|OutputForm|)) (|ConvertibleTo| (|String|))
(CATEGORY |domain| (SIGNATURE |coerce| ((|OutputForm|) $)) (SIGNATURE |coerce| ($ (|List| (|Real|))))
(SIGNATURE |coerce| ($(|Real|))) (SIGNATURE |dot| ((|Real|)$ $)) (SIGNATURE |dim| ((|NonNegativeInteger|)$)) (SIGNATURE + ( $)) (SIGNATURE - ($ )) (SIGNATURE * ($(|Real|)$))
(SIGNATURE * ($(|NonNegativeInteger|)$))
(SIGNATURE * ($(|PositiveInteger|)$))
(SIGNATURE * ($(|Integer|)$)) (SIGNATURE / ( (|Real|)))
(SIGNATURE |#| ((|NonNegativeInteger|) $)) (SIGNATURE - ($ $)) (SIGNATURE = ((|Boolean|)$ $)) (SIGNATURE ~= ((|Boolean|)$ $)) (SIGNATURE |unitVector| ($ (|PositiveInteger|)))
(SIGNATURE |elt| ((|Real|) $(|Integer|))) (SIGNATURE |eval| ($ $(|Equation| (|Real|)))) (SIGNATURE |eval| ($ $(|List| (|Equation| (|Real|))))) (SIGNATURE |every?| ((|Boolean|) (|Mapping| (|Boolean|) (|Real|))$))
(SIGNATURE |map| ($(|Mapping| (|Real|) (|Real|))$))
(SIGNATURE |member?| ((|Boolean|) (|Real|) $)) (SIGNATURE |any?| ((|Boolean|) (|Mapping| (|Boolean|) (|Real|))$))
(SIGNATURE |copy| ()) (SIGNATURE D ( (|Symbol|)))
(SIGNATURE D ( (|Symbol|) (|NonNegativeInteger|)))
(SIGNATURE D ( (|List| (|Symbol|))))
(SIGNATURE D
( (|List| (|Symbol|)) (|List| (|NonNegativeInteger|))))
(SIGNATURE |dist| ((|Real|) ))))   has no
(|DirectProductCategory| |#1| (|Real|))    finalizing NRLIB RSPACE
Processing RealSpace for Browser database:
--------constructor---------
--------(reduce (% %))---------
--------(number? ((Boolean) %))---------
--------(simplifyPower (% % (Integer)))---------
--------(factorPolynomial ((Factored (SparseUnivariatePolynomial %)) (SparseUnivariatePolynomial %)))---------
--------(squareFreePolynomial ((Factored (SparseUnivariatePolynomial %)) (SparseUnivariatePolynomial %)))---------
--------(setSimplifyDenomsFlag ((Boolean) (Boolean)))---------
--------(getSimplifyDenomsFlag ((Boolean)))---------
--------constructor---------
--->-->RealSpace((coerce ((OutputForm) %))): Not documented!!!!
--->-->RealSpace((coerce (% (List (Real))))): Not documented!!!!
--->-->RealSpace((coerce (% (Real)))): Not documented!!!!
--->-->RealSpace((dot ((Real) % %))): Not documented!!!!
--->-->RealSpace((dim ((NonNegativeInteger) %))): Not documented!!!!
--->-->RealSpace((+ (% % %))): Not documented!!!!
--->-->RealSpace((- (% % %))): Not documented!!!!
--->-->RealSpace((* (% (Real) %))): Not documented!!!!
--->-->RealSpace((* (% (NonNegativeInteger) %))): Not documented!!!!
--->-->RealSpace((* (% (PositiveInteger) %))): Not documented!!!!
--->-->RealSpace((* (% (Integer) %))): Not documented!!!!
--->-->RealSpace((/ (% % (Real)))): Not documented!!!!
--->-->RealSpace((# ((NonNegativeInteger) %))): Not documented!!!!
--->-->RealSpace((- (% %))): Not documented!!!!
--->-->RealSpace((= ((Boolean) % %))): Not documented!!!!
--->-->RealSpace((~= ((Boolean) % %))): Not documented!!!!
--->-->RealSpace((unitVector (% (PositiveInteger)))): Not documented!!!!
--->-->RealSpace((elt ((Real) % (Integer)))): Not documented!!!!
--->-->RealSpace((eval (% % (Equation (Real))))): Not documented!!!!
--->-->RealSpace((eval (% % (List (Equation (Real)))))): Not documented!!!!
--->-->RealSpace((every? ((Boolean) (Mapping (Boolean) (Real)) %))): Not documented!!!!
--->-->RealSpace((map (% (Mapping (Real) (Real)) %))): Not documented!!!!
--->-->RealSpace((member? ((Boolean) (Real) %))): Not documented!!!!
--->-->RealSpace((any? ((Boolean) (Mapping (Boolean) (Real)) %))): Not documented!!!!
--->-->RealSpace((copy (% %))): Not documented!!!!
--->-->RealSpace((D (% % (Symbol)))): Not documented!!!!
--->-->RealSpace((D (% % (Symbol) (NonNegativeInteger)))): Not documented!!!!
--->-->RealSpace((D (% % (List (Symbol))))): Not documented!!!!
--->-->RealSpace((D (% % (List (Symbol)) (List (NonNegativeInteger))))): Not documented!!!!
--->-->RealSpace((dist ((Real) % %))): Not documented!!!!
; compiling file "/var/aw/var/LatexWiki/RSPACE.NRLIB/RSPACE.lsp" (written 01 DEC 2014 05:54:50 PM):
; /var/aw/var/LatexWiki/RSPACE.NRLIB/RSPACE.fasl written
; compilation finished in 0:00:00.017
------------------------------------------------------------------------
RealSpace is now explicitly exposed in frame initial
RealSpace will be automatically loaded when needed from
/var/aw/var/LatexWiki/RSPACE.NRLIB/RSPACE

fricas
P:=[x,y,z::RR]::RealSpace(3)
 (1)
Type: RealSpace?(3)
fricas
Q:=[u,v,w::RR]::RealSpace(3)
 (2)
Type: RealSpace?(3)

fricas
s:=s::RR
 (3)
Type: Real
fricas
t:=t::RR
 (4)
Type: Real

fricas
P+Q
 (5)
Type: RealSpace?(3)
fricas
P-Q
 (6)
Type: RealSpace?(3)
fricas
-P
 (7)
Type: RealSpace?(3)
fricas
dot(P,Q)
 (8)
Type: Real
fricas
dist(P,Q)
 (9)
Type: Real
fricas
t*P+s*Q
 (10)
Type: RealSpace?(3)
fricas
unitVector(1)\$RSPACE(3)
 (11)
Type: RealSpace?(3)
fricas
P.1
 (12)
Type: Real
fricas
Q.2
 (13)
Type: Real

Functions

fricas
f:Real -> Real
Type: Void
fricas
f(t) == t^2*sin(t)
Type: Void
fricas
X:Real -> RealSpace(4)
Type: Void
fricas
X(t) == [f(t),f(2*t),t^2,cos(t::RR)]::RealSpace(4)
Type: Void
fricas
X(t) -- curve in R^4
fricas
Compiling function f with type Real -> Real
fricas
Compiling function X with type Real -> RealSpace(4)
 (14)
Type: RealSpace?(4)
fricas
D(X(t),'t)
 (15)
Type: RealSpace?(4)
fricas
D(X(t),'t,2)
 (16)
Type: RealSpace?(4)
fricas
eval(X(t),t=1)
 (17)
Type: RealSpace?(4)
fricas
Z:RealSpace(2)->RealSpace(3)
Type: Void
fricas
z:=[x,y::RR]::RSPACE(2)
 (18)
Type: RealSpace?(2)
fricas
Z(q) == [q.1^2,exp(-q.1*q.2),(q.1+q.2)^n]
Type: Void
fricas
Z(z)
fricas
Compiling function Z with type RealSpace(2) -> RealSpace(3)
 (19)
Type: RealSpace?(3)
fricas
D(Z(z),['x,'y])
 (20)
Type: RealSpace?(3)
fricas
D(Z(z),['x,'y],[2,3])
 (21)
Type: RealSpace?(3)
fricas
D(Z(z),'x,3)
 (22)
Type: RealSpace?(3)

fricas
limit(1/n^2::RR,n=%plusInfinity)
 (23)
Type: Union(OrderedCompletion?(Real),...)
fricas
limit(X(t).4,'t=0)
 (24)
Type: Union(OrderedCompletion?(Real),...)

fricas
integrate((sin(y::RR))^2,y)
 (25)
Type: Union(Real,...)
fricas
integrate(sin(s)^2,'s)
 (26)
Type: Union(Real,...)
fricas
integrate(dist(X(u),X(v)),u)
>> Error detected within library code:
integrate: implementation incomplete (constant residues)

-- continue with PROP domain

 Subject:   Be Bold !! ( 14 subscribers )