version 1.13, 2003/08/26 12:46:03 |
version 1.15, 2003/08/29 04:34:07 |
|
|
% $OpenXM: OpenXM/src/kan96xx/Doc/ecart.sm1,v 1.12 2003/08/26 05:06:00 takayama Exp $ |
% $OpenXM: OpenXM/src/kan96xx/Doc/ecart.sm1,v 1.14 2003/08/27 03:11:13 takayama Exp $ |
%[(parse) (hol.sm1) pushfile] extension |
%[(parse) (hol.sm1) pushfile] extension |
%[(parse) (appell.sm1) pushfile] extension |
%[(parse) (appell.sm1) pushfile] extension |
|
|
|
|
[(EcartAutomaticHomogenization) 0] system_variable |
[(EcartAutomaticHomogenization) 0] system_variable |
} def |
} def |
|
|
|
/ecart.setOpt { |
|
/arg1 set |
|
[/in-ecart.setOpt /opt /i /n /ans] pushVariables |
|
[ |
|
/opt arg1 def |
|
/ans [ ] def |
|
/n opt length def |
|
0 2 n 1 sub { |
|
/i set |
|
opt i get tag StringP eq not { |
|
(ecart.setOpt : [keyword value keyword value ....] ) error |
|
} { } ifelse |
|
{ % start of the loop |
|
% Global: degreeShift |
|
opt i get (degreeShift) eq { |
|
/degreeShift opt i 1 add get def |
|
exit |
|
} { } ifelse |
|
% Global: hdShift |
|
opt i get (startingShift) eq { |
|
/hdShift opt i 1 add get def |
|
exit |
|
} { } ifelse |
|
% Global: hdShift |
|
opt i get (noAutoHomogenize) eq { |
|
/hdShift -1 def |
|
exit |
|
} { } ifelse |
|
ans [opt i get opt i 1 add get ] append /ans set |
|
exit |
|
} loop |
|
} for |
|
|
|
ecart.gb.verbose { |
|
(ecart.setOpt:) message |
|
(degreeShift=) messagen degreeShift message |
|
$hdShift(startingShift)=$ messagen hdShift message |
|
(Other options=) messagen ans message |
|
} { } ifelse |
|
|
|
/arg1 ans def |
|
] pop |
|
popVariables |
|
arg1 |
|
} def |
|
|
/ecart.dehomogenize { |
/ecart.dehomogenize { |
/arg1 set |
/arg1 set |
[/in.ecart.dehomogenize /ll /rr] pushVariables |
[/in.ecart.dehomogenize /ll /rr] pushVariables |
|
|
(a : [f ]; array f; f is a set of generators of an ideal in a ring.) |
(a : [f ]; array f; f is a set of generators of an ideal in a ring.) |
(a : [f v]; array f; string v; v is the variables. ) |
(a : [f v]; array f; string v; v is the variables. ) |
(a : [f v w]; array f; string v; array of array w; w is the weight matirx.) |
(a : [f v w]; array f; string v; array of array w; w is the weight matirx.) |
(a : [f v w ds]; array f; string v; array of array w; w is the weight matirx.) |
$a : [f v w [(degreeShift) ds]]; array f; string v; array of array w; w is the weight matirx.$ |
( array ds; ds is the degree shift for the ring. ) |
( array ds; ds is the degree shift for the ring. ) |
(a : [f v w ds hdShift]; array f; string v; array of array w; w is the weight matirx.) |
$a : [f v w [(degreeShift) ds (startingShift) hdShift]]; array f; string v; array of array w; w is the weight matirx.$ |
( array ds; ds is the degree shift for the ring. ) |
( array ds; ds is the degree shift for the ring. ) |
( array hsShift is the degree shift for the homogenization. cf.homogenize ) |
( array hsShift is the degree shift for the homogenization. cf.homogenize ) |
$a : [f v w ds (no)]; array f; string v; array of array w; w is the weight matirx.$ |
$a : [f v w [(degreeShift) ds (noAutoHomogenize) 1]]; array f; string v; array of array w; w is the weight matirx.$ |
( No automatic homogenization.) |
( No automatic homogenization.) |
( ) |
( ) |
$cf. ecarth.gb (homogenized), ecartd.gb (dehomogenize) $ |
$cf. ecarth.gb (homogenized), ecartd.gb (dehomogenize) $ |
|
|
( This example will cause an error on order.) |
( This example will cause an error on order.) |
( ) |
( ) |
$Example 5: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $ |
$Example 5: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $ |
$ [ [(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1] ] [[0 1] [-3 1] ] ] ecart.gb pmat ; $ |
$ [ [(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1] ] $ |
|
$ [(degreeShift) [[0 1] [-3 1]]] ] ecart.gb pmat ; $ |
( ) |
( ) |
(cf. gb, groebner, ecarth.gb, ecartd.gb, ecart.syz, ecart.begin, ecart.end, ecart.homogenize01, ) |
(cf. gb, groebner, ecarth.gb, ecartd.gb, ecart.syz, ecart.begin, ecart.end, ecart.homogenize01, ) |
( ecart.dehomogenize, ecart.dehomogenizeH) |
( ecart.dehomogenize, ecart.dehomogenizeH) |
|
|
/wv aa 2 get def |
/wv aa 2 get def |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
|
|
typev [ArrayP StringP ArrayP ArrayP] eq |
typev [ArrayP StringP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get def |
/v aa 1 get def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
|
|
typev [ArrayP StringP ArrayP ArrayP ArrayP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
/hdShift aa 4 get def |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP ArrayP ArrayP ArrayP] eq |
typev [ArrayP ArrayP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get from_records def |
/v aa 1 get from_records def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
typev [ArrayP ArrayP ArrayP ArrayP ArrayP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get from_records def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
/hdShift aa 4 get def |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP ArrayP ArrayP ArrayP StringP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get from_records def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
aa 4 get (no) eq { |
|
/hdShift -1 def |
|
} { |
|
(Unknown keyword for the 5th argument) error |
|
} ifelse |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP StringP ArrayP ArrayP StringP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
aa 4 get (no) eq { |
|
/hdShift -1 def |
|
} { |
|
(Unknown keyword for the 5th argument) error |
|
} ifelse |
|
/setarg 1 def |
|
} { } ifelse |
|
|
|
/env1 getOptions def |
/env1 getOptions def |
|
|
|
|
(a : [f ]; array f; f is a set of generators of an ideal in a ring.) |
(a : [f ]; array f; f is a set of generators of an ideal in a ring.) |
(a : [f v]; array f; string v; v is the variables. ) |
(a : [f v]; array f; string v; v is the variables. ) |
(a : [f v w]; array f; string v; array of array w; w is the weight matirx.) |
(a : [f v w]; array f; string v; array of array w; w is the weight matirx.) |
(a : [f v w ds]; array f; string v; array of array w; w is the weight matirx.) |
$a : [f v w [(degreeShift) ds]]; array f; string v; array of array w; w is the weight matirx.$ |
( array ds; ds is the degree shift ) |
( array ds; ds is the degree shift ) |
( ) |
( ) |
(/ecart.autoHomogenize 0 def ) |
(/ecart.autoHomogenize 0 def ) |
|
|
$ [ [ (x) -1 (y) -1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecarth.gb pmat ; $ |
$ [ [ (x) -1 (y) -1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecarth.gb pmat ; $ |
( ) |
( ) |
$Example 5: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $ |
$Example 5: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $ |
$ [ [(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1] ] [[0 1] [-3 1] ] ] ecarth.gb pmat ; (buggy infinite loop)$ |
$ [ [(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1] ] $ |
|
$ [(degreeShift) [[0 1] [-3 1] ]] ] ecarth.gb pmat ; $ |
( ) |
( ) |
(cf. gb, groebner, ecart.gb, ecartd.gb, ecart.syz, ecart.begin, ecart.end, ecart.homogenize01, ) |
(cf. gb, groebner, ecart.gb, ecartd.gb, ecart.syz, ecart.begin, ecart.end, ecart.homogenize01, ) |
( ecart.dehomogenize, ecart.dehomogenizeH) |
( ecart.dehomogenize, ecart.dehomogenizeH) |
|
|
/wv aa 2 get def |
/wv aa 2 get def |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
|
|
typev [ArrayP StringP ArrayP ArrayP] eq |
typev [ArrayP StringP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get def |
/v aa 1 get def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
typev [ArrayP ArrayP ArrayP ArrayP] eq |
typev [ArrayP ArrayP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get from_records def |
/v aa 1 get from_records def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
|
|
|
|
/wv aa 2 get def |
/wv aa 2 get def |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
|
|
typev [ArrayP StringP ArrayP ArrayP] eq |
typev [ArrayP StringP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get def |
/v aa 1 get def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
typev [ArrayP ArrayP ArrayP ArrayP] eq |
typev [ArrayP ArrayP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get from_records def |
/v aa 1 get from_records def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
typev [ArrayP StringP ArrayP ArrayP ArrayP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
/hdShift aa 4 get def |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP ArrayP ArrayP ArrayP ArrayP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get from_records def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
/hdShift aa 4 get def |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP ArrayP ArrayP ArrayP StringP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get from_records def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
aa 4 get (no) eq { |
|
/hdShift -1 def |
|
} { |
|
(Unknown keyword for the 5th argument) error |
|
} ifelse |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP StringP ArrayP ArrayP StringP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get def |
|
/wv aa 2 get def |
|
/degreeShift aa 3 get def |
|
aa 4 get (no) eq { |
|
/hdShift -1 def |
|
} { |
|
(Unknown keyword for the 5th argument) error |
|
} ifelse |
|
/setarg 1 def |
|
} { } ifelse |
|
|
|
/env1 getOptions def |
/env1 getOptions def |
|
|
|
|
/shift [ [1 0 1 0 0] ] def |
/shift [ [1 0 1 0 0] ] def |
/weight [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] def |
/weight [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] def |
|
|
[ff (t,x,y) weight shift nmshift] ecart.minimalBase |
[ff (t,x,y) weight [(degreeShift) shift (startingShift) nmshift]] ecart.minimalBase |
|
|
|
|
} def |
} def |
|
|
arg1 |
arg1 |
} def |
} def |
|
|
|
/ecart.isZeroRow { |
|
/arg1 set |
|
[/in-ecart.isZeroRow /aa /i /n /yes] pushVariables |
|
[ |
|
/aa arg1 def |
|
aa length /n set |
|
/yes 1 def |
|
0 1 n 1 sub { |
|
/i set |
|
aa i get (0). eq { |
|
} { |
|
/yes 0 def |
|
} ifelse |
|
} for |
|
/arg1 yes def |
|
] pop |
|
popVariables |
|
arg1 |
|
} def |
|
|
|
/ecart.removeZeroRow { |
|
/arg1 set |
|
[/in-ecart.removeZeroRow /aa /i /n /ans] pushVariables |
|
[ |
|
/aa arg1 def |
|
aa length /n set |
|
/ans [ ] def |
|
0 1 n 1 sub { |
|
/i set |
|
aa i get ecart.isZeroRow { |
|
} { |
|
ans aa i get append /ans set |
|
} ifelse |
|
} for |
|
/arg1 ans def |
|
] pop |
|
popVariables |
|
arg1 |
|
} def |
|
|
|
/ecart.gen_input { |
|
/arg1 set |
|
[/in-ecart.gen_input /aa /typev /setarg /f /v |
|
/gg /wv /vec /ans /rr /mm |
|
/degreeShift /env2 /opt /ss0 |
|
/hdShift /ff |
|
] pushVariables |
|
[ |
|
/aa arg1 def |
|
aa isArray { } { ( << array >> ecart.gen_input) error } ifelse |
|
/setarg 0 def |
|
/wv 0 def |
|
/degreeShift 0 def |
|
/hdShift 0 def |
|
/opt [ ] def |
|
aa { tag } map /typev set |
|
typev [ArrayP StringP ArrayP ArrayP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get def |
|
/wv aa 2 get def |
|
opt aa 3 get ecart.setOpt join /opt set |
|
/setarg 1 def |
|
} { } ifelse |
|
typev [ArrayP ArrayP ArrayP ArrayP] eq |
|
{ /f aa 0 get def |
|
/v aa 1 get from_records def |
|
/wv aa 2 get def |
|
opt aa 3 get ecart.setOpt join /opt set |
|
/setarg 1 def |
|
} { } ifelse |
|
setarg { } { (ecart.minimalBase : Argument mismatch) error } ifelse |
|
|
|
[(KanGBmessage) ecart.gb.verbose ] system_variable |
|
|
|
f 0 get tag ArrayP eq { } |
|
{ f { /tt set [ tt ] } map /f set } ifelse |
|
|
|
[f v wv [(degreeShift) degreeShift (startingShift) [hdShift 0 get degreeShift 0 get]] opt join] |
|
ecart.gb /ff set |
|
ff getRing ring_def |
|
|
|
ff 0 get { {toString } map } map /ff set |
|
|
|
[ff v wv |
|
[(degreeShift) degreeShift (startingShift) [hdShift 0 get degreeShift 0 get]] opt join |
|
] /arg1 set |
|
] pop |
|
popVariables |
|
arg1 |
|
} def |
|
[(ecart.gen_input) |
|
[$[ff v weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]] ] ecart.gen_input $ |
|
$ [gg_h v weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]]] $ |
|
(It generates the input for the minimal filtered free resolution.) |
|
(Current ring is changed to the ring of gg_h.) |
|
(cf. ecart.minimalBase) |
|
$Example: [ [(t-x^3+y^2) (Dx+ 3 x^2 Dt) (Dy - 2 y Dt)] (t,x,y) $ |
|
$ [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] $ |
|
$ [(degreeShift) [ [0] ] $ |
|
$ (startingShift) [ [0] [0] ]] ] ecart.gen_input /gg set gg pmat $ |
|
]] putUsages |
|
|
|
|
[(ecart.minimalBase) |
[(ecart.minimalBase) |
[([ff v weight_vector degreeShift [D_shift_n uv_shift_m]] ecart.minimalBase mbase) |
[$[ff v weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]]] ecart.minimalBase $ |
|
( [mbase gr_of_mbase ) |
|
$ [syz v weight_vector [(degreeShift) new_uv_shift_m (startingShift) [new_D_shift_n new_uv_shift_m]]]$ |
|
( gr_of_syz ]) |
|
(mbase is the minimal generators of ff in D^h in the sense of filtered minimal) |
|
(generators.) |
|
$Example: [ [(t-x^3+y^2) (Dx+ 3 x^2 Dt) (Dy - 2 y Dt)] (t,x,y) $ |
|
$ [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] $ |
|
$ [(degreeShift) [ [0] ] $ |
|
$ (startingShift) [ [0] [0] ] ] ] ecart.gen_input /gg0 set $ |
|
$ gg0 ecart.minimalBase /ss0 set $ |
|
$ ss0 2 get ecart.minimalBase /ss1 set $ |
|
$ ss1 2 get ecart.minimalBase /ss2 set $ |
|
$ (--------- minimal filtered resolution -------) message $ |
|
$ ss0 0 get pmat ss1 0 get pmat ss2 0 get pmat $ |
|
$ (--------- degree shift (n,m) n:D-shift m:uv-shift -------) message $ |
|
$ gg0 3 get 3 get message $ |
|
$ ss0 2 get 3 get 3 get message $ |
|
$ ss1 2 get 3 get 3 get message $ |
|
$ ss2 2 get 3 get 3 get message ; $ |
|
|
]] putUsages |
]] putUsages |
/ecart.minimalBase { |
/ecart.minimalBase { |
/arg1 set |
/arg1 set |
|
|
/wv 0 def |
/wv 0 def |
/degreeShift 0 def |
/degreeShift 0 def |
/hdShift 0 def |
/hdShift 0 def |
|
/opt [ ] def |
aa { tag } map /typev set |
aa { tag } map /typev set |
typev [ArrayP StringP ArrayP ArrayP ArrayP] eq |
typev [ArrayP StringP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get def |
/v aa 1 get def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/hdShift aa 4 get def |
|
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
typev [ArrayP ArrayP ArrayP ArrayP ArrayP] eq |
typev [ArrayP ArrayP ArrayP ArrayP] eq |
{ /f aa 0 get def |
{ /f aa 0 get def |
/v aa 1 get from_records def |
/v aa 1 get from_records def |
/wv aa 2 get def |
/wv aa 2 get def |
/degreeShift aa 3 get def |
opt aa 3 get ecart.setOpt join /opt set |
/hdShift aa 4 get def |
|
/setarg 1 def |
/setarg 1 def |
} { } ifelse |
} { } ifelse |
setarg { } { (ecart.minimalBase : Argument mismatch) error } ifelse |
setarg { } { (ecart.minimalBase : Argument mismatch) error } ifelse |
|
|
|
|
f 0 get tag ArrayP eq { } |
f 0 get tag ArrayP eq { } |
{ f { /tt set [ tt ] } map /f set } ifelse |
{ f { /tt set [ tt ] } map /f set } ifelse |
[f v wv degreeShift (no)] ecart.syz /ss0 set |
[f v wv [(degreeShift) degreeShift (noAutoHomogenize) 1] opt join] ecart.syz /ss0 set |
|
|
ss0 getRing ring_def |
ss0 getRing ring_def |
/degreeShiftD hdShift 0 get def |
/degreeShiftD hdShift 0 get def |
|
|
|
|
%C Note 2003.8.26 |
%C Note 2003.8.26 |
|
|
|
ai [ ] eq { |
|
exit |
|
} { } ifelse |
|
|
/s ai length def |
/s ai length def |
/r ai 0 get length def |
/r ai 0 get length def |
|
|
|
|
} for |
} for |
|
|
% ( ) error |
% ( ) error |
/ai1 ai1_new def |
/ai1 ai1_new def |
/ai ai_new2 def |
/ai ai_new2 ecart.removeZeroRow def |
|
|
} loop |
} loop |
/arg1 ai1 def |
/arg1 |
|
[ ai1 |
|
ai1 {[wv 0 get weightv degreeShift 0 get] init} map %Getting gr of A_{i-1} |
|
[ai v wv [(degreeShift) [degreeShiftUVnew] (startingShift) [degreeShiftDnew degreeShiftUVnew]]] |
|
ai {[wv 0 get weightv degreeShiftUVnew] init} map %Getting gr of A_i |
|
] |
|
def |
] pop |
] pop |
popVariables |
popVariables |
arg1 |
arg1 |
} def |
} def |
|
|
|
/ecart.minimalResol { |
|
/arg1 set |
|
[/in-ecart.minimalResol /aa /ans /gg0 /ansds /ans_gr /c] pushVariables |
|
[ |
|
/aa arg1 def |
|
/ans [ ] def |
|
/ansds [ ] def |
|
/ans_gr [ ] def |
|
/c 0 def |
|
|
|
(---- ecart.gen_input ----) message |
|
aa ecart.gen_input /gg0 set |
|
ansds gg0 3 get 3 get append /ansds set |
|
(---- ecart.minimalBase --- Degree ) messagen c message c 1 add /c set |
|
gg0 ecart.minimalBase /ssi set |
|
ansds ssi 2 get 3 get 3 get append /ansds set |
|
ans ssi 0 get append /ans set |
|
ans_gr ssi 1 get append /ans_gr set |
|
{ |
|
ssi 3 get [ ] eq { exit } { } ifelse |
|
(---- ecart.minimalBase --- Degree ) messagen c message c 1 add /c set |
|
ssi 2 get ecart.minimalBase /ssi_new set |
|
ans ssi_new 0 get append /ans set |
|
ansds ssi_new 2 get 3 get 3 get append /ansds set |
|
ans_gr ssi_new 1 get append /ans_gr set |
|
/ssi ssi_new def |
|
} loop |
|
/arg1 [ans ansds ans_gr] def |
|
] pop |
|
popVariables |
|
arg1 |
|
} def |
|
|
|
(ecart.minimalResol) message |
|
|
|
[(ecart.minimalResol) |
|
[ |
|
|
|
$[ff v weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]]] ecart.minimalResol $ |
|
( [resol degree_shifts gr_of_resol_by_uv_shift_m] ) |
|
$Example1: [ [(t-x^3+y^2) (Dx+ 3 x^2 Dt) (Dy - 2 y Dt)] (t,x,y) $ |
|
$ [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] $ |
|
$ [(degreeShift) [ [0] ] $ |
|
$ (startingShift) [ [0] [0] ] ] ] ecart.minimalResol /gg set gg pmat $ |
|
]] putUsages |
|
|
( ) message-quiet |
( ) message-quiet |
|
|