113 poly p00=rec(f0,g0,r);
114 poly p11=rec(f1,g1,r);
134 poly pbig=rec(s1,s2,r);
159 poly s1=rec(f0,g1,r);
160 poly s2=rec(g0,f1,r);
278 if ((df==0)||(dg==0))
303 for(i=1;i<=
rVar(r);i++)
345 if (n==0)
return p_ISet(1,r);
354 int field_size=pot_max+1;
355 int* int_pot_array=(
int*)
omAlloc(field_size*
sizeof(
int));
360 for(i=0;i<field_size;i++)
362 int_pot_array[
i]=pot;
367 for(i=1;i<field_size;i++)
369 poly p=pot_array[i-1];
379 assume(work_n>=int_pot_array[field_size-1]);
398 for(i=field_size-1;i>=0;i--)
401 assume(work_n<2*int_pot_array[i]);
402 if(int_pot_array[i]<=work_n)
404 work_n-=int_pot_array[
i];
407 else int_pot_array[
i]=0;
410 for(i=0;i<field_size;i++)
412 if(int_pot_array[i]==1)
422 if(i!=0)
pDelete(&pot_array[i]);
479 for (i=
rVar(r); i!=0; i--)
487 static void buildTermAndAdd(
int ,number* ,
poly* ,
int*
exp,
int f_len,
kBucket_pt ,ring
r, number coef,
poly & zw,
poly ,
poly** term_pot){
507 for(i=0;i<f_len;i++){
528 static void MC_iterate(
poly f,
int n, ring
r,
int f_len,number* facult,
int*
exp,
poly* f_terms,
kBucket_pt erg_bucket,
int pos,
int sum, number coef,
poly & zw,
poly tmp,
poly** term_pot){
535 for(i=0;i<=n-sum;i++)
540 new_coef=
n_Copy(coef,r->cf);
545 number old_rest=
n_Init(n-sum-(i-1),r->cf);
546 new_coef=
n_Mult(new_coef,old_rest,r->cf);
549 number i_number=
n_Init(i,r->cf);
551 new_coef=
n_Div(new_coef,i_number,r->cf);
560 MC_iterate(f, n, r, f_len,facult, exp,f_terms,erg_bucket,pos+1,sum+i,new_coef,zw_real,tmp,term_pot);
582 number new_coef=
n_Copy(coef,r->cf);
583 buildTermAndAdd(n,facult,f_terms,exp,f_len,erg_bucket,r, new_coef,zw, tmp,term_pot);
593 WerrorS(
"Char not 0, pFastPowerMC not implemented for this case");
595 WerrorS(
"not implemented for so small n, recursion fails");
597 WerrorS(
"not implemented for so small length of f, recursion fails");
599 number* facult=(number*)
omAlloc((n+1)*
sizeof(number));
600 facult[0]=
n_Init(1,r->cf);
604 number this_n=
n_Init(i,r->cf);
605 facult[
i]=
n_Mult(this_n,facult[i-1],r->cf);
623 f_iter=
pNext(f_iter);
628 term_potences[
i][0]=
p_ISet(1,r);
631 term_potences[
i][
j]=
p_MonMultCMB(f_terms[i],term_potences[i][j-1],r);
637 number one=
n_Init(1,r->cf);
638 MC_iterate(f,n,r,f_len,&facult[0], &exp[0], &f_terms[0],erg_bucket,0,0,one,zw,tmp, term_potences);
653 for (i=0;i<f_len;i++)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
poly pFastPower(poly f, int n, ring r)
const CanonicalForm int const CFList const Variable & y
void kBucketInit(kBucket_pt bucket, poly lm, int length)
poly fastmultrec(poly f, poly g, ring r)
static int min(int a, int b)
static void p_MonMultMB(poly p, poly q, ring r)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
static poly p_Mult_mm(poly p, poly m, const ring r)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static short rVar(const ring r)
#define rVar(r) (r->N)
poly pFastPowerMC(poly f, int n, ring r)
#define omUnGetSpecBin(bin_ptr)
static void degsplit(poly p, int n, poly &p1, poly &p2, int vn, ring r)
static poly pp_Mult_mm(poly p, poly m, const ring r)
static poly do_unifastmult(poly f, int df, poly g, int dg, int vn, fastmultrec rec, ring r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
void WerrorS(const char *s)
static long p_MultExp(poly p, int v, long ee, ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
static const int pass_option
static poly p_Copy(poly p, const ring r)
returns a copy of p
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void kBucketDestroy(kBucket_pt *bucket_pt)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
static int max(int a, int b)
poly multifastmult(poly f, poly g, ring r)
static poly pp_Mult_qq(poly p, poly q, const ring r)
static void div_by_x_power_n(poly p, int n, int vn, ring r)
static poly p_MonMultCMB(poly p, poly q, ring r)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
static unsigned pLength(poly a)
void p_Normalize(poly p, const ring r)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
static void MC_iterate(poly f, int n, ring r, int f_len, number *facult, int *exp, poly *f_terms, kBucket_pt erg_bucket, int pos, int sum, number coef, poly &zw, poly tmp, poly **term_pot)
static void p_Setm(poly p, const ring r)
static void buildTermAndAdd(int, number *, poly *, int *exp, int f_len, kBucket_pt, ring r, number coef, poly &zw, poly, poly **term_pot)
static poly p_Neg(poly p, const ring r)
#define p_SetCoeff0(p, n, r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
static poly p_Init(const ring r, omBin bin)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
poly unifastmult(poly f, poly g, ring r)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.