> > So yes, I would be in favour of renaming Pfaffian to pfaffian and
> > remove the "mrv_" in front of all exports from the MrvLimitPackage.
In a first patch I renamed mrv_foo to mrvFoo. This works fine.
The second one removes mrv for the two main exports mrv_limit(...)
but this does not compile.
I don't know why and had no time to take a deeper look yet.
--
You received this message because you are subscribed to the Google Groups
"FriCAS - computer algebra system" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/fricas-devel?hl=en.
Index: mrv_limit.spad.pamphlet
===================================================================
--- mrv_limit.spad.pamphlet (revision 1501)
+++ mrv_limit.spad.pamphlet (working copy)
@@ -53,31 +53,31 @@
U ==> Union(OFE, TwoSide, "failed")
Exports ==> with
- mrv_limit : (FE, EQ OFE) -> U
+ mrvLimit : (FE, EQ OFE) -> U
++ Compute limit(f(x), x=a) for a finite or infinite limit point a
- mrv_limit : (FE, EQ FE, String) -> RESULT
+ mrvLimit : (FE, EQ FE, String) -> RESULT
++ Compute limit(f(x), x=a) for a strictly finite limit point a
++ This function computes one-sided limits from the left or right
- mrv_normalize : (FE, Symbol, STATE_REC) -> FE
- ++ mrv_normalize(f, x) transform f to the form acceptable
- ++ by core variant of mrv_limit.
- mrv_limit : (FE, Symbol, STATE_REC) -> RESULT
+ mrvNormalize : (FE, Symbol, STATE_REC) -> FE
+ ++ mrvNormalize(f, x) transform f to the form acceptable
+ ++ by core variant of mrvLimit.
+ mrvLimit : (FE, Symbol, STATE_REC) -> RESULT
++ Compute limit.
- mrv_limit1 : (FE, Symbol) -> RESULT
+ mrvLimit1 : (FE, Symbol) -> RESULT
++ normalize and compute limit.
- mrv_sign : (FE, Symbol, STATE_REC) -> Union(Integer, "failed")
- mrv_cmp : (K, K, Symbol, STATE_REC) -> CMP_RESU
+ mrvSign : (FE, Symbol, STATE_REC) -> Union(Integer, "failed")
+ mrvCmp : (K, K, Symbol, STATE_REC) -> CMP_RESU
++ Compare kernels
- mrv_set : (FE, Symbol, STATE_REC) -> SET_RESU
+ mrvSet : (FE, Symbol, STATE_REC) -> SET_RESU
++ Compute MRV set
- expr_to_series : (FE, K, STATE_REC) -> SER_RESU
+ exprToSeries : (FE, K, STATE_REC) -> SER_RESU
++ Compute degree and leading coefficinet of series expansion
- mrv_rewrite : (FE, List K, List FE, Symbol, STATE_REC) -> SER_RESU
+ mrvRewrite : (FE, List K, List FE, Symbol, STATE_REC) -> SER_RESU
++ rewrite
- mrv_rewrite0 : (FE, List K, List FE, FE) -> FE
- ++ mrv_rewrite0
+ mrvRewrite0 : (FE, List K, List FE, FE) -> FE
+ ++ mrvRewrite0
Implementation ==> add
import ToolsForSign(R)
@@ -99,7 +99,7 @@
EFSTRUC ==> ElementaryFunctionStructurePackage(R, FE)
- mrv_normalize(f, x, state) ==
+ mrvNormalize(f, x, state) ==
f := normalize(f)$EFSTRUC
tf := tower(f)
rtf : List(K) := []
@@ -122,9 +122,9 @@
nm = 'exp => "iterate"
nm = 'log => "iterate"
#args = 1 =>
- lau := mrv_limit(arg1 := args(1), x, state)
+ lau := mrvLimit(arg1 := args(1), x, state)
-- la := lau::OFE
- -- la := mrv_limit(arg1 := args(1), x)
+ -- la := mrvLimit(arg1 := args(1), x)
nm = 'atan =>
lau case "failed" =>
ns := new()$Symbol
@@ -167,7 +167,7 @@
SIGNEF ==> ElementaryFunctionSign(Integer, FE)
- mrv_bounded1(e : FE, state : STATE_REC) : Boolean ==
+ mrvBounded1(e : FE, state : STATE_REC) : Boolean ==
ke := kernels(e)
ne := numer(e)
de := denom(e)
@@ -190,10 +190,10 @@
not(empty?(setIntersection(vde, state.atan_syms))) => false
empty?(setIntersection(kernels(ne::FE), state.tan_kers))
- mrv_bounded(state : STATE_REC) : (FE -> Boolean) ==
- e +-> mrv_bounded1(e, state)
+ mrvBounded(state : STATE_REC) : (FE -> Boolean) ==
+ e +-> mrvBounded1(e, state)
- mrv_invertible(state : STATE_REC) : (FE -> Boolean) ==
+ mrvInvertible(state : STATE_REC) : (FE -> Boolean) ==
var_syms := concat(state.tan_syms, state.atan_syms)
(e : FE) : Boolean +->
empty?(setIntersection(variables(e), var_syms)) => true
@@ -217,13 +217,13 @@
-- compute leading term and degree of expansion of e into
-- generalized power series with respect to k
- expr_to_series(e : FE, k : K, state : STATE_REC) : SER_RESU ==
+ exprToSeries(e : FE, k : K, state : STATE_REC) : SER_RESU ==
ex : FE := eval(e, [k], [series_x :: FE])
not(is?(k, 'exp)) =>
error "Can only expand with respect to exp"
h := argument(k).1
ss := exprToPS(ex, false, "complex", true, h,
- mrv_bounded(state), mrv_invertible(state))$ppack
+ mrvBounded(state), mrvInvertible(state))$ppack
ss case %problem => "failed"
ssl := ss.%series
kk : Integer := 0
@@ -246,14 +246,14 @@
-- compare comparability classes of two kernels, uses
-- Gruntz Lemma 3.6
- mrv_cmp(x : K, y : K, v : Symbol, state : STATE_REC) : CMP_RESU ==
+ mrvCmp(x : K, y : K, v : Symbol, state : STATE_REC) : CMP_RESU ==
x1 : FE :=
is?(x, "exp" :: Symbol) => argument(x).1
log(x :: FE)
y1 : FE :=
is?(y, "exp" :: Symbol) => argument(y).1
log(y :: FE)
- ppu := mrv_limit(x1/y1, v, state)
+ ppu := mrvLimit(x1/y1, v, state)
ppu case OFE =>
pp1 := ppu::OFE
pp1 = (0::OFE) => [-1, 0]
@@ -267,14 +267,14 @@
-- exponentials
-- as a byproduct we compute list of constanst such that
-- res.i =~ res.1^(res_c.i)
- mrv_set(e : FE, x : Symbol, state : STATE_REC) : SET_RESU ==
+ mrvSet(e : FE, x : Symbol, state : STATE_REC) : SET_RESU ==
kers := tower(e)
res_k : K := kernels(x::FE).1
res : List K := [res_k]
res_c : List FE := [1::FE]
for y in kers repeat
is?(y, "exp" :: Symbol) =>
- icu := mrv_cmp(y, res_k, x, state)
+ icu := mrvCmp(y, res_k, x, state)
icu case "failed" => return "failed"
ic := icu::CMP_RES
i := ic.sign
@@ -298,7 +298,7 @@
-- we assume that simpler kernels are earlier on he list,
-- more precisely, if lx.i is a subexpression of lx.j then
-- i <= j
- mrv_rewrite1(e : FE, lx : List K, ly : List FE) : FE ==
+ mrvRewrite1(e : FE, lx : List K, ly : List FE) : FE ==
rlx := reverse(lx)
rly := reverse(ly)
for x in rlx for y in rly repeat
@@ -315,7 +315,7 @@
--
-- lx.1 is equivalent to omega, but normalized so that it
-- goes to 0 when v goes to infinity
- mrv_rewrite0(e : FE, lx : List K, lc : List FE, x00 : FE) : FE ==
+ mrvRewrite0(e : FE, lx : List K, lc : List FE, x00 : FE) : FE ==
c0 := first lc
(#lx = 1) and (c0 = 1) => e
e0 := argument(kernels(x00).1).1
@@ -330,7 +330,7 @@
else
ly := cons(x00^c0, ly)
lxx := lx
- mrv_rewrite1(e, lxx, ly)
+ mrvRewrite1(e, lxx, ly)
-- Rewrite in terms of mrv kernel and compute leading term of
-- series expansion
@@ -339,13 +339,13 @@
-- lx list of mrv kernels
-- lc coefficients so that lx.i =~ lx.1 ^(lc.i)
-- v variable
- mrv_rewrite(e : FE, lx : List K, lc : List FE, v : Symbol,
+ mrvRewrite(e : FE, lx : List K, lc : List FE, v : Symbol,
state : STATE_REC) : SER_RESU ==
x0 := first lx
-- Shift up, if needed and recurse
is?(x0, v :: Symbol) =>
lxx : List K := [kernels(eval(ei::FE, [x0], [exp(v::FE)])).1 for ei in lx]
- mrv_rewrite(eval(e, [x0], [exp(v::FE)]), lxx, lc, v, state)
+ mrvRewrite(eval(e, [x0], [exp(v::FE)]), lxx, lc, v, state)
-- Sanity check
~ is?(x0, "exp" :: Symbol) =>
error "mrv is not exp, need substitution"
@@ -358,7 +358,7 @@
-- kk := kernels(argument(x0).1)
lip : RESULT :=
e0 = (v::FE) => plusInfinity()@OFE
- mrv_limit(e0, v, state)
+ mrvLimit(e0, v, state)
lip case OFE =>
lipp : OFE := lip :: OFE
ss : Integer := whatInfinity(lipp)
@@ -374,45 +374,45 @@
x00 := x0 :: FE
lxx := lx
-- do the rewrite
- e := mrv_rewrite0(e, lxx, lcc, x00)
- expr_to_series(e, kernels(x00).1, state)
+ e := mrvRewrite0(e, lxx, lcc, x00)
+ exprToSeries(e, kernels(x00).1, state)
error "limit failed"
- mrv_sign(e : FE, v : Symbol, state : STATE_REC
+ mrvSign(e : FE, v : Symbol, state : STATE_REC
) : Union(Integer, "failed") ==
~ member?(v::Symbol, variables(e)) => sign(e)$SIGNEF
-- (s := sign(e)$SIGNEF) case Integer =>
-- return s
-- error "Can not determine sign"
- rkcu := mrv_set(e, v, state)
+ rkcu := mrvSet(e, v, state)
rkcu case "failed" => "failed"
rkc := rkcu::SET_RES
lx := rkc.lk
lcc := rkc.lc
- ssu : SER_RESU := mrv_rewrite(e, lx, lcc, v, state)
+ ssu : SER_RESU := mrvRewrite(e, lx, lcc, v, state)
ssu case "failed" => "failed"
ss := ssu::SER_RES
- mrv_sign(ss.coeff, v, state)
+ mrvSign(ss.coeff, v, state)
-- Compute limit of e when v goes to infinity
- mrv_limit(e : FE, v : Symbol, state : STATE_REC) : RESULT ==
+ mrvLimit(e : FE, v : Symbol, state : STATE_REC) : RESULT ==
~ member?(v, (ve := variables(e))) =>
empty?(setIntersection(ve, state.tan_syms)) and
empty?(setIntersection(ve, state.atan_syms)) => e :: OFE
"failed"
- rkcu := mrv_set(e, v, state)
+ rkcu := mrvSet(e, v, state)
rkcu case "failed" => "failed"
rkc := rkcu::SET_RES
lx := rkc.lk
lcc := rkc.lc
- ssu : SER_RESU := mrv_rewrite(e, lx, lcc, v, state)
+ ssu : SER_RESU := mrvRewrite(e, lx, lcc, v, state)
ssu case "failed" => "failed"
ss := ssu::SER_RES
deg := ss.degree
deg > 0 => 0
- deg = 0 => mrv_limit(ss.coeff, v, state)
+ deg = 0 => mrvLimit(ss.coeff, v, state)
deg < 0 =>
- su := mrv_sign(ss.coeff, v, state)
+ su := mrvSign(ss.coeff, v, state)
su case "failed" => "failed"
s := su::Integer
s = 1 =>
@@ -421,12 +421,12 @@
minusInfinity()
error "Nonzero term has no sign"
- mrv_limit1(e : FE, x : Symbol) : RESULT ==
+ mrvLimit1(e : FE, x : Symbol) : RESULT ==
state := [[], [], [], []]$STATE_REC
- e := mrv_normalize(e, x, state)
- mrv_limit(e, x, state)
+ e := mrvNormalize(e, x, state)
+ mrvLimit(e, x, state)
- mrv_limit(e : FE, eq : EQ OFE) : U ==
+ mrvLimit(e : FE, eq : EQ OFE) : U ==
(f := retractIfCan(lhs eq)@Union(FE,"failed")) case "failed" =>
error "limit:left hand side must be a variable"
@@ -439,7 +439,7 @@
-- Case positive infinity
ii = 1 =>
- resu := mrv_limit1(e, v)
+ resu := mrvLimit1(e, v)
resu case "failed" => "failed"
resu::OFE
@@ -448,7 +448,7 @@
-- replace x by -x
vK := retract(v::FE)@Kernel(FE)
et : FE := eval(e, vK, -vK::FE)
- resu := mrv_limit1(et, v)
+ resu := mrvLimit1(et, v)
resu case "failed" => "failed"
resu::OFE
@@ -459,18 +459,18 @@
-- replace x by a - 1/x
et : FE := eval(e, vK, retract(a)@FE - inv(vK::FE))
- ll := mrv_limit1(et, v)
+ ll := mrvLimit1(et, v)
-- replace x by a + 1/x
et : FE := eval(e, vK, retract(a)@FE + inv(vK::FE))
- lr := mrv_limit1(et, v)
+ lr := mrvLimit1(et, v)
ll = lr =>
lr case "failed" => "failed"
lr::OFE
[ll, lr]$TwoSide
- mrv_limit(e : FE, eq : EQ FE, s : String) : RESULT ==
+ mrvLimit(e : FE, eq : EQ FE, s : String) : RESULT ==
(f := retractIfCan(lhs eq)@Union(SY,"failed")) case "failed" =>
error "limit:left hand side must be a variable"
@@ -481,12 +481,12 @@
direction(s) = 1 =>
vK := retract(v::FE)@Kernel(FE)
et : FE := eval(e, vK, a + inv(vK::FE))
- mrv_limit1(et, v)
+ mrvLimit1(et, v)
-- From the left: replace x by a - 1/z
direction(s) = -1 =>
vK := retract(v::FE)@Kernel(FE)
et : FE := eval(e, vK, a - inv(vK::FE))
- mrv_limit1(et, v)
+ mrvLimit1(et, v)
@
Index: limitps.spad.pamphlet
===================================================================
--- limitps.spad.pamphlet (revision 1501)
+++ limitps.spad.pamphlet (working copy)
@@ -393,7 +393,7 @@
limit(fcn : FE, eq : EQ FE, str : String) ==
limit2(fcn, eq, str,
(f : FE, x : SY, a : FE, s : String) : RESULT +->
- (is_exp_log(f, x) => mrv_limit(fcn, eq, str)$MrvLimitPackage;
+ (is_exp_log(f, x) => mrvLimit(fcn, eq, str)$MrvLimitPackage;
limit3(f, x, a, s)))
else
@@ -620,7 +620,7 @@
limit(fcn : FE, eq : EQ OFE) ==
limit1(fcn, eq, (f : FE, x : SY, a : OFE) : U +->
- (is_exp_log(f, x) => mrv_limit(fcn, eq)$MrvLimitPackage;
+ (is_exp_log(f, x) => mrvLimit(fcn, eq)$MrvLimitPackage;
locallimit(f, x, a)))
else
Index: limitps.spad.pamphlet
===================================================================
--- limitps.spad.pamphlet (revision 1501)
+++ limitps.spad.pamphlet (working copy)
@@ -393,7 +393,7 @@
limit(fcn : FE, eq : EQ FE, str : String) ==
limit2(fcn, eq, str,
(f : FE, x : SY, a : FE, s : String) : RESULT +->
- (is_exp_log(f, x) => mrv_limit(fcn, eq, str)$MrvLimitPackage;
+ (is_exp_log(f, x) => limit(fcn, eq, str)$MrvLimitPackage;
limit3(f, x, a, s)))
else
@@ -620,7 +620,7 @@
limit(fcn : FE, eq : EQ OFE) ==
limit1(fcn, eq, (f : FE, x : SY, a : OFE) : U +->
- (is_exp_log(f, x) => mrv_limit(fcn, eq)$MrvLimitPackage;
+ (is_exp_log(f, x) => limit(fcn, eq)$MrvLimitPackage;
locallimit(f, x, a)))
else
Index: mrv_limit.spad.pamphlet
===================================================================
--- mrv_limit.spad.pamphlet (revision 1501)
+++ mrv_limit.spad.pamphlet (working copy)
@@ -53,31 +53,31 @@
U ==> Union(OFE, TwoSide, "failed")
Exports ==> with
- mrv_limit : (FE, EQ OFE) -> U
+ limit : (FE, EQ OFE) -> U
++ Compute limit(f(x), x=a) for a finite or infinite limit point a
- mrv_limit : (FE, EQ FE, String) -> RESULT
+ limit : (FE, EQ FE, String) -> RESULT
++ Compute limit(f(x), x=a) for a strictly finite limit point a
++ This function computes one-sided limits from the left or right
- mrv_normalize : (FE, Symbol, STATE_REC) -> FE
- ++ mrv_normalize(f, x) transform f to the form acceptable
- ++ by core variant of mrv_limit.
- mrv_limit : (FE, Symbol, STATE_REC) -> RESULT
+ mrvNormalize : (FE, Symbol, STATE_REC) -> FE
+ ++ mrvNormalize(f, x) transform f to the form acceptable
+ ++ by core variant of mrvLimit.
+ mrvLimit : (FE, Symbol, STATE_REC) -> RESULT
++ Compute limit.
- mrv_limit1 : (FE, Symbol) -> RESULT
+ mrvLimit1 : (FE, Symbol) -> RESULT
++ normalize and compute limit.
- mrv_sign : (FE, Symbol, STATE_REC) -> Union(Integer, "failed")
- mrv_cmp : (K, K, Symbol, STATE_REC) -> CMP_RESU
+ mrvSign : (FE, Symbol, STATE_REC) -> Union(Integer, "failed")
+ mrvCmp : (K, K, Symbol, STATE_REC) -> CMP_RESU
++ Compare kernels
- mrv_set : (FE, Symbol, STATE_REC) -> SET_RESU
+ mrvSet : (FE, Symbol, STATE_REC) -> SET_RESU
++ Compute MRV set
- expr_to_series : (FE, K, STATE_REC) -> SER_RESU
+ exprToSeries : (FE, K, STATE_REC) -> SER_RESU
++ Compute degree and leading coefficinet of series expansion
- mrv_rewrite : (FE, List K, List FE, Symbol, STATE_REC) -> SER_RESU
+ mrvRewrite : (FE, List K, List FE, Symbol, STATE_REC) -> SER_RESU
++ rewrite
- mrv_rewrite0 : (FE, List K, List FE, FE) -> FE
- ++ mrv_rewrite0
+ mrvRewrite0 : (FE, List K, List FE, FE) -> FE
+ ++ mrvRewrite0
Implementation ==> add
import ToolsForSign(R)
@@ -99,7 +99,7 @@
EFSTRUC ==> ElementaryFunctionStructurePackage(R, FE)
- mrv_normalize(f, x, state) ==
+ mrvNormalize(f, x, state) ==
f := normalize(f)$EFSTRUC
tf := tower(f)
rtf : List(K) := []
@@ -122,9 +122,9 @@
nm = 'exp => "iterate"
nm = 'log => "iterate"
#args = 1 =>
- lau := mrv_limit(arg1 := args(1), x, state)
+ lau := mrvLimit(arg1 := args(1), x, state)
-- la := lau::OFE
- -- la := mrv_limit(arg1 := args(1), x)
+ -- la := mrvLimit(arg1 := args(1), x)
nm = 'atan =>
lau case "failed" =>
ns := new()$Symbol
@@ -167,7 +167,7 @@
SIGNEF ==> ElementaryFunctionSign(Integer, FE)
- mrv_bounded1(e : FE, state : STATE_REC) : Boolean ==
+ mrvBounded1(e : FE, state : STATE_REC) : Boolean ==
ke := kernels(e)
ne := numer(e)
de := denom(e)
@@ -190,10 +190,10 @@
not(empty?(setIntersection(vde, state.atan_syms))) => false
empty?(setIntersection(kernels(ne::FE), state.tan_kers))
- mrv_bounded(state : STATE_REC) : (FE -> Boolean) ==
- e +-> mrv_bounded1(e, state)
+ mrvBounded(state : STATE_REC) : (FE -> Boolean) ==
+ e +-> mrvBounded1(e, state)
- mrv_invertible(state : STATE_REC) : (FE -> Boolean) ==
+ mrvInvertible(state : STATE_REC) : (FE -> Boolean) ==
var_syms := concat(state.tan_syms, state.atan_syms)
(e : FE) : Boolean +->
empty?(setIntersection(variables(e), var_syms)) => true
@@ -217,13 +217,13 @@
-- compute leading term and degree of expansion of e into
-- generalized power series with respect to k
- expr_to_series(e : FE, k : K, state : STATE_REC) : SER_RESU ==
+ exprToSeries(e : FE, k : K, state : STATE_REC) : SER_RESU ==
ex : FE := eval(e, [k], [series_x :: FE])
not(is?(k, 'exp)) =>
error "Can only expand with respect to exp"
h := argument(k).1
ss := exprToPS(ex, false, "complex", true, h,
- mrv_bounded(state), mrv_invertible(state))$ppack
+ mrvBounded(state), mrvInvertible(state))$ppack
ss case %problem => "failed"
ssl := ss.%series
kk : Integer := 0
@@ -246,14 +246,14 @@
-- compare comparability classes of two kernels, uses
-- Gruntz Lemma 3.6
- mrv_cmp(x : K, y : K, v : Symbol, state : STATE_REC) : CMP_RESU ==
+ mrvCmp(x : K, y : K, v : Symbol, state : STATE_REC) : CMP_RESU ==
x1 : FE :=
is?(x, "exp" :: Symbol) => argument(x).1
log(x :: FE)
y1 : FE :=
is?(y, "exp" :: Symbol) => argument(y).1
log(y :: FE)
- ppu := mrv_limit(x1/y1, v, state)
+ ppu := mrvLimit(x1/y1, v, state)
ppu case OFE =>
pp1 := ppu::OFE
pp1 = (0::OFE) => [-1, 0]
@@ -267,14 +267,14 @@
-- exponentials
-- as a byproduct we compute list of constanst such that
-- res.i =~ res.1^(res_c.i)
- mrv_set(e : FE, x : Symbol, state : STATE_REC) : SET_RESU ==
+ mrvSet(e : FE, x : Symbol, state : STATE_REC) : SET_RESU ==
kers := tower(e)
res_k : K := kernels(x::FE).1
res : List K := [res_k]
res_c : List FE := [1::FE]
for y in kers repeat
is?(y, "exp" :: Symbol) =>
- icu := mrv_cmp(y, res_k, x, state)
+ icu := mrvCmp(y, res_k, x, state)
icu case "failed" => return "failed"
ic := icu::CMP_RES
i := ic.sign
@@ -298,7 +298,7 @@
-- we assume that simpler kernels are earlier on he list,
-- more precisely, if lx.i is a subexpression of lx.j then
-- i <= j
- mrv_rewrite1(e : FE, lx : List K, ly : List FE) : FE ==
+ mrvRewrite1(e : FE, lx : List K, ly : List FE) : FE ==
rlx := reverse(lx)
rly := reverse(ly)
for x in rlx for y in rly repeat
@@ -315,7 +315,7 @@
--
-- lx.1 is equivalent to omega, but normalized so that it
-- goes to 0 when v goes to infinity
- mrv_rewrite0(e : FE, lx : List K, lc : List FE, x00 : FE) : FE ==
+ mrvRewrite0(e : FE, lx : List K, lc : List FE, x00 : FE) : FE ==
c0 := first lc
(#lx = 1) and (c0 = 1) => e
e0 := argument(kernels(x00).1).1
@@ -330,7 +330,7 @@
else
ly := cons(x00^c0, ly)
lxx := lx
- mrv_rewrite1(e, lxx, ly)
+ mrvRewrite1(e, lxx, ly)
-- Rewrite in terms of mrv kernel and compute leading term of
-- series expansion
@@ -339,13 +339,13 @@
-- lx list of mrv kernels
-- lc coefficients so that lx.i =~ lx.1 ^(lc.i)
-- v variable
- mrv_rewrite(e : FE, lx : List K, lc : List FE, v : Symbol,
+ mrvRewrite(e : FE, lx : List K, lc : List FE, v : Symbol,
state : STATE_REC) : SER_RESU ==
x0 := first lx
-- Shift up, if needed and recurse
is?(x0, v :: Symbol) =>
lxx : List K := [kernels(eval(ei::FE, [x0], [exp(v::FE)])).1 for ei in lx]
- mrv_rewrite(eval(e, [x0], [exp(v::FE)]), lxx, lc, v, state)
+ mrvRewrite(eval(e, [x0], [exp(v::FE)]), lxx, lc, v, state)
-- Sanity check
~ is?(x0, "exp" :: Symbol) =>
error "mrv is not exp, need substitution"
@@ -358,7 +358,7 @@
-- kk := kernels(argument(x0).1)
lip : RESULT :=
e0 = (v::FE) => plusInfinity()@OFE
- mrv_limit(e0, v, state)
+ mrvLimit(e0, v, state)
lip case OFE =>
lipp : OFE := lip :: OFE
ss : Integer := whatInfinity(lipp)
@@ -374,45 +374,45 @@
x00 := x0 :: FE
lxx := lx
-- do the rewrite
- e := mrv_rewrite0(e, lxx, lcc, x00)
- expr_to_series(e, kernels(x00).1, state)
+ e := mrvRewrite0(e, lxx, lcc, x00)
+ exprToSeries(e, kernels(x00).1, state)
error "limit failed"
- mrv_sign(e : FE, v : Symbol, state : STATE_REC
+ mrvSign(e : FE, v : Symbol, state : STATE_REC
) : Union(Integer, "failed") ==
~ member?(v::Symbol, variables(e)) => sign(e)$SIGNEF
-- (s := sign(e)$SIGNEF) case Integer =>
-- return s
-- error "Can not determine sign"
- rkcu := mrv_set(e, v, state)
+ rkcu := mrvSet(e, v, state)
rkcu case "failed" => "failed"
rkc := rkcu::SET_RES
lx := rkc.lk
lcc := rkc.lc
- ssu : SER_RESU := mrv_rewrite(e, lx, lcc, v, state)
+ ssu : SER_RESU := mrvRewrite(e, lx, lcc, v, state)
ssu case "failed" => "failed"
ss := ssu::SER_RES
- mrv_sign(ss.coeff, v, state)
+ mrvSign(ss.coeff, v, state)
-- Compute limit of e when v goes to infinity
- mrv_limit(e : FE, v : Symbol, state : STATE_REC) : RESULT ==
+ mrvLimit(e : FE, v : Symbol, state : STATE_REC) : RESULT ==
~ member?(v, (ve := variables(e))) =>
empty?(setIntersection(ve, state.tan_syms)) and
empty?(setIntersection(ve, state.atan_syms)) => e :: OFE
"failed"
- rkcu := mrv_set(e, v, state)
+ rkcu := mrvSet(e, v, state)
rkcu case "failed" => "failed"
rkc := rkcu::SET_RES
lx := rkc.lk
lcc := rkc.lc
- ssu : SER_RESU := mrv_rewrite(e, lx, lcc, v, state)
+ ssu : SER_RESU := mrvRewrite(e, lx, lcc, v, state)
ssu case "failed" => "failed"
ss := ssu::SER_RES
deg := ss.degree
deg > 0 => 0
- deg = 0 => mrv_limit(ss.coeff, v, state)
+ deg = 0 => mrvLimit(ss.coeff, v, state)
deg < 0 =>
- su := mrv_sign(ss.coeff, v, state)
+ su := mrvSign(ss.coeff, v, state)
su case "failed" => "failed"
s := su::Integer
s = 1 =>
@@ -421,12 +421,12 @@
minusInfinity()
error "Nonzero term has no sign"
- mrv_limit1(e : FE, x : Symbol) : RESULT ==
+ mrvLimit1(e : FE, x : Symbol) : RESULT ==
state := [[], [], [], []]$STATE_REC
- e := mrv_normalize(e, x, state)
- mrv_limit(e, x, state)
+ e := mrvNormalize(e, x, state)
+ mrvLimit(e, x, state)
- mrv_limit(e : FE, eq : EQ OFE) : U ==
+ limit(e : FE, eq : EQ OFE) : U ==
(f := retractIfCan(lhs eq)@Union(FE,"failed")) case "failed" =>
error "limit:left hand side must be a variable"
@@ -439,7 +439,7 @@
-- Case positive infinity
ii = 1 =>
- resu := mrv_limit1(e, v)
+ resu := mrvLimit1(e, v)
resu case "failed" => "failed"
resu::OFE
@@ -448,7 +448,7 @@
-- replace x by -x
vK := retract(v::FE)@Kernel(FE)
et : FE := eval(e, vK, -vK::FE)
- resu := mrv_limit1(et, v)
+ resu := mrvLimit1(et, v)
resu case "failed" => "failed"
resu::OFE
@@ -459,18 +459,18 @@
-- replace x by a - 1/x
et : FE := eval(e, vK, retract(a)@FE - inv(vK::FE))
- ll := mrv_limit1(et, v)
+ ll := mrvLimit1(et, v)
-- replace x by a + 1/x
et : FE := eval(e, vK, retract(a)@FE + inv(vK::FE))
- lr := mrv_limit1(et, v)
+ lr := mrvLimit1(et, v)
ll = lr =>
lr case "failed" => "failed"
lr::OFE
[ll, lr]$TwoSide
- mrv_limit(e : FE, eq : EQ FE, s : String) : RESULT ==
+ limit(e : FE, eq : EQ FE, s : String) : RESULT ==
(f := retractIfCan(lhs eq)@Union(SY,"failed")) case "failed" =>
error "limit:left hand side must be a variable"
@@ -481,12 +481,12 @@
direction(s) = 1 =>
vK := retract(v::FE)@Kernel(FE)
et : FE := eval(e, vK, a + inv(vK::FE))
- mrv_limit1(et, v)
+ mrvLimit1(et, v)
-- From the left: replace x by a - 1/z
direction(s) = -1 =>
vK := retract(v::FE)@Kernel(FE)
et : FE := eval(e, vK, a - inv(vK::FE))
- mrv_limit1(et, v)
+ mrvLimit1(et, v)
@
