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 "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)
 
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

◆ smprec

struct smprec

Definition at line 48 of file sparsmat.cc.

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

◆ smnrec

struct smnrec

Definition at line 2311 of file sparsmat.cc.

Data Fields
number m
smnumber n
int pos

Macro Definition Documentation

◆ SM_MIN_LENGTH_BUCKET

#define SM_MIN_LENGTH_BUCKET   MIN_LENGTH_BUCKET - 5

Definition at line 41 of file sparsmat.cc.

Typedef Documentation

◆ smnumber

typedef sm_nrec* smnumber

Definition at line 2310 of file sparsmat.cc.

◆ smpoly

typedef sm_prec* smpoly

Definition at line 47 of file sparsmat.cc.

Function Documentation

◆ pp_Mult_Coeff_mm_DivSelect_MultDiv()

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 77 of file sparsmat.cc.

79 {
80  if (rOrd_is_Comp_dp(currRing) && currRing->ExpL_Size > 2)
81  {
82  // pp_Mult_Coeff_mm_DivSelectMult only works for (c/C,dp) and
83  // ExpL_Size > 2
84  // should be generalized, at least to dp with ExpL_Size == 2
85  // (is the case for 1 variable)
86  int shorter;
87  p = currRing->p_Procs->pp_Mult_Coeff_mm_DivSelectMult(p, m, a, b,
88  shorter, currRing);
89  lp -= shorter;
90  }
91  else
92  {
95  }
96  return p;
97 }
static void sm_ExpMultDiv(poly, const poly, const poly, const ring)
Definition: sparsmat.cc:1984
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:10
int m
Definition: cfEzgcd.cc:119
static BOOLEAN rOrd_is_Comp_dp(const ring r)
Definition: ring.h:767
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:996

◆ sm_CallBareiss()

void sm_CallBareiss ( ideal  I,
int  x,
int  y,
ideal &  M,
intvec **  iv,
const ring  R 
)

Definition at line 400 of file sparsmat.cc.

401 {
402  int r=id_RankFreeModule(I,R),t=r;
403  int c=IDELEMS(I),s=c;
404  long bound;
405  ring tmpR;
406  sparse_mat *bareiss;
407 
408  if ((x>0) && (x<t))
409  t-=x;
410  if ((y>1) && (y<s))
411  s-=y;
412  if (t>s) t=s;
413  bound=sm_ExpBound(I,c,r,t,R);
414  tmpR=sm_RingChange(R,bound);
415  ideal II = idrCopyR(I, R, tmpR);
416  bareiss = new sparse_mat(II,tmpR);
417  if (bareiss->smGetAct() == NULL)
418  {
419  delete bareiss;
420  *iv=new intvec(1,rVar(tmpR));
421  }
422  else
423  {
424  id_Delete(&II,tmpR);
425  bareiss->smNewBareiss(x, y);
426  II = bareiss->smRes2Mod();
427  *iv = new intvec(bareiss->smGetRed());
428  bareiss->smToIntvec(*iv);
429  delete bareiss;
430  II = idrMoveR(II,tmpR,R);
431  }
432  sm_KillModifiedRing(tmpR);
433  M=II;
434 }
int smGetRed()
Definition: sparsmat.cc:174
const CanonicalForm int s
Definition: facAbsFact.cc:55
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:259
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:583
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:189
#define M
Definition: sirandom.c:24
void smNewBareiss(int, int)
Definition: sparsmat.cc:602
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:14
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:501
void sm_KillModifiedRing(ring r)
Definition: sparsmat.cc:290
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:517
smpoly * smGetAct()
Definition: sparsmat.cc:173

◆ sm_CallDet()

poly sm_CallDet ( ideal  I,
const ring  R 
)

Definition at line 355 of file sparsmat.cc.

356 {
357  if (I->ncols != I->rank)
358  {
359  Werror("det of %ld x %d module (matrix)",I->rank,I->ncols);
360  return NULL;
361  }
362  int r=id_RankFreeModule(I,R);
363  if (I->ncols != r) // some 0-lines at the end
364  {
365  return NULL;
366  }
367  long bound=sm_ExpBound(I,r,r,r,R);
368  number diag,h=n_Init(1,R->cf);
369  poly res;
370  ring tmpR;
371  sparse_mat *det;
372  ideal II;
373 
374  tmpR=sm_RingChange(R,bound);
375  II = idrCopyR(I, R, tmpR);
376  diag = sm_Cleardenom(II,tmpR);
377  det = new sparse_mat(II,tmpR);
378  id_Delete(&II,tmpR);
379  if (det->smGetAct() == NULL)
380  {
381  delete det;
382  sm_KillModifiedRing(tmpR);
383  return NULL;
384  }
385  res=det->smDet();
386  if(det->smGetSign()<0) res=p_Neg(res,tmpR);
387  delete det;
388  res = prMoveR(res, tmpR, R);
389  sm_KillModifiedRing(tmpR);
390  if (!n_Equal(diag,h,R->cf))
391  {
392  p_Mult_nn(res,diag,R);
393  p_Normalize(res,R);
394  }
395  n_Delete(&diag,R->cf);
396  n_Delete(&h,R->cf);
397  return res;
398 }
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:259
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
int smGetSign()
Definition: sparsmat.cc:172
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:542
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
static number sm_Cleardenom(ideal, const ring)
Definition: sparsmat.cc:2276
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
Definition: sparsmat.cc:189
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:895
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3680
#define NULL
Definition: omList.c:10
void sm_KillModifiedRing(ring r)
Definition: sparsmat.cc:290
poly smDet()
Definition: sparsmat.cc:528
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:464
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:1013
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
void Werror(const char *fmt,...)
Definition: reporter.cc:189
smpoly * smGetAct()
Definition: sparsmat.cc:173

◆ sm_CallSolv()

ideal sm_CallSolv ( ideal  I,
const ring  R 
)

Definition at line 2369 of file sparsmat.cc.

2370 {
2371  sparse_number_mat *linsolv;
2372  ring tmpR;
2373  ideal rr;
2374 
2375  if (id_IsConstant(I,R)==FALSE)
2376  {
2377  WerrorS("symbol in equation");
2378  return NULL;
2379  }
2380  I->rank = id_RankFreeModule(I,R);
2381  if (smCheckSolv(I)) return NULL;
2382  tmpR=sm_RingChange(R,1);
2383  rr=idrCopyR(I,R, tmpR);
2384  linsolv = new sparse_number_mat(rr,tmpR);
2385  rr=NULL;
2386  linsolv->smTriangular();
2387  if (linsolv->smIsSing() == 0)
2388  {
2389  linsolv->smSolv();
2390  rr = linsolv->smRes2Ideal();
2391  }
2392  else
2393  WerrorS("singular problem for linsolv");
2394  delete linsolv;
2395  if (rr!=NULL)
2396  rr = idrMoveR(rr,tmpR,R);
2397  sm_KillModifiedRing(tmpR);
2398  return rr;
2399 }
ring sm_RingChange(const ring origR, long bound)
Definition: sparsmat.cc:259
#define FALSE
Definition: auxiliary.h:94
ideal smRes2Ideal()
Definition: sparsmat.cc:2559
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:2942
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:290
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:193

◆ sm_CheckDet()

BOOLEAN sm_CheckDet ( ideal  I,
int  d,
BOOLEAN  sw,
const ring  r 
)

Definition at line 304 of file sparsmat.cc.

305 {
306  int s,t,i;
307  poly p;
308 
309  if (d>100)
310  return sw;
311  if (!rField_is_Q(r))
312  return sw;
313  s = t = 0;
314  if (sw)
315  {
316  for(i=IDELEMS(I)-1;i>=0;i--)
317  {
318  p=I->m[i];
319  if (p!=NULL)
320  {
321  if(!p_IsConstant(p,r))
322  return sw;
323  s++;
324  t+=n_Size(pGetCoeff(p),r->cf);
325  }
326  }
327  }
328  else
329  {
330  for(i=IDELEMS(I)-1;i>=0;i--)
331  {
332  p=I->m[i];
333  if (!p_IsConstantPoly(p,r))
334  return sw;
335  while (p!=NULL)
336  {
337  s++;
338  t+=n_Size(pGetCoeff(p),r->cf);
339  pIter(p);
340  }
341  }
342  }
343  s*=15;
344  if (t>s)
345  return !sw;
346  else
347  return sw;
348 }
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:1876
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#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:1890
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:574

◆ sm_Cleardenom()

static number sm_Cleardenom ( ideal  id,
const ring  R 
)
static

Definition at line 2276 of file sparsmat.cc.

2277 {
2278  poly a;
2279  number x,y,res=n_Init(1,R->cf);
2280  BOOLEAN sw=FALSE;
2281 
2282  for (int i=0; i<IDELEMS(id); i++)
2283  {
2284  a = id->m[i];
2285  sw = sm_HaveDenom(a,R);
2286  if (sw) break;
2287  }
2288  if (!sw) return res;
2289  for (int i=0; i<IDELEMS(id); i++)
2290  {
2291  a = id->m[i];
2292  if (a!=NULL)
2293  {
2294  x = n_Copy(pGetCoeff(a),R->cf);
2295  p_Cleardenom(a, R);
2296  y = n_Div(x,pGetCoeff(a),R->cf);
2297  n_Delete(&x,R->cf);
2298  x = n_Mult(res,y,R->cf);
2299  n_Normalize(x,R->cf);
2300  n_Delete(&res,R->cf);
2301  res = x;
2302  }
2303  }
2304  return res;
2305 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:94
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:542
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:582
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:640
const ring R
Definition: DebugPrint.cc:36
static BOOLEAN sm_HaveDenom(poly, const ring)
Definition: sparsmat.cc:2257
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:455
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:619
Variable x
Definition: cfModGcd.cc:4023
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
polyrec * poly
Definition: hilb.h:10
int BOOLEAN
Definition: auxiliary.h:85
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2755

◆ sm_CombineChain()

static void sm_CombineChain ( poly px,
poly  r,
const ring  R 
)
static

Definition at line 2026 of file sparsmat.cc.

2027 {
2028  poly pa = *px, pb;
2029  number x;
2030  int i;
2031 
2032  loop
2033  {
2034  pb = pNext(pa);
2035  if (pb == NULL)
2036  {
2037  pa = pNext(pa) = r;
2038  break;
2039  }
2040  i = p_LmCmp(pb, r,R);
2041  if (i > 0)
2042  pa = pb;
2043  else
2044  {
2045  if (i == 0)
2046  {
2047  x = n_Add(pGetCoeff(pb), pGetCoeff(r),R->cf);
2048  p_LmDelete(&r,R);
2049  if (n_IsZero(x,R->cf))
2050  {
2051  p_LmDelete(&pb,R);
2052  pNext(pa) = p_Add_q(pb,r,R);
2053  }
2054  else
2055  {
2056  pa = pb;
2057  p_SetCoeff(pa,x,R);
2058  pNext(pa) = p_Add_q(pNext(pa), r, R);
2059  }
2060  }
2061  else
2062  {
2063  pa = pNext(pa) = r;
2064  pNext(pa) = p_Add_q(pb, pNext(pa),R);
2065  }
2066  break;
2067  }
2068  }
2069  *px = pa;
2070 }
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:407
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:660
const ring R
Definition: DebugPrint.cc:36
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1467
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:468
#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:706
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877

◆ sm_ElemDelete()

static void sm_ElemDelete ( smpoly r,
const ring  R 
)
static

Definition at line 2129 of file sparsmat.cc.

2130 {
2131  smpoly a = *r, b = a->n;
2132 
2133  p_Delete(&a->m, R);
2134  omFreeBin((void *)a, smprec_bin);
2135  *r = b;
2136 }
const poly a
Definition: syzextra.cc:212
omBin smprec_bin
Definition: sparsmat.cc:75
sm_prec * smpoly
Definition: sparsmat.cc:47
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:843
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
const poly b
Definition: syzextra.cc:213

◆ sm_ExactPolyDiv()

static void sm_ExactPolyDiv ( poly  a,
poly  b,
const ring  R 
)
static

Definition at line 1904 of file sparsmat.cc.

1905 {
1906  const number x = pGetCoeff(b);
1907  poly tail = pNext(b), e = p_Init(R);
1908  poly h;
1909  number y, yn;
1910  int lt = pLength(tail);
1911 
1912  if (lt + 1 >= SM_MIN_LENGTH_BUCKET && !TEST_OPT_NOT_BUCKETS)
1913  {
1915  kBucketInit(bucket, pNext(a), 0);
1916  int lh = 0;
1917  do
1918  {
1919  y = n_Div(pGetCoeff(a), x, R->cf);
1920  n_Normalize(y, R->cf);
1921  p_SetCoeff(a,y, R);
1922  yn = n_InpNeg(n_Copy(y, R->cf), R->cf);
1923  pSetCoeff0(e,yn);
1924  lh = lt;
1925  if (sm_IsNegQuot(e, a, b, R))
1926  {
1927  h = pp_Mult_Coeff_mm_DivSelect_MultDiv(tail, lh, e, a, b, R);
1928  }
1929  else
1930  h = pp_Mult_mm(tail, e, R);
1931  n_Delete(&yn, R->cf);
1932  kBucket_Add_q(bucket, h, &lh);
1933 
1935  } while (a!=NULL);
1937  }
1938  else
1939  {
1940  do
1941  {
1942  y = n_Div(pGetCoeff(a), x, R->cf);
1943  n_Normalize(y, R->cf);
1944  p_SetCoeff(a,y, R);
1945  yn = n_InpNeg(n_Copy(y, R->cf), R->cf);
1946  pSetCoeff0(e,yn);
1947  if (sm_IsNegQuot(e, a, b, R))
1948  h = sm_SelectCopy_ExpMultDiv(tail, e, a, b, R);
1949  else
1950  h = pp_Mult_mm(tail, e, R);
1951  n_Delete(&yn, R->cf);
1952  a = pNext(a) = p_Add_q(pNext(a), h, R);
1953  } while (a!=NULL);
1954  }
1955  p_LmFree(e, R);
1956 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition: kbuckets.cc:467
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:77
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:957
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:582
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:407
static void p_LmFree(poly p, ring)
Definition: p_polys.h:678
poly kBucketExtractLm(kBucket_pt bucket)
Definition: kbuckets.cc:485
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:200
const ring R
Definition: DebugPrint.cc:36
P bucket
Definition: myNF.cc:79
#define SM_MIN_LENGTH_BUCKET
Definition: sparsmat.cc:41
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:561
static unsigned pLength(poly a)
Definition: p_polys.h:189
#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:455
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:619
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:459
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
static poly sm_SelectCopy_ExpMultDiv(poly p, poly m, poly a, poly b, const ring currRing)
Definition: sparsmat.cc:99
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets
Definition: kbuckets.cc:193
static Poly * h
Definition: janet.cc:978
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1243
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:628
static BOOLEAN sm_IsNegQuot(poly, const poly, const poly, const ring)
Definition: sparsmat.cc:1959

◆ sm_ExpBound()

long sm_ExpBound ( ideal  m,
int  di,
int  ra,
int  t,
const ring  currRing 
)

Definition at line 189 of file sparsmat.cc.

190 {
191  poly p;
192  long kr, kc;
193  long *r, *c;
194  int al, bl, i, j, k;
195 
196  if (ra==0) ra=1;
197  al = di*sizeof(long);
198  c = (long *)omAlloc(al);
199  bl = ra*sizeof(long);
200  r = (long *)omAlloc0(bl);
201  for (i=di-1;i>=0;i--)
202  {
203  kc = 0;
204  p = m->m[i];
205  while(p!=NULL)
206  {
207  k = p_GetComp(p, currRing)-1;
208  kr = r[k];
209  for (j=currRing->N;j>0;j--)
210  {
211  long t=p_GetExp(p,j, currRing);
212  if(t /*p_GetExp(p,j, currRing)*/ >kc)
213  kc=t; /*p_GetExp(p,j, currRing);*/
214  if(t /*p_GetExp(p,j, currRing)s*/ >kr)
215  kr=t; /*p_GetExp(p,j, currRing);*/
216  }
217  r[k] = kr;
218  pIter(p);
219  }
220  c[i] = kc;
221  }
222  if (t<di) smMinSelect(c, t, di);
223  if (t<ra) smMinSelect(r, t, ra);
224  kr = kc = 0;
225  for (j=t-1;j>=0;j--)
226  {
227  kr += r[j];
228  kc += c[j];
229  }
230  omFreeSize((ADDRESS)c, al);
231  omFreeSize((ADDRESS)r, bl);
232  if (kr<kc) kc = kr;
233  if (kr<1) kr = 1;
234  return kr;
235 }
return P p
Definition: myNF.cc:203
#define p_GetComp(p, r)
Definition: monomials.h:72
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:115
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:10
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:464
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:237
polyrec * poly
Definition: hilb.h:10
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ sm_ExpMultDiv()

static void sm_ExpMultDiv ( poly  t,
const poly  b,
const poly  c,
const ring  R 
)
static

Definition at line 1984 of file sparsmat.cc.

1985 {
1986  p_Test(t,R);
1987  p_LmTest(b,R);
1988  p_LmTest(c,R);
1989  poly bc = p_New(R);
1990 
1991  p_ExpVectorDiff(bc, b, c, R);
1992 
1993  while(t!=NULL)
1994  {
1995  p_ExpVectorAdd(t, bc, R);
1996  pIter(t);
1997  }
1998  p_LmFree(bc, R);
1999 }
static void p_LmFree(poly p, ring)
Definition: p_polys.h:678
#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:1334
#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:1397
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
static poly p_New(const ring, omBin bin)
Definition: p_polys.h:659
const poly b
Definition: syzextra.cc:213

◆ sm_FindRef()

static void sm_FindRef ( poly ref,
poly px,
poly  r,
const ring  R 
)
static

Definition at line 2073 of file sparsmat.cc.

2074 {
2075  number x;
2076  int i;
2077  poly pa = *px, pp = NULL;
2078 
2079  loop
2080  {
2081  i = p_LmCmp(pa, r,R);
2082  if (i > 0)
2083  {
2084  pp = pa;
2085  pIter(pa);
2086  if (pa==NULL)
2087  {
2088  pNext(pp) = r;
2089  break;
2090  }
2091  }
2092  else
2093  {
2094  if (i == 0)
2095  {
2096  x = n_Add(pGetCoeff(pa), pGetCoeff(r),R->cf);
2097  p_LmDelete(&r,R);
2098  if (n_IsZero(x,R->cf))
2099  {
2100  p_LmDelete(&pa,R);
2101  if (pp!=NULL)
2102  pNext(pp) = p_Add_q(pa,r,R);
2103  else
2104  *px = p_Add_q(pa,r,R);
2105  }
2106  else
2107  {
2108  pp = pa;
2109  p_SetCoeff(pp,x,R);
2110  pNext(pp) = p_Add_q(pNext(pp), r, R);
2111  }
2112  }
2113  else
2114  {
2115  if (pp!=NULL)
2116  pp = pNext(pp) = r;
2117  else
2118  *px = pp = r;
2119  pNext(pp) = p_Add_q(pa, pNext(r),R);
2120  }
2121  break;
2122  }
2123  }
2124  *ref = pp;
2125 }
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:407
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:660
const ring R
Definition: DebugPrint.cc:36
static int p_LmCmp(poly p, poly q, const ring r)
Definition: p_polys.h:1467
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:468
#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:706
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877

◆ sm_HaveDenom()

static BOOLEAN sm_HaveDenom ( poly  a,
const ring  R 
)
static

Definition at line 2257 of file sparsmat.cc.

2258 {
2259  BOOLEAN sw;
2260  number x;
2261 
2262  while (a != NULL)
2263  {
2264  x = n_GetDenom(pGetCoeff(a),R->cf);
2265  sw = n_IsOne(x,R->cf);
2266  n_Delete(&x,R->cf);
2267  if (!sw)
2268  {
2269  return TRUE;
2270  }
2271  pIter(a);
2272  }
2273  return FALSE;
2274 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:94
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:472
#define TRUE
Definition: auxiliary.h: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
#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:607
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
int BOOLEAN
Definition: auxiliary.h:85

◆ sm_IsNegQuot()

static BOOLEAN sm_IsNegQuot ( poly  a,
const poly  b,
const poly  c,
const ring  R 
)
static

Definition at line 1959 of file sparsmat.cc.

1960 {
1961  if (p_LmDivisibleByNoComp(c, b,R))
1962  {
1963  p_ExpVectorDiff(a, b, c,R);
1964  // Hmm: here used to be a p_Setm(a): but it is unnecessary,
1965  // if b and c are correct
1966  return FALSE;
1967  }
1968  else
1969  {
1970  int i;
1971  for (i=rVar(R); i>0; i--)
1972  {
1973  if(p_GetExp(c,i,R) > p_GetExp(b,i,R))
1974  p_SetExp(a,i,p_GetExp(c,i,R)-p_GetExp(b,i,R),R);
1975  else
1976  p_SetExp(a,i,0,R);
1977  }
1978  // here we actually might need a p_Setm, if a is to be used in
1979  // comparisons
1980  return TRUE;
1981  }
1982 }
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:94
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1754
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
#define TRUE
Definition: auxiliary.h:98
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:464
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:1397
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:483
const poly b
Definition: syzextra.cc:213

◆ sm_KillModifiedRing()

void sm_KillModifiedRing ( ring  r)

Definition at line 290 of file sparsmat.cc.

291 {
292  if (r->qideal!=NULL) id_Delete(&(r->qideal),r);
294 }
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:2972

◆ sm_MultDiv()

poly sm_MultDiv ( poly  a,
poly  b,
const poly  c,
const ring  R 
)

Definition at line 1812 of file sparsmat.cc.

1813 {
1814  poly pa, e, res, r;
1815  BOOLEAN lead;
1816 
1817  if ((c == NULL) || p_LmIsConstantComp(c,R))
1818  {
1819  return pp_Mult_qq(a, b, R);
1820  }
1821  if (smSmaller(a, b))
1822  {
1823  r = a;
1824  a = b;
1825  b = r;
1826  }
1827  res = NULL;
1828  e = p_Init(R);
1829  lead = FALSE;
1830  while (!lead)
1831  {
1832  pSetCoeff0(e,pGetCoeff(b));
1833  if (sm_IsNegQuot(e, b, c, R))
1834  {
1835  lead = p_LmDivisibleByNoComp(e, a, R);
1836  r = sm_SelectCopy_ExpMultDiv(a, e, b, c, R);
1837  }
1838  else
1839  {
1840  lead = TRUE;
1841  r = pp_Mult_mm(a, e,R);
1842  }
1843  if (lead)
1844  {
1845  if (res != NULL)
1846  {
1847  sm_FindRef(&pa, &res, r, R);
1848  if (pa == NULL)
1849  lead = FALSE;
1850  }
1851  else
1852  {
1853  pa = res = r;
1854  }
1855  }
1856  else
1857  res = p_Add_q(res, r, R);
1858  pIter(b);
1859  if (b == NULL)
1860  {
1861  p_LmFree(e, R);
1862  return res;
1863  }
1864  }
1865  do
1866  {
1867  pSetCoeff0(e,pGetCoeff(b));
1868  if (sm_IsNegQuot(e, b, c, R))
1869  {
1870  r = sm_SelectCopy_ExpMultDiv(a, e, b, c, R);
1871  if (p_LmDivisibleByNoComp(e, a,R))
1872  sm_CombineChain(&pa, r, R);
1873  else
1874  pa = p_Add_q(pa,r,R);
1875  }
1876  else
1877  {
1878  r = pp_Mult_mm(a, e, R);
1879  sm_CombineChain(&pa, r, R);
1880  }
1881  pIter(b);
1882  } while (b != NULL);
1883  p_LmFree(e, R);
1884  return res;
1885 }
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:932
const poly a
Definition: syzextra.cc:212
#define FALSE
Definition: auxiliary.h:94
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
Definition: p_polys.h:1754
static BOOLEAN smSmaller(poly, poly)
Definition: sparsmat.cc:2015
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:957
#define TRUE
Definition: auxiliary.h: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 void p_LmFree(poly p, ring)
Definition: p_polys.h:678
#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:2073
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1070
const ring R
Definition: DebugPrint.cc:36
#define NULL
Definition: omList.c:10
static void sm_CombineChain(poly *, poly, const ring)
Definition: sparsmat.cc:2026
#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:877
static poly sm_SelectCopy_ExpMultDiv(poly p, poly m, poly a, poly b, const ring currRing)
Definition: sparsmat.cc:99
int BOOLEAN
Definition: auxiliary.h:85
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1243
const poly b
Definition: syzextra.cc:213
static BOOLEAN sm_IsNegQuot(poly, const poly, const poly, const ring)
Definition: sparsmat.cc:1959

◆ sm_NumberDelete()

static void sm_NumberDelete ( smnumber r,
const ring  R 
)
static

Definition at line 2878 of file sparsmat.cc.

2879 {
2880  smnumber a = *r, b = a->n;
2881 
2882  n_Delete(&a->m,R->cf);
2884  *r = b;
2885 }
const poly a
Definition: syzextra.cc:212
void * ADDRESS
Definition: auxiliary.h:115
sm_nrec * smnumber
Definition: sparsmat.cc:2310
const ring r
Definition: syzextra.cc:208
const ring R
Definition: DebugPrint.cc:36
static omBin smnrec_bin
Definition: sparsmat.cc:2317
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
const poly b
Definition: syzextra.cc:213

◆ sm_Poly2Smnumber()

static smnumber sm_Poly2Smnumber ( poly  q,
const ring  R 
)
static

Definition at line 2898 of file sparsmat.cc.

2899 {
2900  smnumber a, res;
2901  poly p = q;
2902 
2903  if (p == NULL)
2904  return NULL;
2906  a->pos = p_GetComp(p,R);
2907  a->m = pGetCoeff(p);
2908  n_New(&pGetCoeff(p),R->cf);
2909  loop
2910  {
2911  pIter(p);
2912  if (p == NULL)
2913  {
2914  p_Delete(&q,R);
2915  a->n = NULL;
2916  return res;
2917  }
2918  a = a->n = (smnumber)omAllocBin(smnrec_bin);
2919  a->pos = p_GetComp(p,R);
2920  a->m = pGetCoeff(p);
2921  n_New(&pGetCoeff(p),R->cf);
2922  }
2923 }
#define n_New(n, r)
Definition: coeffs.h:444
#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:2310
const ring R
Definition: DebugPrint.cc:36
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
static omBin smnrec_bin
Definition: sparsmat.cc:2317
polyrec * poly
Definition: hilb.h:10

◆ sm_Poly2Smpoly()

static smpoly sm_Poly2Smpoly ( poly  q,
const ring  R 
)
static

Definition at line 2150 of file sparsmat.cc.

2151 {
2152  poly pp;
2153  smpoly res, a;
2154  long x;
2155 
2156  if (q == NULL)
2157  return NULL;
2159  a->pos = x = p_GetComp(q,R);
2160  a->m = q;
2161  a->e = 0;
2162  loop
2163  {
2164  p_SetComp(q,0,R);
2165  pp = q;
2166  pIter(q);
2167  if (q == NULL)
2168  {
2169  a->n = NULL;
2170  return res;
2171  }
2172  if (p_GetComp(q,R) != x)
2173  {
2174  a = a->n = (smpoly)omAllocBin(smprec_bin);
2175  pNext(pp) = NULL;
2176  a->pos = x = p_GetComp(q,R);
2177  a->m = q;
2178  a->e = 0;
2179  }
2180  }
2181 }
#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:242
#define p_GetComp(p, r)
Definition: monomials.h:72
omBin smprec_bin
Definition: sparsmat.cc:75
sm_prec * smpoly
Definition: sparsmat.cc:47
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

◆ sm_PolyDivN()

static void sm_PolyDivN ( poly  a,
const number  x,
const ring  R 
)
static

Definition at line 2002 of file sparsmat.cc.

2003 {
2004  number y;
2005 
2006  do
2007  {
2008  y = n_Div(pGetCoeff(a),x, R->cf);
2009  n_Normalize(y, R->cf);
2010  p_SetCoeff(a,y, R);
2011  pIter(a);
2012  } while (a != NULL);
2013 }
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:582
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:407
#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:619
Variable x
Definition: cfModGcd.cc:4023

◆ sm_PolyWeight()

static float sm_PolyWeight ( smpoly  a,
const ring  R 
)
static

Definition at line 2228 of file sparsmat.cc.

2229 {
2230  poly p = a->m;
2231  int i;
2232  float res = (float)n_Size(pGetCoeff(p),R->cf);
2233 
2234  if (pNext(p) == NULL)
2235  {
2236  for(i=rVar(R); i>0; i--)
2237  {
2238  if (p_GetExp(p,i,R) != 0) return res+1.0;
2239  }
2240  return res;
2241  }
2242  else
2243  {
2244  i = 0;
2245  res = 0.0;
2246  do
2247  {
2248  i++;
2249  res += (float)n_Size(pGetCoeff(p),R->cf);
2250  pIter(p);
2251  }
2252  while (p);
2253  return res+(float)i;
2254  }
2255 }
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:583
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:464
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:574

◆ sm_RingChange()

ring sm_RingChange ( const ring  origR,
long  bound 
)

Definition at line 259 of file sparsmat.cc.

260 {
261 // *origR =currRing;
262  ring tmpR=rCopy0(origR,FALSE,FALSE);
264  int *block0=(int*)omAlloc(3*sizeof(int));
265  int *block1=(int*)omAlloc(3*sizeof(int));
266  ord[0]=ringorder_c;
267  ord[1]=ringorder_dp;
268  tmpR->order=ord;
269  tmpR->OrdSgn=1;
270  block0[1]=1;
271  tmpR->block0=block0;
272  block1[1]=tmpR->N;
273  tmpR->block1=block1;
274  tmpR->bitmask = 2*bound;
275  tmpR->wvhdl = (int **)omAlloc0((3) * sizeof(int*));
276 
277 // ???
278 // if (tmpR->bitmask > currRing->bitmask) tmpR->bitmask = currRing->bitmask;
279 
280  rComplete(tmpR,1);
281  if (origR->qideal!=NULL)
282  {
283  tmpR->qideal= idrCopyR_NoSort(origR->qideal, origR, tmpR);
284  }
285  if (TEST_OPT_PROT)
286  Print("[%ld:%d]", (long) tmpR->bitmask, tmpR->ExpL_Size);
287  return tmpR;
288 }
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:94
#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:3365
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1325
rRingOrder_t
order stuff
Definition: ring.h:75
#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

◆ sm_SelectCopy_ExpMultDiv()

static poly sm_SelectCopy_ExpMultDiv ( poly  p,
poly  m,
poly  a,
poly  b,
const ring  currRing 
)
static

Definition at line 99 of file sparsmat.cc.

100 {
101  int lp = 0;
103 }
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:77
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:10
int m
Definition: cfEzgcd.cc:119
const poly b
Definition: syzextra.cc:213

◆ sm_Smnumber2Poly()

static poly sm_Smnumber2Poly ( number  a,
const ring  R 
)
static

Definition at line 2929 of file sparsmat.cc.

2930 {
2931  poly res;
2932 
2933  if (a == NULL) return NULL;
2934  res = p_Init(R);
2935  pSetCoeff0(res, a);
2936  return res;
2937 }
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:1243

◆ sm_Smpoly2Poly()

static poly sm_Smpoly2Poly ( smpoly  a,
const ring  R 
)
static

Definition at line 2187 of file sparsmat.cc.

2188 {
2189  smpoly b;
2190  poly res, pp, q;
2191  long x;
2192 
2193  if (a == NULL)
2194  return NULL;
2195  x = a->pos;
2196  q = res = a->m;
2197  loop
2198  {
2199  p_SetComp(q,x,R);
2200  pp = q;
2201  pIter(q);
2202  if (q == NULL)
2203  break;
2204  }
2205  loop
2206  {
2207  b = a;
2208  a = a->n;
2209  omFreeBin((void *)b, smprec_bin);
2210  if (a == NULL)
2211  return res;
2212  x = a->pos;
2213  q = pNext(pp) = a->m;
2214  loop
2215  {
2216  p_SetComp(q,x,R);
2217  pp = q;
2218  pIter(q);
2219  if (q == NULL)
2220  break;
2221  }
2222  }
2223 }
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:242
omBin smprec_bin
Definition: sparsmat.cc:75
sm_prec * smpoly
Definition: sparsmat.cc:47
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

◆ sm_SpecialPolyDiv()

void sm_SpecialPolyDiv ( poly  a,
poly  b,
const ring  R 
)

Definition at line 1893 of file sparsmat.cc.

1894 {
1895  if (pNext(b) == NULL)
1896  {
1897  sm_PolyDivN(a, pGetCoeff(b),R);
1898  return;
1899  }
1900  sm_ExactPolyDiv(a, b, R);
1901 }
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:2002
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
static void sm_ExactPolyDiv(poly, poly, const ring)
Definition: sparsmat.cc:1904
const poly b
Definition: syzextra.cc:213

◆ smCheckSolv()

static BOOLEAN smCheckSolv ( ideal  I)
static

Definition at line 2942 of file sparsmat.cc.

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

◆ smElemCopy()

static smpoly smElemCopy ( smpoly  a)
static

Definition at line 2138 of file sparsmat.cc.

2139 {
2141  memcpy(r, a, sizeof(smprec));
2142 /* r->m = pCopy(r->m); */
2143  return r;
2144 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
const poly a
Definition: syzextra.cc:212
omBin smprec_bin
Definition: sparsmat.cc:75
sm_prec * smpoly
Definition: sparsmat.cc:47
const ring r
Definition: syzextra.cc:208

◆ smMinSelect()

static void smMinSelect ( long *  c,
int  t,
int  d 
)
static

Definition at line 237 of file sparsmat.cc.

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

◆ smNumberCopy()

static smnumber smNumberCopy ( smnumber  a)
static

Definition at line 2887 of file sparsmat.cc.

2888 {
2890  memcpy(r, a, sizeof(smnrec));
2891  return r;
2892 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
const poly a
Definition: syzextra.cc:212
sm_nrec * smnumber
Definition: sparsmat.cc:2310
const ring r
Definition: syzextra.cc:208
static omBin smnrec_bin
Definition: sparsmat.cc:2317

◆ smSmaller()

static BOOLEAN smSmaller ( poly  a,
poly  b 
)
static

Definition at line 2015 of file sparsmat.cc.

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

Variable Documentation

◆ smnrec_bin

omBin smnrec_bin = omGetSpecBin(sizeof(smnrec))
static

Definition at line 2317 of file sparsmat.cc.

◆ smprec_bin

omBin smprec_bin = omGetSpecBin(sizeof(smprec))

Definition at line 75 of file sparsmat.cc.