Data Structures | Macros | Typedefs | Functions | Variables
sparsmat.cc File Reference
#include <misc/auxiliary.h>
#include <omalloc/omalloc.h>
#include <misc/mylimits.h>
#include <misc/options.h>
#include <reporter/reporter.h>
#include <misc/intvec.h>
#include <coeffs/numbers.h>
#include "coeffrings.h"
#include "monomials/ring.h"
#include "monomials/p_polys.h"
#include "simpleideals.h"
#include "sparsmat.h"
#include "prCopy.h"
#include "templates/p_Procs.h"
#include "kbuckets.h"
#include "operations/p_Mult_q.h"

Go to the source code of this file.

Data Structures

struct  sm_prec
 
class  sparse_mat
 
struct  sm_nrec
 
class  sparse_number_mat
 

Macros

#define SM_MIN_LENGTH_BUCKET   MIN_LENGTH_BUCKET - 5
 

Typedefs

typedef sm_prec * smpoly
 
typedef sm_nrec * smnumber
 

Functions

static void sm_ExactPolyDiv (poly, poly, const ring)
 
static BOOLEAN sm_IsNegQuot (poly, const poly, const poly, const ring)
 
static void sm_ExpMultDiv (poly, const poly, const poly, const ring)
 
static void sm_PolyDivN (poly, const number, const ring)
 
static BOOLEAN smSmaller (poly, poly)
 
static void sm_CombineChain (poly *, poly, const ring)
 
static void sm_FindRef (poly *, poly *, poly, const ring)
 
static void sm_ElemDelete (smpoly *, const ring)
 
static smpoly smElemCopy (smpoly)
 
static float sm_PolyWeight (smpoly, const ring)
 
static smpoly sm_Poly2Smpoly (poly, const ring)
 
static poly sm_Smpoly2Poly (smpoly, const ring)
 
static BOOLEAN sm_HaveDenom (poly, const ring)
 
static number sm_Cleardenom (ideal, const ring)
 
static poly pp_Mult_Coeff_mm_DivSelect_MultDiv (poly p, int &lp, poly m, poly a, poly b, const ring currRing)
 
static poly sm_SelectCopy_ExpMultDiv (poly p, poly m, poly a, poly b, const ring currRing)
 
static void smMinSelect (long *, int, int)
 
long sm_ExpBound (ideal m, int di, int ra, int t, const ring currRing)
 
ring sm_RingChange (const ring origR, long bound)
 
void sm_KillModifiedRing (ring r)
 
BOOLEAN sm_CheckDet (ideal I, int d, BOOLEAN sw, const ring r)
 
poly sm_CallDet (ideal I, const ring R)
 
void sm_CallBareiss (ideal I, int x, int y, ideal &M, intvec **iv, const ring R)
 
void sm_PolyDiv (poly a, poly b, const ring R)
 
poly sm_MultDiv (poly a, poly b, const poly c, const ring R)
 
void sm_SpecialPolyDiv (poly a, poly b, const ring R)
 
static void sm_NumberDelete (smnumber *, const ring R)
 
static smnumber smNumberCopy (smnumber)
 
static smnumber sm_Poly2Smnumber (poly, const ring)
 
static poly sm_Smnumber2Poly (number, const ring)
 
static BOOLEAN smCheckSolv (ideal)
 
ideal sm_CallSolv (ideal I, const ring R)
 

Variables

omBin smprec_bin = omGetSpecBin(sizeof(smprec))
 
static omBin smnrec_bin = omGetSpecBin(sizeof(smnrec))
 

Data Structure Documentation

struct smprec

Definition at line 53 of file sparsmat.cc.

Data Fields
int e
float f
poly m
smpoly n
int pos
struct smnrec

Definition at line 2314 of file sparsmat.cc.

Data Fields
number m
smnumber n
int pos

Macro Definition Documentation

#define SM_MIN_LENGTH_BUCKET   MIN_LENGTH_BUCKET - 5

Definition at line 46 of file sparsmat.cc.

Typedef Documentation

typedef sm_nrec* smnumber

Definition at line 2313 of file sparsmat.cc.

typedef sm_prec* smpoly

Definition at line 52 of file sparsmat.cc.

Function Documentation

static poly pp_Mult_Coeff_mm_DivSelect_MultDiv ( poly  p,
int &  lp,
poly  m,
poly  a,
poly  b,
const ring  currRing 
)
static

Definition at line 82 of file sparsmat.cc.

84 {
85  if (rOrd_is_Comp_dp(currRing) && currRing->ExpL_Size > 2)
86  {
87  // pp_Mult_Coeff_mm_DivSelectMult only works for (c/C,dp) and
88  // ExpL_Size > 2
89  // should be generalized, at least to dp with ExpL_Size == 2
90  // (is the case for 1 variable)
91  int shorter;
92  p = currRing->p_Procs->pp_Mult_Coeff_mm_DivSelectMult(p, m, a, b,
93  shorter, currRing);
94  lp -= shorter;
95  }
96  else
97  {
100  }
101  return p;
102 }
static void sm_ExpMultDiv(poly, const poly, const poly, const ring)
Definition: sparsmat.cc:1987
const poly a
Definition: syzextra.cc:212
return P p
Definition: myNF.cc:203
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int m
Definition: cfEzgcd.cc:119
static BOOLEAN rOrd_is_Comp_dp(const ring r)
Definition: ring.h:771
const poly b
Definition: syzextra.cc:213
static poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
Definition: p_polys.h:1001
void sm_CallBareiss ( ideal  I,
int  x,
int  y,
ideal &  M,
intvec **  iv,
const ring  R 
)

Definition at line 404 of file sparsmat.cc.

405 {
406  int r=id_RankFreeModule(I,R),t=r;
407  int c=IDELEMS(I),s=c;
408  long bound;
409  ring tmpR;
410  sparse_mat *bareiss;
411 
412  if ((x>0) && (x<t))
413  t-=x;
414  if ((y>1) && (y<s))
415  s-=y;
416  if (t>s) t=s;
417  bound=sm_ExpBound(I,c,r,t,R);
418  tmpR=sm_RingChange(R,bound);
419  ideal II = idrCopyR(I, R, tmpR);
420  bareiss = new sparse_mat(II,tmpR);
421  if (bareiss->smGetAct() == NULL)
422  {
423  delete bareiss;
424  *iv=new intvec(1,rVar(tmpR));
425  }
426  else
427  {
428  id_Delete(&II,tmpR);
429  bareiss->smNewBareiss(x, y);
430  II = bareiss->smRes2Mod();
431  *iv = new intvec(bareiss->smGetRed());
432  bareiss->smToIntvec(*iv);
433  delete bareiss;
434  II = idrMoveR(II,tmpR,R);
435  }
436  sm_KillModifiedRing(tmpR);
437  M=II;
438 }
int smGetRed()
Definition: sparsmat.cc:179
const CanonicalForm int s
Definition: facAbsFact.cc:55
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:263
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
Definition: sparsmat.cc:194
#define M
Definition: sirandom.c:24
void smNewBareiss(int, int)
Definition: sparsmat.cc:606
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:16
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
const ring R
Definition: DebugPrint.cc:36
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:249
#define IDELEMS(i)
Definition: simpleideals.h:24
#define NULL
Definition: omList.c:10
ideal smRes2Mod()
Definition: sparsmat.cc:505
void sm_KillModifiedRing(ring r)
Definition: sparsmat.cc:294
Variable x
Definition: cfModGcd.cc:4023
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:193
void smToIntvec(intvec *)
Definition: sparsmat.cc:521
smpoly * smGetAct()
Definition: sparsmat.cc:178
poly sm_CallDet ( ideal  I,
const ring  R 
)

Definition at line 359 of file sparsmat.cc.

360 {
361  if (I->ncols != I->rank)
362  {
363  Werror("det of %ld x %d module (matrix)",I->rank,I->ncols);
364  return NULL;
365  }
366  int r=id_RankFreeModule(I,R);
367  if (I->ncols != r) // some 0-lines at the end
368  {
369  return NULL;
370  }
371  long bound=sm_ExpBound(I,r,r,r,R);
372  number diag,h=n_Init(1,R->cf);
373  poly res;
374  ring tmpR;
375  sparse_mat *det;
376  ideal II;
377 
378  tmpR=sm_RingChange(R,bound);
379  II = idrCopyR(I, R, tmpR);
380  diag = sm_Cleardenom(II,tmpR);
381  det = new sparse_mat(II,tmpR);
382  id_Delete(&II,tmpR);
383  if (det->smGetAct() == NULL)
384  {
385  delete det;
386  sm_KillModifiedRing(tmpR);
387  return NULL;
388  }
389  res=det->smDet();
390  if(det->smGetSign()<0) res=p_Neg(res,tmpR);
391  delete det;
392  res = prMoveR(res, tmpR, R);
393  sm_KillModifiedRing(tmpR);
394  if (!n_Equal(diag,h,R->cf))
395  {
396  p_Mult_nn(res,diag,R);
397  p_Normalize(res,R);
398  }
399  n_Delete(&diag,R->cf);
400  n_Delete(&h,R->cf);
401  return res;
402 }
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:263
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
int smGetSign()
Definition: sparsmat.cc:177
poly prMoveR(poly &p, ring src_r, ring dest_r)
Definition: prCopy.cc:91
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
static number sm_Cleardenom(ideal, const ring)
Definition: sparsmat.cc:2279
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
Definition: sparsmat.cc:194
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
const ring R
Definition: DebugPrint.cc:36
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:902
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3621
#define NULL
Definition: omList.c:10
void sm_KillModifiedRing(ring r)
Definition: sparsmat.cc:294
poly smDet()
Definition: sparsmat.cc:532
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:461
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:193
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1018
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
void Werror(const char *fmt,...)
Definition: reporter.cc:199
smpoly * smGetAct()
Definition: sparsmat.cc:178
ideal sm_CallSolv ( ideal  I,
const ring  R 
)

Definition at line 2372 of file sparsmat.cc.

2373 {
2374  sparse_number_mat *linsolv;
2375  ring tmpR;
2376  ideal rr;
2377 
2378  if (id_IsConstant(I,R)==FALSE)
2379  {
2380  WerrorS("symbol in equation");
2381  return NULL;
2382  }
2383  I->rank = id_RankFreeModule(I,R);
2384  if (smCheckSolv(I)) return NULL;
2385  tmpR=sm_RingChange(R,1);
2386  rr=idrCopyR(I,R, tmpR);
2387  linsolv = new sparse_number_mat(rr,tmpR);
2388  rr=NULL;
2389  linsolv->smTriangular();
2390  if (linsolv->smIsSing() == 0)
2391  {
2392  linsolv->smSolv();
2393  rr = linsolv->smRes2Ideal();
2394  }
2395  else
2396  WerrorS("singular problem for linsolv");
2397  delete linsolv;
2398  if (rr!=NULL)
2399  rr = idrMoveR(rr,tmpR,R);
2400  sm_KillModifiedRing(tmpR);
2401  return rr;
2402 }
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:263
#define FALSE
Definition: auxiliary.h:140
ideal smRes2Ideal()
Definition: sparsmat.cc:2562
BOOLEAN id_IsConstant(ideal id, const ring r)
test if the ideal has only constant polynomials NOTE: zero ideal/module is also constant ...
void WerrorS(const char *s)
Definition: feFopen.cc:24
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static BOOLEAN smCheckSolv(ideal)
Definition: sparsmat.cc:2945
const ring R
Definition: DebugPrint.cc:36
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:249
#define NULL
Definition: omList.c:10
void sm_KillModifiedRing(ring r)
Definition: sparsmat.cc:294
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:193
BOOLEAN sm_CheckDet ( ideal  I,
int  d,
BOOLEAN  sw,
const ring  r 
)

Definition at line 308 of file sparsmat.cc.

309 {
310  int s,t,i;
311  poly p;
312 
313  if (d>100)
314  return sw;
315  if (!rField_is_Q(r))
316  return sw;
317  s = t = 0;
318  if (sw)
319  {
320  for(i=IDELEMS(I)-1;i>=0;i--)
321  {
322  p=I->m[i];
323  if (p!=NULL)
324  {
325  if(!p_IsConstant(p,r))
326  return sw;
327  s++;
328  t+=n_Size(pGetCoeff(p),r->cf);
329  }
330  }
331  }
332  else
333  {
334  for(i=IDELEMS(I)-1;i>=0;i--)
335  {
336  p=I->m[i];
337  if (!p_IsConstantPoly(p,r))
338  return sw;
339  while (p!=NULL)
340  {
341  s++;
342  t+=n_Size(pGetCoeff(p),r->cf);
343  pIter(p);
344  }
345  }
346  }
347  s*=15;
348  if (t>s)
349  return !sw;
350  else
351  return sw;
352 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
return P p
Definition: myNF.cc:203
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1784
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:461
#define IDELEMS(i)
Definition: simpleideals.h:24
#define NULL
Definition: omList.c:10
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:1798
polyrec * poly
Definition: hilb.h:10
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition: coeffs.h:571
static number sm_Cleardenom ( ideal  id,
const ring  R 
)
static

Definition at line 2279 of file sparsmat.cc.

2280 {
2281  poly a;
2282  number x,y,res=n_Init(1,R->cf);
2283  BOOLEAN sw=FALSE;
2284 
2285  for (int i=0; i<IDELEMS(id); i++)
2286  {
2287  a = id->m[i];
2288  sw = sm_HaveDenom(a,R);
2289  if (sw) break;
2290  }
2291  if (!sw) return res;
2292  for (int i=0; i<IDELEMS(id); i++)
2293  {
2294  a = id->m[i];
2295  if (a!=NULL)
2296  {
2297  x = n_Copy(pGetCoeff(a),R->cf);
2298  p_Cleardenom(a, R);
2299  y = n_Div(x,pGetCoeff(a),R->cf);
2300  n_Delete(&x,R->cf);
2301  x = n_Mult(res,y,R->cf);
2302  n_Normalize(x,R->cf);
2303  n_Delete(&res,R->cf);
2304  res = x;
2305  }
2306  }
2307  return res;
2308 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
poly res
Definition: myNF.cc:322
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:635
const ring R
Definition: DebugPrint.cc:36
static BOOLEAN sm_HaveDenom(poly, const ring)
Definition: sparsmat.cc:2260
int i
Definition: cfEzgcd.cc:123
#define IDELEMS(i)
Definition: simpleideals.h:24
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
Variable x
Definition: cfModGcd.cc:4023
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
int BOOLEAN
Definition: auxiliary.h:131
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2682
static void sm_CombineChain ( poly px,
poly  r,
const ring  R 
)
static

Definition at line 2029 of file sparsmat.cc.

2030 {
2031  poly pa = *px, pb;
2032  number x;
2033  int i;
2034 
2035  loop
2036  {
2037  pb = pNext(pa);
2038  if (pb == NULL)
2039  {
2040  pa = pNext(pa) = r;
2041  break;
2042  }
2043  i = p_LmCmp(pb, r,R);
2044  if (i > 0)
2045  pa = pb;
2046  else
2047  {
2048  if (i == 0)
2049  {
2050  x = n_Add(pGetCoeff(pb), pGetCoeff(r),R->cf);
2051  p_LmDelete(&r,R);
2052  if (n_IsZero(x,R->cf))
2053  {
2054  p_LmDelete(&pb,R);
2055  pNext(pa) = p_Add_q(pb,r,R);
2056  }
2057  else
2058  {
2059  pa = pb;
2060  p_SetCoeff(pa,x,R);
2061  pNext(pa) = p_Add_q(pNext(pa), r, R);
2062  }
2063  }
2064  else
2065  {
2066  pa = pNext(pa) = r;
2067  pNext(pa) = p_Add_q(pb, pNext(pa),R);
2068  }
2069  break;
2070  }
2071  }
2072  *px = pa;
2073 }
loop
Definition: myNF.cc:98
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:401
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:655
const ring R
Definition: DebugPrint.cc:36
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1472
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:707
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:884
static void sm_ElemDelete ( smpoly r,
const ring  R 
)
static

Definition at line 2132 of file sparsmat.cc.

2133 {
2134  smpoly a = *r, b = a->n;
2135 
2136  p_Delete(&a->m, R);
2137  omFreeBin((void *)a, smprec_bin);
2138  *r = b;
2139 }
const poly a
Definition: syzextra.cc:212
omBin smprec_bin
Definition: sparsmat.cc:80
sm_prec * smpoly
Definition: sparsmat.cc:52
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
const poly b
Definition: syzextra.cc:213
static void sm_ExactPolyDiv ( poly  a,
poly  b,
const ring  R 
)
static

Definition at line 1907 of file sparsmat.cc.

1908 {
1909  const number x = pGetCoeff(b);
1910  poly tail = pNext(b), e = p_Init(R);
1911  poly h;
1912  number y, yn;
1913  int lt = pLength(tail);
1914 
1915  if (lt + 1 >= SM_MIN_LENGTH_BUCKET && !TEST_OPT_NOT_BUCKETS)
1916  {
1918  kBucketInit(bucket, pNext(a), 0);
1919  int lh = 0;
1920  do
1921  {
1922  y = n_Div(pGetCoeff(a), x, R->cf);
1923  n_Normalize(y, R->cf);
1924  p_SetCoeff(a,y, R);
1925  yn = n_InpNeg(n_Copy(y, R->cf), R->cf);
1926  pSetCoeff0(e,yn);
1927  lh = lt;
1928  if (sm_IsNegQuot(e, a, b, R))
1929  {
1930  h = pp_Mult_Coeff_mm_DivSelect_MultDiv(tail, lh, e, a, b, R);
1931  }
1932  else
1933  h = pp_Mult_mm(tail, e, R);
1934  n_Delete(&yn, R->cf);
1935  kBucket_Add_q(bucket, h, &lh);
1936 
1937  a = pNext(a) = kBucketExtractLm(bucket);
1938  } while (a!=NULL);
1939  kBucketDestroy(&bucket);
1940  }
1941  else
1942  {
1943  do
1944  {
1945  y = n_Div(pGetCoeff(a), x, R->cf);
1946  n_Normalize(y, R->cf);
1947  p_SetCoeff(a,y, R);
1948  yn = n_InpNeg(n_Copy(y, R->cf), R->cf);
1949  pSetCoeff0(e,yn);
1950  if (sm_IsNegQuot(e, a, b, R))
1951  h = sm_SelectCopy_ExpMultDiv(tail, e, a, b, R);
1952  else
1953  h = pp_Mult_mm(tail, e, R);
1954  n_Delete(&yn, R->cf);
1955  a = pNext(a) = p_Add_q(pNext(a), h, R);
1956  } while (a!=NULL);
1957  }
1958  p_LmFree(e, R);
1959 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition: kbuckets.cc:471
const poly a
Definition: syzextra.cc:212
static poly pp_Mult_Coeff_mm_DivSelect_MultDiv(poly p, int &lp, poly m, poly a, poly b, const ring currRing)
Definition: sparsmat.cc:82
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:962
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
kBucket_pt kBucketCreate(ring bucket_ring)
Creation/Destruction of buckets.
Definition: kbuckets.cc:197
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:401
static void p_LmFree(poly p, ring)
Definition: p_polys.h:679
static int pLength(poly a)
Definition: p_polys.h:189
poly kBucketExtractLm(kBucket_pt bucket)
Definition: kbuckets.cc:489
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:204
const ring R
Definition: DebugPrint.cc:36
P bucket
Definition: myNF.cc:79
#define SM_MIN_LENGTH_BUCKET
Definition: sparsmat.cc:46
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:558
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:884
static poly sm_SelectCopy_ExpMultDiv(poly p, poly m, poly a, poly b, const ring currRing)
Definition: sparsmat.cc:104
static Poly * h
Definition: janet.cc:978
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1248
const poly b
Definition: syzextra.cc:213
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
Definition: kbuckets.cc:636
static BOOLEAN sm_IsNegQuot(poly, const poly, const poly, const ring)
Definition: sparsmat.cc:1962
long sm_ExpBound ( ideal  m,
int  di,
int  ra,
int  t,
const ring  currRing 
)

Definition at line 194 of file sparsmat.cc.

195 {
196  poly p;
197  long kr, kc;
198  long *r, *c;
199  int al, bl, i, j, k;
200 
201  if (ra==0) ra=1;
202  al = di*sizeof(long);
203  c = (long *)omAlloc(al);
204  bl = ra*sizeof(long);
205  r = (long *)omAlloc0(bl);
206  for (i=di-1;i>=0;i--)
207  {
208  kc = 0;
209  p = m->m[i];
210  while(p!=NULL)
211  {
212  k = p_GetComp(p, currRing)-1;
213  kr = r[k];
214  for (j=rVar(currRing);j>0;j--)
215  {
216  if(p_GetExp(p,j, currRing)>kc)
217  kc=p_GetExp(p,j, currRing);
218  if(p_GetExp(p,j, currRing)>kr)
219  kr=p_GetExp(p,j, currRing);
220  }
221  r[k] = kr;
222  pIter(p);
223  }
224  c[i] = kc;
225  }
226  if (t<di) smMinSelect(c, t, di);
227  if (t<ra) smMinSelect(r, t, ra);
228  kr = kc = 0;
229  for (j=t-1;j>=0;j--)
230  {
231  kr += r[j];
232  kc += c[j];
233  }
234  omFreeSize((ADDRESS)c, al);
235  omFreeSize((ADDRESS)r, bl);
236  if (kr<kc) kc = kr;
237  if (kr<1) kr = 1;
238  return kr;
239 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
void * ADDRESS
Definition: auxiliary.h:161
int k
Definition: cfEzgcd.cc:93
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define pIter(p)
Definition: monomials.h:44
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:465
int j
Definition: myNF.cc:70
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static void smMinSelect(long *, int, int)
Definition: sparsmat.cc:241
polyrec * poly
Definition: hilb.h:10
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static void sm_ExpMultDiv ( poly  t,
const poly  b,
const poly  c,
const ring  R 
)
static

Definition at line 1987 of file sparsmat.cc.

1988 {
1989  p_Test(t,R);
1990  p_LmTest(b,R);
1991  p_LmTest(c,R);
1992  poly bc = p_New(R);
1993 
1994  p_ExpVectorDiff(bc, b, c, R);
1995 
1996  while(t!=NULL)
1997  {
1998  p_ExpVectorAdd(t, bc, R);
1999  pIter(t);
2000  }
2001  p_LmFree(bc, R);
2002 }
static void p_LmFree(poly p, ring)
Definition: p_polys.h:679
#define pIter(p)
Definition: monomials.h:44
const ring R
Definition: DebugPrint.cc:36
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
Definition: p_polys.h:1339
#define p_LmTest(p, r)
Definition: p_polys.h:161
#define p_Test(p, r)
Definition: p_polys.h:160
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1402
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:660
const poly b
Definition: syzextra.cc:213
static void sm_FindRef ( poly ref,
poly px,
poly  r,
const ring  R 
)
static

Definition at line 2076 of file sparsmat.cc.

2077 {
2078  number x;
2079  int i;
2080  poly pa = *px, pp = NULL;
2081 
2082  loop
2083  {
2084  i = p_LmCmp(pa, r,R);
2085  if (i > 0)
2086  {
2087  pp = pa;
2088  pIter(pa);
2089  if (pa==NULL)
2090  {
2091  pNext(pp) = r;
2092  break;
2093  }
2094  }
2095  else
2096  {
2097  if (i == 0)
2098  {
2099  x = n_Add(pGetCoeff(pa), pGetCoeff(r),R->cf);
2100  p_LmDelete(&r,R);
2101  if (n_IsZero(x,R->cf))
2102  {
2103  p_LmDelete(&pa,R);
2104  if (pp!=NULL)
2105  pNext(pp) = p_Add_q(pa,r,R);
2106  else
2107  *px = p_Add_q(pa,r,R);
2108  }
2109  else
2110  {
2111  pp = pa;
2112  p_SetCoeff(pp,x,R);
2113  pNext(pp) = p_Add_q(pNext(pp), r, R);
2114  }
2115  }
2116  else
2117  {
2118  if (pp!=NULL)
2119  pp = pNext(pp) = r;
2120  else
2121  *px = pp = r;
2122  pNext(pp) = p_Add_q(pa, pNext(r),R);
2123  }
2124  break;
2125  }
2126  }
2127  *ref = pp;
2128 }
loop
Definition: myNF.cc:98
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:401
poly pp
Definition: myNF.cc:296
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:655
const ring R
Definition: DebugPrint.cc:36
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1472
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:707
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:884
static BOOLEAN sm_HaveDenom ( poly  a,
const ring  R 
)
static

Definition at line 2260 of file sparsmat.cc.

2261 {
2262  BOOLEAN sw;
2263  number x;
2264 
2265  while (a != NULL)
2266  {
2267  x = n_GetDenom(pGetCoeff(a),R->cf);
2268  sw = n_IsOne(x,R->cf);
2269  n_Delete(&x,R->cf);
2270  if (!sw)
2271  {
2272  return TRUE;
2273  }
2274  pIter(a);
2275  }
2276  return FALSE;
2277 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
#define TRUE
Definition: auxiliary.h:144
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
static FORCE_INLINE number n_GetDenom(number &n, const coeffs r)
return the denominator of n (if elements of r are by nature not fractional, result is 1) ...
Definition: coeffs.h:604
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
int BOOLEAN
Definition: auxiliary.h:131
static BOOLEAN sm_IsNegQuot ( poly  a,
const poly  b,
const poly  c,
const ring  R 
)
static

Definition at line 1962 of file sparsmat.cc.

1963 {
1964  if (p_LmDivisibleByNoComp(c, b,R))
1965  {
1966  p_ExpVectorDiff(a, b, c,R);
1967  // Hmm: here used to be a p_Setm(a): but it is unnecessary,
1968  // if b and c are correct
1969  return FALSE;
1970  }
1971  else
1972  {
1973  int i;
1974  for (i=rVar(R); i>0; i--)
1975  {
1976  if(p_GetExp(c,i,R) > p_GetExp(b,i,R))
1977  p_SetExp(a,i,p_GetExp(c,i,R)-p_GetExp(b,i,R),R);
1978  else
1979  p_SetExp(a,i,0,R);
1980  }
1981  // here we actually might need a p_Setm, if a is to be used in
1982  // comparisons
1983  return TRUE;
1984  }
1985 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1662
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
#define TRUE
Definition: auxiliary.h:144
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:465
const ring R
Definition: DebugPrint.cc:36
int i
Definition: cfEzgcd.cc:123
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
Definition: p_polys.h:1402
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
Definition: p_polys.h:484
const poly b
Definition: syzextra.cc:213
void sm_KillModifiedRing ( ring  r)

Definition at line 294 of file sparsmat.cc.

295 {
296  if (r->qideal!=NULL) id_Delete(&(r->qideal),r);
298 }
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
const ring r
Definition: syzextra.cc:208
#define NULL
Definition: omList.c:10
void rKillModifiedRing(ring r)
Definition: ring.cc:2962
poly sm_MultDiv ( poly  a,
poly  b,
const poly  c,
const ring  R 
)

Definition at line 1815 of file sparsmat.cc.

1816 {
1817  poly pa, e, res, r;
1818  BOOLEAN lead;
1819 
1820  if ((c == NULL) || p_LmIsConstantComp(c,R))
1821  {
1822  return pp_Mult_qq(a, b, R);
1823  }
1824  if (smSmaller(a, b))
1825  {
1826  r = a;
1827  a = b;
1828  b = r;
1829  }
1830  res = NULL;
1831  e = p_Init(R);
1832  lead = FALSE;
1833  while (!lead)
1834  {
1835  pSetCoeff0(e,pGetCoeff(b));
1836  if (sm_IsNegQuot(e, b, c, R))
1837  {
1838  lead = p_LmDivisibleByNoComp(e, a, R);
1839  r = sm_SelectCopy_ExpMultDiv(a, e, b, c, R);
1840  }
1841  else
1842  {
1843  lead = TRUE;
1844  r = pp_Mult_mm(a, e,R);
1845  }
1846  if (lead)
1847  {
1848  if (res != NULL)
1849  {
1850  sm_FindRef(&pa, &res, r, R);
1851  if (pa == NULL)
1852  lead = FALSE;
1853  }
1854  else
1855  {
1856  pa = res = r;
1857  }
1858  }
1859  else
1860  res = p_Add_q(res, r, R);
1861  pIter(b);
1862  if (b == NULL)
1863  {
1864  p_LmFree(e, R);
1865  return res;
1866  }
1867  }
1868  do
1869  {
1870  pSetCoeff0(e,pGetCoeff(b));
1871  if (sm_IsNegQuot(e, b, c, R))
1872  {
1873  r = sm_SelectCopy_ExpMultDiv(a, e, b, c, R);
1874  if (p_LmDivisibleByNoComp(e, a,R))
1875  sm_CombineChain(&pa, r, R);
1876  else
1877  pa = p_Add_q(pa,r,R);
1878  }
1879  else
1880  {
1881  r = pp_Mult_mm(a, e, R);
1882  sm_CombineChain(&pa, r, R);
1883  }
1884  pIter(b);
1885  } while (b != NULL);
1886  p_LmFree(e, R);
1887  return res;
1888 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:937
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:140
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1662
static BOOLEAN smSmaller(poly, poly)
Definition: sparsmat.cc:2018
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:962
#define TRUE
Definition: auxiliary.h:144
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static void p_LmFree(poly p, ring)
Definition: p_polys.h:679
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
static void sm_FindRef(poly *, poly *, poly, const ring)
Definition: sparsmat.cc:2076
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1075
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
static void sm_CombineChain(poly *, poly, const ring)
Definition: sparsmat.cc:2029
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:884
static poly sm_SelectCopy_ExpMultDiv(poly p, poly m, poly a, poly b, const ring currRing)
Definition: sparsmat.cc:104
int BOOLEAN
Definition: auxiliary.h:131
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1248
const poly b
Definition: syzextra.cc:213
static BOOLEAN sm_IsNegQuot(poly, const poly, const poly, const ring)
Definition: sparsmat.cc:1962
static void sm_NumberDelete ( smnumber r,
const ring  R 
)
static

Definition at line 2881 of file sparsmat.cc.

2882 {
2883  smnumber a = *r, b = a->n;
2884 
2885  n_Delete(&a->m,R->cf);
2887  *r = b;
2888 }
const poly a
Definition: syzextra.cc:212
void * ADDRESS
Definition: auxiliary.h:161
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
static omBin smnrec_bin
Definition: sparsmat.cc:2320
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
const poly b
Definition: syzextra.cc:213
static smnumber sm_Poly2Smnumber ( poly  q,
const ring  R 
)
static

Definition at line 2901 of file sparsmat.cc.

2902 {
2903  smnumber a, res;
2904  poly p = q;
2905 
2906  if (p == NULL)
2907  return NULL;
2908  a = res = (smnumber)omAllocBin(smnrec_bin);
2909  a->pos = p_GetComp(p,R);
2910  a->m = pGetCoeff(p);
2911  n_New(&pGetCoeff(p),R->cf);
2912  loop
2913  {
2914  pIter(p);
2915  if (p == NULL)
2916  {
2917  p_Delete(&q,R);
2918  a->n = NULL;
2919  return res;
2920  }
2921  a = a->n = (smnumber)omAllocBin(smnrec_bin);
2922  a->pos = p_GetComp(p,R);
2923  a->m = pGetCoeff(p);
2924  n_New(&pGetCoeff(p),R->cf);
2925  }
2926 }
#define n_New(n, r)
Definition: coeffs.h:441
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring R
Definition: DebugPrint.cc:36
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
#define NULL
Definition: omList.c:10
static omBin smnrec_bin
Definition: sparsmat.cc:2320
polyrec * poly
Definition: hilb.h:10
static smpoly sm_Poly2Smpoly ( poly  q,
const ring  R 
)
static

Definition at line 2153 of file sparsmat.cc.

2154 {
2155  poly pp;
2156  smpoly res, a;
2157  long x;
2158 
2159  if (q == NULL)
2160  return NULL;
2161  a = res = (smpoly)omAllocBin(smprec_bin);
2162  a->pos = x = p_GetComp(q,R);
2163  a->m = q;
2164  a->e = 0;
2165  loop
2166  {
2167  p_SetComp(q,0,R);
2168  pp = q;
2169  pIter(q);
2170  if (q == NULL)
2171  {
2172  a->n = NULL;
2173  return res;
2174  }
2175  if (p_GetComp(q,R) != x)
2176  {
2177  a = a->n = (smpoly)omAllocBin(smprec_bin);
2178  pNext(pp) = NULL;
2179  a->pos = x = p_GetComp(q,R);
2180  a->m = q;
2181  a->e = 0;
2182  }
2183  }
2184 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:236
#define p_GetComp(p, r)
Definition: monomials.h:72
omBin smprec_bin
Definition: sparsmat.cc:80
sm_prec * smpoly
Definition: sparsmat.cc:52
poly pp
Definition: myNF.cc:296
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
void sm_PolyDiv ( poly  a,
poly  b,
const ring  R 
)

Definition at line 1616 of file sparsmat.cc.

1617 {
1618  const number x = pGetCoeff(b);
1619  number y, yn;
1620  poly t, h, dummy;
1621  int i;
1622 
1623  if (pNext(b) == NULL)
1624  {
1625  do
1626  {
1627  if (!p_LmIsConstantComp(b,R))
1628  {
1629  for (i=rVar(R); i; i--)
1630  p_SubExp(a,i,p_GetExp(b,i,R),R);
1631  p_Setm(a,R);
1632  }
1633  y = n_Div(pGetCoeff(a),x,R->cf);
1634  n_Normalize(y,R->cf);
1635  p_SetCoeff(a,y,R);
1636  pIter(a);
1637  } while (a != NULL);
1638  return;
1639  }
1640  dummy = p_Init(R);
1641  do
1642  {
1643  for (i=rVar(R); i; i--)
1644  p_SubExp(a,i,p_GetExp(b,i,R),R);
1645  p_Setm(a,R);
1646  y = n_Div(pGetCoeff(a),x,R->cf);
1647  n_Normalize(y,R->cf);
1648  p_SetCoeff(a,y,R);
1649  yn = n_InpNeg(n_Copy(y,R->cf),R->cf);
1650  t = pNext(b);
1651  h = dummy;
1652  do
1653  {
1654  h = pNext(h) = p_Init(R);
1655  //pSetComp(h,0);
1656  for (i=rVar(R); i; i--)
1657  p_SetExp(h,i,p_GetExp(a,i,R)+p_GetExp(t,i,R),R);
1658  p_Setm(h,R);
1659  pSetCoeff0(h,n_Mult(yn, pGetCoeff(t),R->cf));
1660  pIter(t);
1661  } while (t != NULL);
1662  n_Delete(&yn,R->cf);
1663  pNext(h) = NULL;
1664  a = pNext(a) = p_Add_q(pNext(a), pNext(dummy),R);
1665  } while (a!=NULL);
1666  p_LmFree(dummy, R);
1667 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:937
const poly a
Definition: syzextra.cc:212
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:401
static void p_LmFree(poly p, ring)
Definition: p_polys.h:679
static long p_SubExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:609
#define pIter(p)
Definition: monomials.h:44
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:635
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:465
const ring R
Definition: DebugPrint.cc:36
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:558
int i
Definition: cfEzgcd.cc:123
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
Definition: p_polys.h:484
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:436
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:884
static Poly * h
Definition: janet.cc:978
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1248
const poly b
Definition: syzextra.cc:213
static void sm_PolyDivN ( poly  a,
const number  x,
const ring  R 
)
static

Definition at line 2005 of file sparsmat.cc.

2006 {
2007  number y;
2008 
2009  do
2010  {
2011  y = n_Div(pGetCoeff(a),x, R->cf);
2012  n_Normalize(y, R->cf);
2013  p_SetCoeff(a,y, R);
2014  pIter(a);
2015  } while (a != NULL);
2016 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:401
#define pIter(p)
Definition: monomials.h:44
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
Variable x
Definition: cfModGcd.cc:4023
static float sm_PolyWeight ( smpoly  a,
const ring  R 
)
static

Definition at line 2231 of file sparsmat.cc.

2232 {
2233  poly p = a->m;
2234  int i;
2235  float res = (float)n_Size(pGetCoeff(p),R->cf);
2236 
2237  if (pNext(p) == NULL)
2238  {
2239  for(i=rVar(R); i>0; i--)
2240  {
2241  if (p_GetExp(p,i,R) != 0) return res+1.0;
2242  }
2243  return res;
2244  }
2245  else
2246  {
2247  i = 0;
2248  res = 0.0;
2249  do
2250  {
2251  i++;
2252  res += (float)n_Size(pGetCoeff(p),R->cf);
2253  pIter(p);
2254  }
2255  while (p);
2256  return res+(float)i;
2257  }
2258 }
const poly a
Definition: syzextra.cc:212
return P p
Definition: myNF.cc:203
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:465
const ring R
Definition: DebugPrint.cc:36
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition: coeffs.h:571
ring sm_RingChange ( const ring  origR,
long  bound 
)

Definition at line 263 of file sparsmat.cc.

264 {
265 // *origR =currRing;
266  ring tmpR=rCopy0(origR,FALSE,FALSE);
267  int *ord=(int*)omAlloc0(3*sizeof(int));
268  int *block0=(int*)omAlloc(3*sizeof(int));
269  int *block1=(int*)omAlloc(3*sizeof(int));
270  ord[0]=ringorder_c;
271  ord[1]=ringorder_dp;
272  tmpR->order=ord;
273  tmpR->OrdSgn=1;
274  block0[1]=1;
275  tmpR->block0=block0;
276  block1[1]=tmpR->N;
277  tmpR->block1=block1;
278  tmpR->bitmask = 2*bound;
279  tmpR->wvhdl = (int **)omAlloc0((3) * sizeof(int*));
280 
281 // ???
282 // if (tmpR->bitmask > currRing->bitmask) tmpR->bitmask = currRing->bitmask;
283 
284  rComplete(tmpR,1);
285  if (origR->qideal!=NULL)
286  {
287  tmpR->qideal= idrCopyR_NoSort(origR->qideal, origR, tmpR);
288  }
289  if (TEST_OPT_PROT)
290  Print("[%ld:%d]", (long) tmpR->bitmask, tmpR->ExpL_Size);
291  return tmpR;
292 }
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
#define Print
Definition: emacs.cc:83
#define TEST_OPT_PROT
Definition: options.h:98
#define FALSE
Definition: auxiliary.h:140
#define omAlloc(size)
Definition: omAllocDecl.h:210
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3436
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1318
#define NULL
Definition: omList.c:10
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:206
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static poly sm_SelectCopy_ExpMultDiv ( poly  p,
poly  m,
poly  a,
poly  b,
const ring  currRing 
)
static

Definition at line 104 of file sparsmat.cc.

105 {
106  int lp = 0;
108 }
const poly a
Definition: syzextra.cc:212
static poly pp_Mult_Coeff_mm_DivSelect_MultDiv(poly p, int &lp, poly m, poly a, poly b, const ring currRing)
Definition: sparsmat.cc:82
return P p
Definition: myNF.cc:203
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int m
Definition: cfEzgcd.cc:119
const poly b
Definition: syzextra.cc:213
static poly sm_Smnumber2Poly ( number  a,
const ring  R 
)
static

Definition at line 2932 of file sparsmat.cc.

2933 {
2934  poly res;
2935 
2936  if (a == NULL) return NULL;
2937  res = p_Init(R);
2938  pSetCoeff0(res, a);
2939  return res;
2940 }
const poly a
Definition: syzextra.cc:212
poly res
Definition: myNF.cc:322
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
#define pSetCoeff0(p, n)
Definition: monomials.h:67
polyrec * poly
Definition: hilb.h:10
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1248
static poly sm_Smpoly2Poly ( smpoly  a,
const ring  R 
)
static

Definition at line 2190 of file sparsmat.cc.

2191 {
2192  smpoly b;
2193  poly res, pp, q;
2194  long x;
2195 
2196  if (a == NULL)
2197  return NULL;
2198  x = a->pos;
2199  q = res = a->m;
2200  loop
2201  {
2202  p_SetComp(q,x,R);
2203  pp = q;
2204  pIter(q);
2205  if (q == NULL)
2206  break;
2207  }
2208  loop
2209  {
2210  b = a;
2211  a = a->n;
2212  omFreeBin((void *)b, smprec_bin);
2213  if (a == NULL)
2214  return res;
2215  x = a->pos;
2216  q = pNext(pp) = a->m;
2217  loop
2218  {
2219  p_SetComp(q,x,R);
2220  pp = q;
2221  pIter(q);
2222  if (q == NULL)
2223  break;
2224  }
2225  }
2226 }
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:236
omBin smprec_bin
Definition: sparsmat.cc:80
sm_prec * smpoly
Definition: sparsmat.cc:52
poly pp
Definition: myNF.cc:296
#define pIter(p)
Definition: monomials.h:44
poly res
Definition: myNF.cc:322
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
const poly b
Definition: syzextra.cc:213
void sm_SpecialPolyDiv ( poly  a,
poly  b,
const ring  R 
)

Definition at line 1895 of file sparsmat.cc.

1896 {
1897  if (pNext(b) == NULL)
1898  {
1899  sm_PolyDivN(a, pGetCoeff(b),R);
1900  return;
1901  }
1902  sm_ExactPolyDiv(a, b, R);
1903 }
const poly a
Definition: syzextra.cc:212
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
const ring R
Definition: DebugPrint.cc:36
static void sm_PolyDivN(poly, const number, const ring)
Definition: sparsmat.cc:2005
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void sm_ExactPolyDiv(poly, poly, const ring)
Definition: sparsmat.cc:1907
const poly b
Definition: syzextra.cc:213
static BOOLEAN smCheckSolv ( ideal  I)
static

Definition at line 2945 of file sparsmat.cc.

2946 { int i = I->ncols;
2947  if ((i == 0) || (i != I->rank-1))
2948  {
2949  WerrorS("wrong dimensions for linsolv");
2950  return TRUE;
2951  }
2952  for(;i;i--)
2953  {
2954  if(I->m[i-1] == NULL)
2955  {
2956  WerrorS("singular input for linsolv");
2957  return TRUE;
2958  }
2959  }
2960  return FALSE;
2961 }
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void WerrorS(const char *s)
Definition: feFopen.cc:24
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static smpoly smElemCopy ( smpoly  a)
static

Definition at line 2141 of file sparsmat.cc.

2142 {
2144  memcpy(r, a, sizeof(smprec));
2145 /* r->m = pCopy(r->m); */
2146  return r;
2147 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
const poly a
Definition: syzextra.cc:212
omBin smprec_bin
Definition: sparsmat.cc:80
sm_prec * smpoly
Definition: sparsmat.cc:52
const ring r
Definition: syzextra.cc:208
static void smMinSelect ( long *  c,
int  t,
int  d 
)
static

Definition at line 241 of file sparsmat.cc.

242 {
243  long m;
244  int pos, i;
245  do
246  {
247  d--;
248  pos = d;
249  m = c[pos];
250  for (i=d-1;i>=0;i--)
251  {
252  if(c[i]<m)
253  {
254  pos = i;
255  m = c[i];
256  }
257  }
258  for (i=pos;i<d;i++) c[i] = c[i+1];
259  } while (d>t);
260 }
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
static smnumber smNumberCopy ( smnumber  a)
static

Definition at line 2890 of file sparsmat.cc.

2891 {
2893  memcpy(r, a, sizeof(smnrec));
2894  return r;
2895 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
const poly a
Definition: syzextra.cc:212
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring r
Definition: syzextra.cc:208
static omBin smnrec_bin
Definition: sparsmat.cc:2320
static BOOLEAN smSmaller ( poly  a,
poly  b 
)
static

Definition at line 2018 of file sparsmat.cc.

2019 {
2020  loop
2021  {
2022  pIter(b);
2023  if (b == NULL) return TRUE;
2024  pIter(a);
2025  if (a == NULL) return FALSE;
2026  }
2027 }
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
#define pIter(p)
Definition: monomials.h:44
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213

Variable Documentation

omBin smnrec_bin = omGetSpecBin(sizeof(smnrec))
static

Definition at line 2320 of file sparsmat.cc.

omBin smprec_bin = omGetSpecBin(sizeof(smprec))

Definition at line 80 of file sparsmat.cc.