My Project
Data Structures | Macros | Functions | Variables
simpleideals.h File Reference
#include "polys/monomials/ring.h"
#include "polys/matpol.h"

Go to the source code of this file.

Data Structures

struct  const_ideal
 The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it are: More...
 
struct  const_map
 
struct  ideal_list
 

Macros

#define IDELEMS(i)   ((i)->ncols)
 
#define id_Init(s, r, R)   idInit(s,r)
 
#define id_Elem(F, R)   idElem(F)
 
#define id_Test(A, lR)   id_DBTest(A, PDEBUG, __FILE__,__LINE__, lR, lR)
 
#define id_LmTest(A, lR)   id_DBLmTest(A, PDEBUG, __FILE__,__LINE__, lR)
 
#define id_Print(id, lR, tR)   idShow(id, lR, tR)
 

Functions

ideal idInit (int size, int rank=1)
 creates an ideal / module More...
 
void id_Delete (ideal *h, ring r)
 deletes an ideal/module/matrix More...
 
void id_ShallowDelete (ideal *h, ring r)
 Shallowdeletes an ideal/matrix. More...
 
void idSkipZeroes (ideal ide)
 gives an ideal/module the minimal possible size More...
 
int idElem (const ideal F)
 number of non-zero polys in F More...
 
void id_Normalize (ideal id, const ring r)
 normialize all polys in id More...
 
int id_MinDegW (ideal M, intvec *w, const ring r)
 
void id_DBTest (ideal h1, int level, const char *f, const int l, const ring lR, const ring tR)
 Internal verification for ideals/modules and dense matrices! More...
 
void id_DBLmTest (ideal h1, int level, const char *f, const int l, const ring r)
 Internal verification for ideals/modules and dense matrices! More...
 
ideal id_Copy (ideal h1, const ring r)
 copy an ideal More...
 
ideal id_SimpleAdd (ideal h1, ideal h2, const ring r)
 concat the lists h1 and h2 without zeros More...
 
ideal id_Add (ideal h1, ideal h2, const ring r)
 h1 + h2 More...
 
ideal id_Power (ideal given, int exp, const ring r)
 
BOOLEAN idIs0 (ideal h)
 returns true if h is the zero ideal More...
 
long id_RankFreeModule (ideal m, ring lmRing, ring tailRing)
 return the maximal component number found in any polynomial in s More...
 
static long id_RankFreeModule (ideal m, ring r)
 
ideal id_FreeModule (int i, const ring r)
 the free module of rank i More...
 
int id_PosConstant (ideal id, const ring r)
 index of generator with leading term in ground ring (if any); otherwise -1 More...
 
ideal id_Head (ideal h, const ring r)
 returns the ideals of initial terms More...
 
ideal id_MaxIdeal (const ring r)
 initialise the maximal ideal (at 0) More...
 
ideal id_MaxIdeal (int deg, const ring r)
 
ideal id_CopyFirstK (const ideal ide, const int k, const ring r)
 copies the first k (>= 1) entries of the given ideal/module and returns these as a new ideal/module (Note that the copied entries may be zero.) More...
 
void id_DelMultiples (ideal id, const ring r)
 ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i More...
 
void id_Norm (ideal id, const ring r)
 ideal id = (id[i]), result is leadcoeff(id[i]) = 1 More...
 
void id_DelEquals (ideal id, const ring r)
 ideal id = (id[i]) if id[i] = id[j] then id[j] is deleted for j > i More...
 
void id_DelLmEquals (ideal id, const ring r)
 Delete id[j], if Lm(j) == Lm(i) and both LC(j), LC(i) are units and j > i. More...
 
void id_DelDiv (ideal id, const ring r)
 delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*LT(j) More...
 
void id_DelDiv_Sorted (ideal id, const ring r)
 delete id[j], if LT(j) == coeff*mon*LT(i) (j>i) More...
 
BOOLEAN id_IsConstant (ideal id, const ring r)
 test if the ideal has only constant polynomials NOTE: zero ideal/module is also constant More...
 
intvecid_Sort (const ideal id, const BOOLEAN nolex, const ring r)
 sorts the ideal w.r.t. the actual ringordering uses lex-ordering when nolex = FALSE More...
 
ideal id_Transp (ideal a, const ring rRing)
 transpose a module More...
 
void id_Compactify (ideal id, const ring r)
 
ideal id_Mult (ideal h1, ideal h2, const ring r)
 h1 * h2 one h_i must be an ideal (with at least one column) the other h_i may be a module (with no columns at all) More...
 
ideal id_Homogen (ideal h, int varnum, const ring r)
 
BOOLEAN id_HomIdeal (ideal id, ideal Q, const ring r)
 
BOOLEAN id_HomIdealW (ideal id, ideal Q, const intvec *w, const ring r)
 
BOOLEAN id_HomModuleW (ideal id, ideal Q, const intvec *w, const intvec *module_w, const ring r)
 
BOOLEAN id_HomModule (ideal m, ideal Q, intvec **w, const ring R)
 
BOOLEAN id_IsZeroDim (ideal I, const ring r)
 
ideal id_Jet (const ideal i, int d, const ring R)
 
ideal id_JetW (const ideal i, int d, intvec *iv, const ring R)
 
ideal id_Subst (ideal id, int n, poly e, const ring r)
 
matrix id_Module2Matrix (ideal mod, const ring R)
 
matrix id_Module2formatedMatrix (ideal mod, int rows, int cols, const ring R)
 
ideal id_ResizeModule (ideal mod, int rows, int cols, const ring R)
 
ideal id_Matrix2Module (matrix mat, const ring R)
 converts mat to module, destroys mat More...
 
ideal id_Vec2Ideal (poly vec, const ring R)
 
int id_ReadOutPivot (ideal arg, int *comp, const ring r)
 
int binom (int n, int r)
 
void idInitChoise (int r, int beg, int end, BOOLEAN *endch, int *choise)
 
void idGetNextChoise (int r, int end, BOOLEAN *endch, int *choise)
 
int idGetNumberOfChoise (int t, int d, int begin, int end, int *choise)
 
void idShow (const ideal id, const ring lmRing, const ring tailRing, const int debugPrint=0)
 
BOOLEAN id_InsertPolyWithTests (ideal h1, const int validEntries, const poly h2, const bool zeroOk, const bool duplicateOk, const ring r)
 insert h2 into h1 depending on the two boolean parameters: More...
 
intvecid_QHomWeight (ideal id, const ring r)
 
ideal id_ChineseRemainder (ideal *xx, number *q, int rl, const ring r)
 
void id_Shift (ideal M, int s, const ring r)
 
ideal id_Delete_Pos (const ideal I, const int pos, const ring r)
 
poly id_Array2Vector (poly *m, unsigned n, const ring R)
 for julia: convert an array of poly to vector More...
 

Variables

EXTERN_VAR omBin sip_sideal_bin
 

Data Structure Documentation

◆ sip_sideal

struct sip_sideal

The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it are:

  • ideal/module: nrows = 1, ncols >=0 and rank:1 for ideals, rank>=0 for modules
  • matrix: nrows, ncols >=0, rank == nrows! see mp_* procedures NOTE: the m member point to memory chunk of size (ncols*nrows*sizeof(poly)) or is NULL

Definition at line 17 of file simpleideals.h.

Data Fields
poly * m
int ncols
int nrows
long rank

◆ sip_smap

struct sip_smap

Definition at line 32 of file simpleideals.h.

Data Fields
poly * m
int ncols
int nrows
char * preimage

◆ sideal_list

struct sideal_list

Definition at line 45 of file simpleideals.h.

Data Fields
ideal d
ideal_list next
int nr

Macro Definition Documentation

◆ id_Elem

#define id_Elem (   F,
  R 
)    idElem(F)

Definition at line 68 of file simpleideals.h.

◆ id_Init

#define id_Init (   s,
  r,
  R 
)    idInit(s,r)

Definition at line 58 of file simpleideals.h.

◆ id_LmTest

#define id_LmTest (   A,
  lR 
)    id_DBLmTest(A, PDEBUG, __FILE__,__LINE__, lR)

Definition at line 79 of file simpleideals.h.

◆ id_Print

#define id_Print (   id,
  lR,
  tR 
)    idShow(id, lR, tR)

Definition at line 150 of file simpleideals.h.

◆ id_Test

#define id_Test (   A,
  lR 
)    id_DBTest(A, PDEBUG, __FILE__,__LINE__, lR, lR)

Definition at line 78 of file simpleideals.h.

◆ IDELEMS

#define IDELEMS (   i)    ((i)->ncols)

Definition at line 23 of file simpleideals.h.

Function Documentation

◆ binom()

int binom ( int  n,
int  r 
)

Definition at line 1081 of file simpleideals.cc.

1082 {
1083  int i;
1084  int64 result;
1085 
1086  if (r==0) return 1;
1087  if (n-r<r) return binom(n,n-r);
1088  result = n-r+1;
1089  for (i=2;i<=r;i++)
1090  {
1091  result *= n-r+i;
1092  result /= i;
1093  }
1094  if (result>MAX_INT_VAL)
1095  {
1096  WarnS("overflow in binomials");
1097  result=0;
1098  }
1099  return (int)result;
1100 }
long int64
Definition: auxiliary.h:68
int i
Definition: cfEzgcd.cc:132
#define WarnS
Definition: emacs.cc:78
return result
Definition: facAbsBiFact.cc:75
const int MAX_INT_VAL
Definition: mylimits.h:12
int binom(int n, int r)

◆ id_Add()

ideal id_Add ( ideal  h1,
ideal  h2,
const ring  r 
)

h1 + h2

Definition at line 838 of file simpleideals.cc.

839 {
840  id_Test(h1, r);
841  id_Test(h2, r);
842 
843  ideal result = id_SimpleAdd(h1,h2,r);
845  return result;
846 }
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
void id_Compactify(ideal id, const ring r)
#define id_Test(A, lR)
Definition: simpleideals.h:78

◆ id_Array2Vector()

poly id_Array2Vector ( poly *  m,
unsigned  n,
const ring  R 
)

for julia: convert an array of poly to vector

Definition at line 1385 of file simpleideals.cc.

1386 {
1387  poly h;
1388  int l;
1389  sBucket_pt bucket = sBucketCreate(R);
1390 
1391  for(unsigned j=0;j<n ;j++)
1392  {
1393  h = m[j];
1394  if (h!=NULL)
1395  {
1396  h=p_Copy(h, R);
1397  l=pLength(h);
1398  p_SetCompP(h,j+1, R);
1399  sBucket_Merge_p(bucket, h, l);
1400  }
1401  }
1402  sBucketClearMerge(bucket, &h, &l);
1403  sBucketDestroy(&bucket);
1404  return h;
1405 }
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int j
Definition: facHensel.cc:110
STATIC_VAR Poly * h
Definition: janet.cc:971
#define NULL
Definition: omList.c:12
static void p_SetCompP(poly p, int i, ring r)
Definition: p_polys.h:256
static unsigned pLength(poly a)
Definition: p_polys.h:191
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:848
void sBucketClearMerge(sBucket_pt bucket, poly *p, int *length)
Definition: sbuckets.cc:237
void sBucket_Merge_p(sBucket_pt bucket, poly p, int length)
Merges p into Spoly: assumes Bpoly and p have no common monoms destroys p!
Definition: sbuckets.cc:148
void sBucketDestroy(sBucket_pt *bucket)
Definition: sbuckets.cc:103
sBucket_pt sBucketCreate(const ring r)
Definition: sbuckets.cc:96
#define R
Definition: sirandom.c:27

◆ id_ChineseRemainder()

ideal id_ChineseRemainder ( ideal *  xx,
number *  q,
int  rl,
const ring  r 
)

Definition at line 2038 of file simpleideals.cc.

2039 {
2040  int cnt=0;int rw=0; int cl=0;
2041  int i,j;
2042  // find max. size of xx[.]:
2043  for(j=rl-1;j>=0;j--)
2044  {
2045  i=IDELEMS(xx[j])*xx[j]->nrows;
2046  if (i>cnt) cnt=i;
2047  if (xx[j]->nrows >rw) rw=xx[j]->nrows; // for lifting matrices
2048  if (xx[j]->ncols >cl) cl=xx[j]->ncols; // for lifting matrices
2049  }
2050  if (rw*cl !=cnt)
2051  {
2052  WerrorS("format mismatch in CRT");
2053  return NULL;
2054  }
2055  ideal result=idInit(cnt,xx[0]->rank);
2056  result->nrows=rw; // for lifting matrices
2057  result->ncols=cl; // for lifting matrices
2058  number *x=(number *)omAlloc(rl*sizeof(number));
2059  poly *p=(poly *)omAlloc(rl*sizeof(poly));
2060  CFArray inv_cache(rl);
2061  EXTERN_VAR int n_SwitchChinRem; //TEST
2062  int save_n_SwitchChinRem=n_SwitchChinRem;
2063  n_SwitchChinRem=1;
2064  for(i=cnt-1;i>=0;i--)
2065  {
2066  for(j=rl-1;j>=0;j--)
2067  {
2068  if(i>=IDELEMS(xx[j])*xx[j]->nrows) // out of range of this ideal
2069  p[j]=NULL;
2070  else
2071  p[j]=xx[j]->m[i];
2072  }
2073  result->m[i]=p_ChineseRemainder(p,x,q,rl,inv_cache,r);
2074  for(j=rl-1;j>=0;j--)
2075  {
2076  if(i<IDELEMS(xx[j])*xx[j]->nrows) xx[j]->m[i]=p[j];
2077  }
2078  }
2079  n_SwitchChinRem=save_n_SwitchChinRem;
2080  omFreeSize(p,rl*sizeof(poly));
2081  omFreeSize(x,rl*sizeof(number));
2082  for(i=rl-1;i>=0;i--) id_Delete(&(xx[i]),r);
2083  omFreeSize(xx,rl*sizeof(ideal));
2084  return result;
2085 }
Variable x
Definition: cfModGcd.cc:4082
int p
Definition: cfModGcd.cc:4078
cl
Definition: cfModGcd.cc:4100
int int ncols
Definition: cf_linsys.cc:32
int nrows
Definition: cf_linsys.cc:32
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define EXTERN_VAR
Definition: globaldefs.h:6
poly p_ChineseRemainder(poly *xx, mpz_ptr *x, mpz_ptr *q, int rl, mpz_ptr *C, const ring R)
VAR int n_SwitchChinRem
Definition: longrat.cc:3094
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ id_Compactify()

void id_Compactify ( ideal  id,
const ring  r 
)

Definition at line 1328 of file simpleideals.cc.

1329 {
1330  int i;
1331  BOOLEAN b=FALSE;
1332 
1333  i = IDELEMS(id)-1;
1334  while ((! b) && (i>=0))
1335  {
1336  b=p_IsUnit(id->m[i],r);
1337  i--;
1338  }
1339  if (b)
1340  {
1341  for(i=IDELEMS(id)-1;i>=0;i--) p_Delete(&id->m[i],r);
1342  id->m[0]=p_One(r);
1343  }
1344  else
1345  {
1346  id_DelMultiples(id,r);
1347  }
1348  idSkipZeroes(id);
1349 }
int BOOLEAN
Definition: auxiliary.h:87
#define FALSE
Definition: auxiliary.h:96
CanonicalForm b
Definition: cfModGcd.cc:4103
poly p_One(const ring r)
Definition: p_polys.cc:1313
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:903
static BOOLEAN p_IsUnit(const poly p, const ring r)
Definition: p_polys.h:2032
void id_DelMultiples(ideal id, const ring r)
ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size

◆ id_Copy()

ideal id_Copy ( ideal  h1,
const ring  r 
)

copy an ideal

Definition at line 474 of file simpleideals.cc.

475 {
476  id_Test(h1, r);
477 
478  ideal h2 = idInit(IDELEMS(h1), h1->rank);
479  for (int i=IDELEMS(h1)-1; i>=0; i--)
480  h2->m[i] = p_Copy(h1->m[i],r);
481  return h2;
482 }

◆ id_CopyFirstK()

ideal id_CopyFirstK ( const ideal  ide,
const int  k,
const ring  r 
)

copies the first k (>= 1) entries of the given ideal/module and returns these as a new ideal/module (Note that the copied entries may be zero.)

Definition at line 237 of file simpleideals.cc.

238 {
239  id_Test(ide, r);
240 
241  assume( ide != NULL );
242  assume( k <= IDELEMS(ide) );
243 
244  ideal newI = idInit(k, ide->rank);
245 
246  for (int i = 0; i < k; i++)
247  newI->m[i] = p_Copy(ide->m[i],r);
248 
249  return newI;
250 }
int k
Definition: cfEzgcd.cc:99
#define assume(x)
Definition: mod2.h:389

◆ id_DBLmTest()

void id_DBLmTest ( ideal  h1,
int  level,
const char *  f,
const int  l,
const ring  r 
)

Internal verification for ideals/modules and dense matrices!

Definition at line 537 of file simpleideals.cc.

538 {
539  if (h1 != NULL)
540  {
541  // assume(IDELEMS(h1) > 0); for ideal/module, does not apply to matrix
542  omCheckAddrSize(h1,sizeof(*h1));
543 
544  assume( h1->ncols >= 0 );
545  assume( h1->nrows >= 0 ); // matrix case!
546 
547  assume( h1->rank >= 0 );
548 
549  const long n = ((long)h1->ncols * (long)h1->nrows);
550 
551  assume( !( n > 0 && h1->m == NULL) );
552 
553  if( h1->m != NULL && n > 0 )
554  omdebugAddrSize(h1->m, n * sizeof(poly));
555 
556  long new_rk = 0; // inlining id_RankFreeModule(h1, r, tailRing);
557 
558  /* to be able to test matrices: */
559  for (long i=n - 1; i >= 0; i--)
560  {
561  if (h1->m[i]!=NULL)
562  {
563  _p_LmTest(h1->m[i], r, level);
564  const long k = p_GetComp(h1->m[i], r);
565  if (k > new_rk) new_rk = k;
566  }
567  }
568 
569  // dense matrices only contain polynomials:
570  // h1->nrows == h1->rank > 1 && new_rk == 0!
571  assume( !( h1->nrows == h1->rank && h1->nrows > 1 && new_rk > 0 ) ); //
572 
573  if(new_rk > h1->rank)
574  {
575  dReportError("wrong rank %d (should be %d) in %s:%d\n",
576  h1->rank, new_rk, f,l);
577  omPrintAddrInfo(stderr, h1, " for ideal");
578  h1->rank = new_rk;
579  }
580  }
581  else
582  {
583  Print("error: ideal==NULL in %s:%d\n",f,l);
584  assume( h1 != NULL );
585  }
586 }
int level(const CanonicalForm &f)
FILE * f
Definition: checklibs.c:9
#define Print
Definition: emacs.cc:80
int dReportError(const char *fmt,...)
Definition: dError.cc:44
#define p_GetComp(p, r)
Definition: monomials.h:64
#define omdebugAddrSize(addr, size)
Definition: omAllocDecl.h:315
#define omCheckAddrSize(addr, size)
Definition: omAllocDecl.h:327
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition: pDebug.cc:323
#define omPrintAddrInfo(A, B, C)
Definition: xalloc.h:270

◆ id_DBTest()

void id_DBTest ( ideal  h1,
int  level,
const char *  f,
const int  l,
const ring  lR,
const ring  tR 
)

Internal verification for ideals/modules and dense matrices!

Definition at line 486 of file simpleideals.cc.

487 {
488  if (h1 != NULL)
489  {
490  // assume(IDELEMS(h1) > 0); for ideal/module, does not apply to matrix
491  omCheckAddrSize(h1,sizeof(*h1));
492 
493  assume( h1->ncols >= 0 );
494  assume( h1->nrows >= 0 ); // matrix case!
495 
496  assume( h1->rank >= 0 );
497 
498  const long n = ((long)h1->ncols * (long)h1->nrows);
499 
500  assume( !( n > 0 && h1->m == NULL) );
501 
502  if( h1->m != NULL && n > 0 )
503  omdebugAddrSize(h1->m, n * sizeof(poly));
504 
505  long new_rk = 0; // inlining id_RankFreeModule(h1, r, tailRing);
506 
507  /* to be able to test matrices: */
508  for (long i=n - 1; i >= 0; i--)
509  {
510  _pp_Test(h1->m[i], r, tailRing, level);
511  const long k = p_MaxComp(h1->m[i], r, tailRing);
512  if (k > new_rk) new_rk = k;
513  }
514 
515  // dense matrices only contain polynomials:
516  // h1->nrows == h1->rank > 1 && new_rk == 0!
517  assume( !( h1->nrows == h1->rank && h1->nrows > 1 && new_rk > 0 ) ); //
518 
519  if(new_rk > h1->rank)
520  {
521  dReportError("wrong rank %d (should be %d) in %s:%d\n",
522  h1->rank, new_rk, f,l);
523  omPrintAddrInfo(stderr, h1, " for ideal");
524  h1->rank = new_rk;
525  }
526  }
527  else
528  {
529  Print("error: ideal==NULL in %s:%d\n",f,l);
530  assume( h1 != NULL );
531  }
532 }
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:294
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
Definition: pDebug.cc:333

◆ id_DelDiv()

void id_DelDiv ( ideal  id,
const ring  r 
)

delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*LT(j)

Definition at line 388 of file simpleideals.cc.

389 {
390  id_Test(id, r);
391 
392  int i, j;
393  int k = IDELEMS(id)-1;
394 #ifdef HAVE_RINGS
395  if (rField_is_Ring(r))
396  {
397  for (i=k-1; i>=0; i--)
398  {
399  if (id->m[i] != NULL)
400  {
401  for (j=k; j>i; j--)
402  {
403  if (id->m[j]!=NULL)
404  {
405  if (p_DivisibleByRingCase(id->m[i], id->m[j],r))
406  {
407  p_Delete(&id->m[j],r);
408  }
409  else if (p_DivisibleByRingCase(id->m[j], id->m[i],r))
410  {
411  p_Delete(&id->m[i],r);
412  break;
413  }
414  }
415  }
416  }
417  }
418  }
419  else
420 #endif
421  {
422  /* the case of a coefficient field: */
423  if (k>10)
424  {
425  id_DelDiv_SEV(id,k,r);
426  return;
427  }
428  for (i=k-1; i>=0; i--)
429  {
430  if (id->m[i] != NULL)
431  {
432  for (j=k; j>i; j--)
433  {
434  if (id->m[j]!=NULL)
435  {
436  if (p_LmDivisibleBy(id->m[i], id->m[j],r))
437  {
438  p_Delete(&id->m[j],r);
439  }
440  else if (p_LmDivisibleBy(id->m[j], id->m[i],r))
441  {
442  p_Delete(&id->m[i],r);
443  break;
444  }
445  }
446  }
447  }
448  }
449  }
450 }
BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r)
divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g),...
Definition: p_polys.cc:1638
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1897
#define rField_is_Ring(R)
Definition: ring.h:486
static void id_DelDiv_SEV(ideal id, int k, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) (j>i)

◆ id_DelDiv_Sorted()

void id_DelDiv_Sorted ( ideal  id,
const ring  r 
)

delete id[j], if LT(j) == coeff*mon*LT(i) (j>i)

Definition at line 453 of file simpleideals.cc.

454 {
455  int k = IDELEMS(id)-1;
456  id_DelDiv_SEV(id,k,r);
457 }

◆ id_DelEquals()

void id_DelEquals ( ideal  id,
const ring  r 
)

ideal id = (id[i]) if id[i] = id[j] then id[j] is deleted for j > i

Definition at line 302 of file simpleideals.cc.

303 {
304  id_Test(id, r);
305 
306  int i, j;
307  int k = IDELEMS(id)-1;
308  for (i=k; i>=0; i--)
309  {
310  if (id->m[i]!=NULL)
311  {
312  for (j=k; j>i; j--)
313  {
314  if ((id->m[j]!=NULL)
315  && (p_EqualPolys(id->m[i], id->m[j],r)))
316  {
317  p_Delete(&id->m[j],r);
318  }
319  }
320  }
321  }
322 }
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition: p_polys.cc:4628

◆ id_Delete()

void id_Delete ( ideal *  h,
ring  r 
)

deletes an ideal/module/matrix

Definition at line 123 of file simpleideals.cc.

124 {
125  if (*h == NULL)
126  return;
127 
128  id_Test(*h, r);
129 
130  const long elems = (long)(*h)->nrows * (long)(*h)->ncols;
131 
132  if ( elems > 0 )
133  {
134  assume( (*h)->m != NULL );
135 
136  if (r!=NULL)
137  {
138  long j = elems;
139  do
140  {
141  j--;
142  poly pp=((*h)->m[j]);
143  if (pp!=NULL) p_Delete(&pp, r);
144  }
145  while (j>0);
146  }
147 
148  omFreeSize((ADDRESS)((*h)->m),sizeof(poly)*elems);
149  }
150 
152  *h=NULL;
153 }
void * ADDRESS
Definition: auxiliary.h:119
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
VAR omBin sip_sideal_bin
Definition: simpleideals.cc:27

◆ id_Delete_Pos()

ideal id_Delete_Pos ( const ideal  I,
const int  pos,
const ring  r 
)

Definition at line 2101 of file simpleideals.cc.

2102 {
2103  if ((p<0)||(p>=IDELEMS(I))) return NULL;
2104  ideal ret=idInit(IDELEMS(I)-1,I->rank);
2105  for(int i=0;i<p;i++) ret->m[i]=p_Copy(I->m[i],r);
2106  for(int i=p+1;i<IDELEMS(I);i++) ret->m[i-1]=p_Copy(I->m[i],r);
2107  return ret;
2108 }

◆ id_DelLmEquals()

void id_DelLmEquals ( ideal  id,
const ring  r 
)

Delete id[j], if Lm(j) == Lm(i) and both LC(j), LC(i) are units and j > i.

Definition at line 325 of file simpleideals.cc.

326 {
327  id_Test(id, r);
328 
329  int i, j;
330  int k = IDELEMS(id)-1;
331  for (i=k; i>=0; i--)
332  {
333  if (id->m[i] != NULL)
334  {
335  for (j=k; j>i; j--)
336  {
337  if ((id->m[j] != NULL)
338  && p_LmEqual(id->m[i], id->m[j],r)
339 #ifdef HAVE_RINGS
340  && n_IsUnit(pGetCoeff(id->m[i]),r->cf) && n_IsUnit(pGetCoeff(id->m[j]),r->cf)
341 #endif
342  )
343  {
344  p_Delete(&id->m[j],r);
345  }
346  }
347  }
348  }
349 }
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition: coeffs.h:515
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define p_LmEqual(p1, p2, r)
Definition: p_polys.h:1725

◆ id_DelMultiples()

void id_DelMultiples ( ideal  id,
const ring  r 
)

ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i

Definition at line 267 of file simpleideals.cc.

268 {
269  id_Test(id, r);
270 
271  int i, j;
272  int k = IDELEMS(id)-1;
273  for (i=k; i>=0; i--)
274  {
275  if (id->m[i]!=NULL)
276  {
277  for (j=k; j>i; j--)
278  {
279  if (id->m[j]!=NULL)
280  {
281  if (rField_is_Ring(r))
282  {
283  /* if id[j] = c*id[i] then delete id[j].
284  In the below cases of a ground field, we
285  check whether id[i] = c*id[j] and, if so,
286  delete id[j] for historical reasons (so
287  that previous output does not change) */
288  if (p_ComparePolys(id->m[j], id->m[i],r)) p_Delete(&id->m[j],r);
289  }
290  else
291  {
292  if (p_ComparePolys(id->m[i], id->m[j],r)) p_Delete(&id->m[j],r);
293  }
294  }
295  }
296  }
297  }
298 }
BOOLEAN p_ComparePolys(poly p1, poly p2, const ring r)
returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
Definition: p_polys.cc:4692

◆ id_FreeModule()

ideal id_FreeModule ( int  i,
const ring  r 
)

the free module of rank i

Definition at line 1104 of file simpleideals.cc.

1105 {
1106  assume(i >= 0);
1107  if (r->isLPring)
1108  {
1109  PrintS("In order to address bimodules, the command freeAlgebra should be used.");
1110  }
1111  ideal h = idInit(i, i);
1112 
1113  for (int j=0; j<i; j++)
1114  {
1115  h->m[j] = p_One(r);
1116  p_SetComp(h->m[j],j+1,r);
1117  p_SetmComp(h->m[j],r);
1118  }
1119 
1120  return h;
1121 }
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:249
#define p_SetmComp
Definition: p_polys.h:246
void PrintS(const char *s)
Definition: reporter.cc:284

◆ id_Head()

ideal id_Head ( ideal  h,
const ring  r 
)

returns the ideals of initial terms

Definition at line 1352 of file simpleideals.cc.

1353 {
1354  ideal m = idInit(IDELEMS(h),h->rank);
1355 
1356  for (int i=IDELEMS(h)-1;i>=0; i--)
1357  if (h->m[i]!=NULL)
1358  m->m[i]=p_Head(h->m[i],r);
1359 
1360  return m;
1361 }
static poly p_Head(const poly p, const ring r)
copy the (leading) term of p
Definition: p_polys.h:862

◆ id_HomIdeal()

BOOLEAN id_HomIdeal ( ideal  id,
ideal  Q,
const ring  r 
)

Definition at line 928 of file simpleideals.cc.

929 {
930  int i;
931  BOOLEAN b;
932  i = 0;
933  b = TRUE;
934  while ((i < IDELEMS(id)) && b)
935  {
936  b = p_IsHomogeneous(id->m[i],r);
937  i++;
938  }
939  if ((b) && (Q!=NULL) && (IDELEMS(Q)>0))
940  {
941  i=0;
942  while ((i < IDELEMS(Q)) && b)
943  {
944  b = p_IsHomogeneous(Q->m[i],r);
945  i++;
946  }
947  }
948  return b;
949 }
#define TRUE
Definition: auxiliary.h:100
STATIC_VAR jList * Q
Definition: janet.cc:30
BOOLEAN p_IsHomogeneous(poly p, const ring r)
Definition: p_polys.cc:3384

◆ id_HomIdealW()

BOOLEAN id_HomIdealW ( ideal  id,
ideal  Q,
const intvec w,
const ring  r 
)

Definition at line 951 of file simpleideals.cc.

952 {
953  int i;
954  BOOLEAN b;
955  i = 0;
956  b = TRUE;
957  while ((i < IDELEMS(id)) && b)
958  {
959  b = p_IsHomogeneousW(id->m[i],w,r);
960  i++;
961  }
962  if ((b) && (Q!=NULL) && (IDELEMS(Q)>0))
963  {
964  i=0;
965  while ((i < IDELEMS(Q)) && b)
966  {
967  b = p_IsHomogeneousW(Q->m[i],w,r);
968  i++;
969  }
970  }
971  return b;
972 }
const CanonicalForm & w
Definition: facAbsFact.cc:51
BOOLEAN p_IsHomogeneousW(poly p, const intvec *w, const ring r)
Definition: p_polys.cc:3408

◆ id_HomModule()

BOOLEAN id_HomModule ( ideal  m,
ideal  Q,
intvec **  w,
const ring  R 
)

Definition at line 1572 of file simpleideals.cc.

1573 {
1574  if (w!=NULL) *w=NULL;
1575  if ((Q!=NULL) && (!id_HomIdeal(Q,NULL,R))) return FALSE;
1576  if (idIs0(m))
1577  {
1578  if (w!=NULL) (*w)=new intvec(m->rank);
1579  return TRUE;
1580  }
1581 
1582  long cmax=1,order=0,ord,* diff,diffmin=32000;
1583  int *iscom;
1584  int i;
1585  poly p=NULL;
1586  pFDegProc d;
1587  if (R->pLexOrder && (R->order[0]==ringorder_lp))
1588  d=p_Totaldegree;
1589  else
1590  d=R->pFDeg;
1591  int length=IDELEMS(m);
1592  poly* P=m->m;
1593  poly* F=(poly*)omAlloc(length*sizeof(poly));
1594  for (i=length-1;i>=0;i--)
1595  {
1596  p=F[i]=P[i];
1597  cmax=si_max(cmax,p_MaxComp(p,R));
1598  }
1599  cmax++;
1600  diff = (long *)omAlloc0(cmax*sizeof(long));
1601  if (w!=NULL) *w=new intvec(cmax-1);
1602  iscom = (int *)omAlloc0(cmax*sizeof(int));
1603  i=0;
1604  while (i<=length)
1605  {
1606  if (i<length)
1607  {
1608  p=F[i];
1609  while ((p!=NULL) && (iscom[__p_GetComp(p,R)]==0)) pIter(p);
1610  }
1611  if ((p==NULL) && (i<length))
1612  {
1613  i++;
1614  }
1615  else
1616  {
1617  if (p==NULL) /* && (i==length) */
1618  {
1619  i=0;
1620  while ((i<length) && (F[i]==NULL)) i++;
1621  if (i>=length) break;
1622  p = F[i];
1623  }
1624  //if (pLexOrder && (currRing->order[0]==ringorder_lp))
1625  // order=pTotaldegree(p);
1626  //else
1627  // order = p->order;
1628  // order = pFDeg(p,currRing);
1629  order = d(p,R) +diff[__p_GetComp(p,R)];
1630  //order += diff[pGetComp(p)];
1631  p = F[i];
1632 //Print("Actual p=F[%d]: ",i);pWrite(p);
1633  F[i] = NULL;
1634  i=0;
1635  }
1636  while (p!=NULL)
1637  {
1638  if (R->pLexOrder && (R->order[0]==ringorder_lp))
1639  ord=p_Totaldegree(p,R);
1640  else
1641  // ord = p->order;
1642  ord = R->pFDeg(p,R);
1643  if (iscom[__p_GetComp(p,R)]==0)
1644  {
1645  diff[__p_GetComp(p,R)] = order-ord;
1646  iscom[__p_GetComp(p,R)] = 1;
1647 /*
1648 *PrintS("new diff: ");
1649 *for (j=0;j<cmax;j++) Print("%d ",diff[j]);
1650 *PrintLn();
1651 *PrintS("new iscom: ");
1652 *for (j=0;j<cmax;j++) Print("%d ",iscom[j]);
1653 *PrintLn();
1654 *Print("new set %d, order %d, ord %d, diff %d\n",pGetComp(p),order,ord,diff[pGetComp(p)]);
1655 */
1656  }
1657  else
1658  {
1659 /*
1660 *PrintS("new diff: ");
1661 *for (j=0;j<cmax;j++) Print("%d ",diff[j]);
1662 *PrintLn();
1663 *Print("order %d, ord %d, diff %d\n",order,ord,diff[pGetComp(p)]);
1664 */
1665  if (order != (ord+diff[__p_GetComp(p,R)]))
1666  {
1667  omFreeSize((ADDRESS) iscom,cmax*sizeof(int));
1668  omFreeSize((ADDRESS) diff,cmax*sizeof(long));
1669  omFreeSize((ADDRESS) F,length*sizeof(poly));
1670  delete *w;*w=NULL;
1671  return FALSE;
1672  }
1673  }
1674  pIter(p);
1675  }
1676  }
1677  omFreeSize((ADDRESS) iscom,cmax*sizeof(int));
1678  omFreeSize((ADDRESS) F,length*sizeof(poly));
1679  for (i=1;i<cmax;i++) (**w)[i-1]=(int)(diff[i]);
1680  for (i=1;i<cmax;i++)
1681  {
1682  if (diff[i]<diffmin) diffmin=diff[i];
1683  }
1684  if (w!=NULL)
1685  {
1686  for (i=1;i<cmax;i++)
1687  {
1688  (**w)[i-1]=(int)(diff[i]-diffmin);
1689  }
1690  }
1691  omFreeSize((ADDRESS) diff,cmax*sizeof(long));
1692  return TRUE;
1693 }
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
Definition: intvec.h:23
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
#define pIter(p)
Definition: monomials.h:37
#define __p_GetComp(p, r)
Definition: monomials.h:63
STATIC_VAR gmp_float * diff
Definition: mpr_complex.cc:45
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1509
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:38
@ ringorder_lp
Definition: ring.h:77
BOOLEAN id_HomIdeal(ideal id, ideal Q, const ring r)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal

◆ id_HomModuleW()

BOOLEAN id_HomModuleW ( ideal  id,
ideal  Q,
const intvec w,
const intvec module_w,
const ring  r 
)

Definition at line 974 of file simpleideals.cc.

975 {
976  int i;
977  BOOLEAN b;
978  i = 0;
979  b = TRUE;
980  while ((i < IDELEMS(id)) && b)
981  {
982  b = p_IsHomogeneousW(id->m[i],w,module_w,r);
983  i++;
984  }
985  if ((b) && (Q!=NULL) && (IDELEMS(Q)>0))
986  {
987  i=0;
988  while ((i < IDELEMS(Q)) && b)
989  {
990  b = p_IsHomogeneousW(Q->m[i],w,r);
991  i++;
992  }
993  }
994  return b;
995 }

◆ id_Homogen()

ideal id_Homogen ( ideal  h,
int  varnum,
const ring  r 
)

Definition at line 1363 of file simpleideals.cc.

1364 {
1365  ideal m = idInit(IDELEMS(h),h->rank);
1366  int i;
1367 
1368  for (i=IDELEMS(h)-1;i>=0; i--)
1369  {
1370  m->m[i]=p_Homogen(h->m[i],varnum,r);
1371  }
1372  return m;
1373 }
poly p_Homogen(poly p, int varnum, const ring r)
Definition: p_polys.cc:3335

◆ id_InsertPolyWithTests()

BOOLEAN id_InsertPolyWithTests ( ideal  h1,
const int  validEntries,
const poly  h2,
const bool  zeroOk,
const bool  duplicateOk,
const ring  r 
)

insert h2 into h1 depending on the two boolean parameters:

  • if zeroOk is true, then h2 will also be inserted when it is zero
  • if duplicateOk is true, then h2 will also be inserted when it is already present in h1 return TRUE iff h2 was indeed inserted

Definition at line 810 of file simpleideals.cc.

812 {
813  id_Test(h1, r);
814  p_Test(h2, r);
815 
816  if ((!zeroOk) && (h2 == NULL)) return FALSE;
817  if (!duplicateOk)
818  {
819  bool h2FoundInH1 = false;
820  int i = 0;
821  while ((i < validEntries) && (!h2FoundInH1))
822  {
823  h2FoundInH1 = p_EqualPolys(h1->m[i], h2,r);
824  i++;
825  }
826  if (h2FoundInH1) return FALSE;
827  }
828  if (validEntries == IDELEMS(h1))
829  {
830  pEnlargeSet(&(h1->m), IDELEMS(h1), 16);
831  IDELEMS(h1) += 16;
832  }
833  h1->m[validEntries] = h2;
834  return TRUE;
835 }
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3812
#define p_Test(p, r)
Definition: p_polys.h:162

◆ id_IsConstant()

BOOLEAN id_IsConstant ( ideal  id,
const ring  r 
)

test if the ideal has only constant polynomials NOTE: zero ideal/module is also constant

Definition at line 461 of file simpleideals.cc.

462 {
463  id_Test(id, r);
464 
465  for (int k = IDELEMS(id)-1; k>=0; k--)
466  {
467  if (!p_IsConstantPoly(id->m[k],r))
468  return FALSE;
469  }
470  return TRUE;
471 }
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:2019

◆ id_IsZeroDim()

BOOLEAN id_IsZeroDim ( ideal  I,
const ring  r 
)

Definition at line 1856 of file simpleideals.cc.

1857 {
1858  BOOLEAN *UsedAxis=(BOOLEAN *)omAlloc0(rVar(r)*sizeof(BOOLEAN));
1859  int i,n;
1860  poly po;
1861  BOOLEAN res=TRUE;
1862  for(i=IDELEMS(I)-1;i>=0;i--)
1863  {
1864  po=I->m[i];
1865  if ((po!=NULL) &&((n=p_IsPurePower(po,r))!=0)) UsedAxis[n-1]=TRUE;
1866  }
1867  for(i=rVar(r)-1;i>=0;i--)
1868  {
1869  if(UsedAxis[i]==FALSE) {res=FALSE; break;} // not zero-dim.
1870  }
1871  omFreeSize(UsedAxis,rVar(r)*sizeof(BOOLEAN));
1872  return res;
1873 }
CanonicalForm res
Definition: facAbsFact.cc:60
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1226
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:593

◆ id_Jet()

ideal id_Jet ( const ideal  i,
int  d,
const ring  R 
)

Definition at line 1695 of file simpleideals.cc.

1696 {
1697  ideal r=idInit((i->nrows)*(i->ncols),i->rank);
1698  r->nrows = i-> nrows;
1699  r->ncols = i-> ncols;
1700  //r->rank = i-> rank;
1701 
1702  for(long k=((long)(i->nrows))*((long)(i->ncols))-1;k>=0; k--)
1703  r->m[k]=pp_Jet(i->m[k],d,R);
1704 
1705  return r;
1706 }
poly pp_Jet(poly p, int m, const ring R)
Definition: p_polys.cc:4474

◆ id_JetW()

ideal id_JetW ( const ideal  i,
int  d,
intvec iv,
const ring  R 
)

Definition at line 1708 of file simpleideals.cc.

1709 {
1710  ideal r=idInit(IDELEMS(i),i->rank);
1711  if (ecartWeights!=NULL)
1712  {
1713  WerrorS("cannot compute weighted jets now");
1714  }
1715  else
1716  {
1717  int *w=iv2array(iv,R);
1718  int k;
1719  for(k=0; k<IDELEMS(i); k++)
1720  {
1721  r->m[k]=pp_JetW(i->m[k],d,w,R);
1722  }
1723  omFreeSize((ADDRESS)w,(rVar(R)+1)*sizeof(int));
1724  }
1725  return r;
1726 }
poly pp_JetW(poly p, int m, int *w, const ring R)
Definition: p_polys.cc:4519
int * iv2array(intvec *iv, const ring R)
Definition: weight.cc:200
EXTERN_VAR short * ecartWeights
Definition: weight.h:12

◆ id_Matrix2Module()

ideal id_Matrix2Module ( matrix  mat,
const ring  R 
)

converts mat to module, destroys mat

Definition at line 1408 of file simpleideals.cc.

1409 {
1410  int mc=MATCOLS(mat);
1411  int mr=MATROWS(mat);
1412  ideal result = idInit(mc,mr);
1413  int i,j,l;
1414  poly h;
1415  sBucket_pt bucket = sBucketCreate(R);
1416 
1417  for(j=0;j<mc /*MATCOLS(mat)*/;j++) /* j is also index in result->m */
1418  {
1419  for (i=0;i<mr /*MATROWS(mat)*/;i++)
1420  {
1421  h = MATELEM0(mat,i,j);
1422  if (h!=NULL)
1423  {
1424  l=pLength(h);
1425  MATELEM0(mat,i,j)=NULL;
1426  p_SetCompP(h,i+1, R);
1427  sBucket_Merge_p(bucket, h, l);
1428  }
1429  }
1430  sBucketClearMerge(bucket, &(result->m[j]), &l);
1431  }
1432  sBucketDestroy(&bucket);
1433 
1434  // obachman: need to clean this up
1435  id_Delete((ideal*) &mat,R);
1436  return result;
1437 }
#define MATELEM0(mat, i, j)
0-based access to matrix
Definition: matpol.h:31
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27

◆ id_MaxIdeal() [1/2]

ideal id_MaxIdeal ( const ring  r)

initialise the maximal ideal (at 0)

Definition at line 98 of file simpleideals.cc.

99 {
100  int nvars;
101 #ifdef HAVE_SHIFTBBA
102  if (r->isLPring)
103  {
104  nvars = r->isLPring;
105  }
106  else
107 #endif
108  {
109  nvars = rVar(r);
110  }
111  ideal hh = idInit(nvars, 1);
112  for (int l=nvars-1; l>=0; l--)
113  {
114  hh->m[l] = p_One(r);
115  p_SetExp(hh->m[l],l+1,1,r);
116  p_Setm(hh->m[l],r);
117  }
118  id_Test(hh, r);
119  return hh;
120 }
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:490
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:235

◆ id_MaxIdeal() [2/2]

ideal id_MaxIdeal ( int  deg,
const ring  r 
)

Definition at line 1221 of file simpleideals.cc.

1222 {
1223  if (deg < 1)
1224  {
1225  ideal I=idInit(1,1);
1226  I->m[0]=p_One(r);
1227  return I;
1228  }
1229  if (deg == 1
1230 #ifdef HAVE_SHIFTBBA
1231  && !r->isLPring
1232 #endif
1233  )
1234  {
1235  return id_MaxIdeal(r);
1236  }
1237 
1238  int vars, i;
1239 #ifdef HAVE_SHIFTBBA
1240  if (r->isLPring)
1241  {
1242  vars = r->isLPring - r->LPncGenCount;
1243  i = 1;
1244  // i = vars^deg
1245  for (int j = 0; j < deg; j++)
1246  {
1247  i *= vars;
1248  }
1249  }
1250  else
1251 #endif
1252  {
1253  vars = rVar(r);
1254  i = binom(vars+deg-1,deg);
1255  }
1256  if (i<=0) return idInit(1,1);
1257  ideal id=idInit(i,1);
1258  idpower = id->m;
1259  idpowerpoint = 0;
1260 #ifdef HAVE_SHIFTBBA
1261  if (r->isLPring)
1262  {
1263  lpmakemonoms(vars, deg, r);
1264  }
1265  else
1266 #endif
1267  {
1268  makemonoms(vars,1,deg,0,r);
1269  }
1270  idpower = NULL;
1271  idpowerpoint = 0;
1272  return id;
1273 }
STATIC_VAR int idpowerpoint
Definition: simpleideals.cc:31
STATIC_VAR poly * idpower
Definition: simpleideals.cc:29
static void makemonoms(int vars, int actvar, int deg, int monomdeg, const ring r)
ideal id_MaxIdeal(const ring r)
initialise the maximal ideal (at 0)
Definition: simpleideals.cc:98
static void lpmakemonoms(int vars, int deg, const ring r)

◆ id_MinDegW()

int id_MinDegW ( ideal  M,
intvec w,
const ring  r 
)

Definition at line 1885 of file simpleideals.cc.

1886 {
1887  int d=-1;
1888  for(int i=0;i<IDELEMS(M);i++)
1889  {
1890  if (M->m[i]!=NULL)
1891  {
1892  int d0=p_MinDeg(M->m[i],w,r);
1893  if(-1<d0&&((d0<d)||(d==-1)))
1894  d=d0;
1895  }
1896  }
1897  return d;
1898 }
int p_MinDeg(poly p, intvec *w, const ring R)
Definition: p_polys.cc:4564
#define M
Definition: sirandom.c:25

◆ id_Module2formatedMatrix()

matrix id_Module2formatedMatrix ( ideal  mod,
int  rows,
int  cols,
const ring  R 
)

Definition at line 1488 of file simpleideals.cc.

1489 {
1490  matrix result = mpNew(rows,cols);
1491  int i,cp,r=id_RankFreeModule(mod,R),c=IDELEMS(mod);
1492  poly p,h;
1493 
1494  if (r>rows) r = rows;
1495  if (c>cols) c = cols;
1496  for(i=0;i<c;i++)
1497  {
1498  p=pReverse(mod->m[i]);
1499  mod->m[i]=NULL;
1500  while (p!=NULL)
1501  {
1502  h=p;
1503  pIter(p);
1504  pNext(h)=NULL;
1505  cp = p_GetComp(h,R);
1506  if (cp<=r)
1507  {
1508  p_SetComp(h,0,R);
1509  p_SetmComp(h,R);
1510  MATELEM0(result,cp-1,i) = p_Add_q(MATELEM0(result,cp-1,i),h,R);
1511  }
1512  else
1513  p_Delete(&h,R);
1514  }
1515  }
1516  id_Delete(&mod,R);
1517  return result;
1518 }
CF_NO_INLINE FACTORY_PUBLIC CanonicalForm mod(const CanonicalForm &, const CanonicalForm &)
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define pNext(p)
Definition: monomials.h:36
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:938
static poly pReverse(poly p)
Definition: p_polys.h:337
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s

◆ id_Module2Matrix()

matrix id_Module2Matrix ( ideal  mod,
const ring  R 
)

Definition at line 1442 of file simpleideals.cc.

1443 {
1444  matrix result = mpNew(mod->rank,IDELEMS(mod));
1445  long i; long cp;
1446  poly p,h;
1447 
1448  for(i=0;i<IDELEMS(mod);i++)
1449  {
1450  p=pReverse(mod->m[i]);
1451  mod->m[i]=NULL;
1452  while (p!=NULL)
1453  {
1454  h=p;
1455  pIter(p);
1456  pNext(h)=NULL;
1457  cp = si_max(1L,p_GetComp(h, R)); // if used for ideals too
1458  //cp = p_GetComp(h,R);
1459  p_SetComp(h,0,R);
1460  p_SetmComp(h,R);
1461 #ifdef TEST
1462  if (cp>mod->rank)
1463  {
1464  Print("## inv. rank %ld -> %ld\n",mod->rank,cp);
1465  int k,l,o=mod->rank;
1466  mod->rank=cp;
1467  matrix d=mpNew(mod->rank,IDELEMS(mod));
1468  for (l=0; l<o; l++)
1469  {
1470  for (k=0; k<IDELEMS(mod); k++)
1471  {
1472  MATELEM0(d,l,k)=MATELEM0(result,l,k);
1473  MATELEM0(result,l,k)=NULL;
1474  }
1475  }
1476  id_Delete((ideal *)&result,R);
1477  result=d;
1478  }
1479 #endif
1480  MATELEM0(result,cp-1,i) = p_Add_q(MATELEM0(result,cp-1,i),h,R);
1481  }
1482  }
1483  // obachman 10/99: added the following line, otherwise memory leack!
1484  id_Delete(&mod,R);
1485  return result;
1486 }

◆ id_Mult()

ideal id_Mult ( ideal  h1,
ideal  h2,
const ring  r 
)

h1 * h2 one h_i must be an ideal (with at least one column) the other h_i may be a module (with no columns at all)

Definition at line 851 of file simpleideals.cc.

852 {
853  id_Test(h1, R);
854  id_Test(h2, R);
855 
856  int j = IDELEMS(h1);
857  while ((j > 0) && (h1->m[j-1] == NULL)) j--;
858 
859  int i = IDELEMS(h2);
860  while ((i > 0) && (h2->m[i-1] == NULL)) i--;
861 
862  j *= i;
863  int r = si_max( h2->rank, h1->rank );
864  if (j==0)
865  {
866  if ((IDELEMS(h1)>0) && (IDELEMS(h2)>0)) j=1;
867  return idInit(j, r);
868  }
869  ideal hh = idInit(j, r);
870 
871  int k = 0;
872  for (i=0; i<IDELEMS(h1); i++)
873  {
874  if (h1->m[i] != NULL)
875  {
876  for (j=0; j<IDELEMS(h2); j++)
877  {
878  if (h2->m[j] != NULL)
879  {
880  hh->m[k] = pp_Mult_qq(h1->m[i],h2->m[j],R);
881  k++;
882  }
883  }
884  }
885  }
886 
887  id_Compactify(hh,R);
888  return hh;
889 }
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1153

◆ id_Norm()

void id_Norm ( ideal  id,
const ring  r 
)

ideal id = (id[i]), result is leadcoeff(id[i]) = 1

Definition at line 253 of file simpleideals.cc.

254 {
255  id_Test(id, r);
256  for (int i=IDELEMS(id)-1; i>=0; i--)
257  {
258  if (id->m[i] != NULL)
259  {
260  p_Norm(id->m[i],r);
261  }
262  }
263 }
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3835

◆ id_Normalize()

void id_Normalize ( ideal  id,
const ring  r 
)

normialize all polys in id

Definition at line 1875 of file simpleideals.cc.

1876 {
1877  if (rField_has_simple_inverse(r)) return; /* Z/p, GF(p,n), R, long R/C */
1878  int i;
1879  for(i=I->nrows*I->ncols-1;i>=0;i--)
1880  {
1881  p_Normalize(I->m[i],r);
1882  }
1883 }
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3929
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:549

◆ id_PosConstant()

int id_PosConstant ( ideal  id,
const ring  r 
)

index of generator with leading term in ground ring (if any); otherwise -1

Definition at line 80 of file simpleideals.cc.

81 {
82  id_Test(id, r);
83  const int N = IDELEMS(id) - 1;
84  const poly * m = id->m + N;
85 
86  for (int k = N; k >= 0; --k, --m)
87  {
88  const poly p = *m;
89  if (p!=NULL)
90  if (p_LmIsConstantComp(p, r) == TRUE)
91  return k;
92  }
93 
94  return -1;
95 }
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
Definition: p_polys.h:1008

◆ id_Power()

ideal id_Power ( ideal  given,
int  exp,
const ring  r 
)

Definition at line 1302 of file simpleideals.cc.

1303 {
1304  ideal result,temp;
1305  poly p1;
1306  int i;
1307 
1308  if (idIs0(given)) return idInit(1,1);
1309  temp = id_Copy(given,r);
1310  idSkipZeroes(temp);
1311  i = binom(IDELEMS(temp)+exp-1,exp);
1312  result = idInit(i,1);
1313  result->nrows = 0;
1314 //Print("ideal contains %d elements\n",i);
1315  p1=p_One(r);
1316  id_NextPotence(temp,result,0,IDELEMS(temp)-1,exp,exp,p1,r);
1317  p_Delete(&p1,r);
1318  id_Delete(&temp,r);
1319  result->nrows = 1;
1320  id_DelEquals(result,r);
1322  return result;
1323 }
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357
static void id_NextPotence(ideal given, ideal result, int begin, int end, int deg, int restdeg, poly ap, const ring r)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
void id_DelEquals(ideal id, const ring r)
ideal id = (id[i]) if id[i] = id[j] then id[j] is deleted for j > i

◆ id_QHomWeight()

intvec* id_QHomWeight ( ideal  id,
const ring  r 
)

Definition at line 1809 of file simpleideals.cc.

1810 {
1811  poly head, tail;
1812  int k;
1813  int in=IDELEMS(id)-1, ready=0, all=0,
1814  coldim=rVar(r), rowmax=2*coldim;
1815  if (in<0) return NULL;
1816  intvec *imat=new intvec(rowmax+1,coldim,0);
1817 
1818  do
1819  {
1820  head = id->m[in--];
1821  if (head!=NULL)
1822  {
1823  tail = pNext(head);
1824  while (tail!=NULL)
1825  {
1826  all++;
1827  for (k=1;k<=coldim;k++)
1828  IMATELEM(*imat,all,k) = p_GetExpDiff(head,tail,k,r);
1829  if (all==rowmax)
1830  {
1831  ivTriangIntern(imat, ready, all);
1832  if (ready==coldim)
1833  {
1834  delete imat;
1835  return NULL;
1836  }
1837  }
1838  pIter(tail);
1839  }
1840  }
1841  } while (in>=0);
1842  if (all>ready)
1843  {
1844  ivTriangIntern(imat, ready, all);
1845  if (ready==coldim)
1846  {
1847  delete imat;
1848  return NULL;
1849  }
1850  }
1851  intvec *result = ivSolveKern(imat, ready);
1852  delete imat;
1853  return result;
1854 }
CanonicalForm head(const CanonicalForm &f)
void ivTriangIntern(intvec *imat, int &ready, int &all)
Definition: intvec.cc:404
intvec * ivSolveKern(intvec *imat, int dimtr)
Definition: intvec.cc:442
#define IMATELEM(M, I, J)
Definition: intvec.h:85
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition: p_polys.h:637

◆ id_RankFreeModule() [1/2]

long id_RankFreeModule ( ideal  m,
ring  lmRing,
ring  tailRing 
)

return the maximal component number found in any polynomial in s

Definition at line 906 of file simpleideals.cc.

907 {
908  long j = 0;
909 
910  if (rRing_has_Comp(tailRing) && rRing_has_Comp(lmRing))
911  {
912  poly *p=s->m;
913  for (unsigned int l=IDELEMS(s); l > 0; --l, ++p)
914  if (*p != NULL)
915  {
916  pp_Test(*p, lmRing, tailRing);
917  const long k = p_MaxComp(*p, lmRing, tailRing);
918  if (k>j) j = k;
919  }
920  }
921 
922  return j; // return -1;
923 }
const CanonicalForm int s
Definition: facAbsFact.cc:51
#define rRing_has_Comp(r)
Definition: monomials.h:266
#define pp_Test(p, lmRing, tailRing)
Definition: p_polys.h:164

◆ id_RankFreeModule() [2/2]

static long id_RankFreeModule ( ideal  m,
ring  r 
)
inlinestatic

Definition at line 97 of file simpleideals.h.

98 {return id_RankFreeModule(m, r, r);}
long id_RankFreeModule(ideal m, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s

◆ id_ReadOutPivot()

int id_ReadOutPivot ( ideal  arg,
int *  comp,
const ring  r 
)

Definition at line 1732 of file simpleideals.cc.

1733 {
1734  if (idIs0(arg)) return -1;
1735  int i=0,j, generator=-1;
1736  int rk_arg=arg->rank; //idRankFreeModule(arg);
1737  int * componentIsUsed =(int *)omAlloc((rk_arg+1)*sizeof(int));
1738  poly p;
1739 
1740  while ((generator<0) && (i<IDELEMS(arg)))
1741  {
1742  memset(componentIsUsed,0,(rk_arg+1)*sizeof(int));
1743  p = arg->m[i];
1744  while (p!=NULL)
1745  {
1746  j = __p_GetComp(p,r);
1747  if (componentIsUsed[j]==0)
1748  {
1749  if (p_LmIsConstantComp(p,r) &&
1750  (!rField_is_Ring(r) || n_IsUnit(pGetCoeff(p),r->cf)))
1751  {
1752  generator = i;
1753  componentIsUsed[j] = 1;
1754  }
1755  else
1756  {
1757  componentIsUsed[j] = -1;
1758  }
1759  }
1760  else if (componentIsUsed[j]>0)
1761  {
1762  (componentIsUsed[j])++;
1763  }
1764  pIter(p);
1765  }
1766  i++;
1767  }
1768  i = 0;
1769  *comp = -1;
1770  for (j=0;j<=rk_arg;j++)
1771  {
1772  if (componentIsUsed[j]>0)
1773  {
1774  if ((*comp==-1) || (componentIsUsed[j]<i))
1775  {
1776  *comp = j;
1777  i= componentIsUsed[j];
1778  }
1779  }
1780  }
1781  omFree(componentIsUsed);
1782  return generator;
1783 }
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define omFree(addr)
Definition: omAllocDecl.h:261

◆ id_ResizeModule()

ideal id_ResizeModule ( ideal  mod,
int  rows,
int  cols,
const ring  R 
)

Definition at line 1520 of file simpleideals.cc.

1521 {
1522  // columns?
1523  if (cols!=IDELEMS(mod))
1524  {
1525  for(int i=IDELEMS(mod)-1;i>=cols;i--) p_Delete(&mod->m[i],R);
1526  pEnlargeSet(&(mod->m),IDELEMS(mod),cols-IDELEMS(mod));
1527  IDELEMS(mod)=cols;
1528  }
1529  // rows?
1530  if (rows<mod->rank)
1531  {
1532  for(int i=IDELEMS(mod)-1;i>=0;i--)
1533  {
1534  if (mod->m[i]!=NULL)
1535  {
1536  while((mod->m[i]!=NULL) && (p_GetComp(mod->m[i],R)>rows))
1537  mod->m[i]=p_LmDeleteAndNext(mod->m[i],R);
1538  poly p=mod->m[i];
1539  while(pNext(p)!=NULL)
1540  {
1541  if (p_GetComp(pNext(p),R)>rows)
1543  else
1544  pIter(p);
1545  }
1546  }
1547  }
1548  }
1549  mod->rank=rows;
1550  return mod;
1551 }
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:757

◆ id_ShallowDelete()

void id_ShallowDelete ( ideal *  h,
ring  r 
)

Shallowdeletes an ideal/matrix.

Definition at line 157 of file simpleideals.cc.

158 {
159  id_Test(*h, r);
160 
161  if (*h == NULL)
162  return;
163 
164  int j,elems;
165  elems=j=(*h)->nrows*(*h)->ncols;
166  if (j>0)
167  {
168  assume( (*h)->m != NULL );
169  do
170  {
171  p_ShallowDelete(&((*h)->m[--j]), r);
172  }
173  while (j>0);
174  omFreeSize((ADDRESS)((*h)->m),sizeof(poly)*elems);
175  }
177  *h=NULL;
178 }
void p_ShallowDelete(poly *p, const ring r)

◆ id_Shift()

void id_Shift ( ideal  M,
int  s,
const ring  r 
)

Definition at line 2087 of file simpleideals.cc.

2088 {
2089 // id_Test( M, r );
2090 
2091 // assume( s >= 0 ); // negative is also possible // TODO: verify input ideal in such a case!?
2092 
2093  for(int i=IDELEMS(M)-1; i>=0;i--)
2094  p_Shift(&(M->m[i]),s,r);
2095 
2096  M->rank += s;
2097 
2098 // id_Test( M, r );
2099 }
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition: p_polys.cc:4822

◆ id_SimpleAdd()

ideal id_SimpleAdd ( ideal  h1,
ideal  h2,
const ring  r 
)

concat the lists h1 and h2 without zeros

Definition at line 722 of file simpleideals.cc.

723 {
724  id_Test(h1, R);
725  id_Test(h2, R);
726 
727  if ( idIs0(h1) )
728  {
729  ideal res=id_Copy(h2,R);
730  if (res->rank<h1->rank) res->rank=h1->rank;
731  return res;
732  }
733  if ( idIs0(h2) )
734  {
735  ideal res=id_Copy(h1,R);
736  if (res->rank<h2->rank) res->rank=h2->rank;
737  return res;
738  }
739 
740  int j = IDELEMS(h1)-1;
741  while ((j >= 0) && (h1->m[j] == NULL)) j--;
742 
743  int i = IDELEMS(h2)-1;
744  while ((i >= 0) && (h2->m[i] == NULL)) i--;
745 
746  const int r = si_max(h1->rank, h2->rank);
747 
748  ideal result = idInit(i+j+2,r);
749 
750  int l;
751 
752  for (l=j; l>=0; l--)
753  result->m[l] = p_Copy(h1->m[l],R);
754 
755  j = i+j+1;
756  for (l=i; l>=0; l--, j--)
757  result->m[j] = p_Copy(h2->m[l],R);
758 
759  return result;
760 }

◆ id_Sort()

intvec* id_Sort ( const ideal  id,
const BOOLEAN  nolex,
const ring  r 
)

sorts the ideal w.r.t. the actual ringordering uses lex-ordering when nolex = FALSE

Definition at line 627 of file simpleideals.cc.

628 {
629  id_Test(id, r);
630 
631  intvec * result = new intvec(IDELEMS(id));
632  int i, j, actpos=0, newpos;
633  int diff, olddiff, lastcomp, newcomp;
634  BOOLEAN notFound;
635 
636  for (i=0;i<IDELEMS(id);i++)
637  {
638  if (id->m[i]!=NULL)
639  {
640  notFound = TRUE;
641  newpos = actpos / 2;
642  diff = (actpos+1) / 2;
643  diff = (diff+1) / 2;
644  lastcomp = p_Comp_RevLex(id->m[i],id->m[(*result)[newpos]],nolex,r);
645  if (lastcomp<0)
646  {
647  newpos -= diff;
648  }
649  else if (lastcomp>0)
650  {
651  newpos += diff;
652  }
653  else
654  {
655  notFound = FALSE;
656  }
657  //while ((newpos>=0) && (newpos<actpos) && (notFound))
658  while (notFound && (newpos>=0) && (newpos<actpos))
659  {
660  newcomp = p_Comp_RevLex(id->m[i],id->m[(*result)[newpos]],nolex,r);
661  olddiff = diff;
662  if (diff>1)
663  {
664  diff = (diff+1) / 2;
665  if ((newcomp==1)
666  && (actpos-newpos>1)
667  && (diff>1)
668  && (newpos+diff>=actpos))
669  {
670  diff = actpos-newpos-1;
671  }
672  else if ((newcomp==-1)
673  && (diff>1)
674  && (newpos<diff))
675  {
676  diff = newpos;
677  }
678  }
679  if (newcomp<0)
680  {
681  if ((olddiff==1) && (lastcomp>0))
682  notFound = FALSE;
683  else
684  newpos -= diff;
685  }
686  else if (newcomp>0)
687  {
688  if ((olddiff==1) && (lastcomp<0))
689  {
690  notFound = FALSE;
691  newpos++;
692  }
693  else
694  {
695  newpos += diff;
696  }
697  }
698  else
699  {
700  notFound = FALSE;
701  }
702  lastcomp = newcomp;
703  if (diff==0) notFound=FALSE; /*hs*/
704  }
705  if (newpos<0) newpos = 0;
706  if (newpos>actpos) newpos = actpos;
707  while ((newpos<actpos) && (p_Comp_RevLex(id->m[i],id->m[(*result)[newpos]],nolex,r)==0))
708  newpos++;
709  for (j=actpos;j>newpos;j--)
710  {
711  (*result)[j] = (*result)[j-1];
712  }
713  (*result)[newpos] = i;
714  actpos++;
715  }
716  }
717  for (j=0;j<actpos;j++) (*result)[j]++;
718  return result;
719 }
static int p_Comp_RevLex(poly a, poly b, BOOLEAN nolex, const ring R)
for idSort: compare a and b revlex inclusive module comp.

◆ id_Subst()

ideal id_Subst ( ideal  id,
int  n,
poly  e,
const ring  r 
)

Definition at line 1557 of file simpleideals.cc.

1558 {
1559  int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
1560  ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
1561 
1562  res->rank = id->rank;
1563  for(k--;k>=0;k--)
1564  {
1565  res->m[k]=p_Subst(id->m[k],n,e,r);
1566  id->m[k]=NULL;
1567  }
1568  id_Delete(&id,r);
1569  return res;
1570 }
poly * m
Definition: matpol.h:18
poly p_Subst(poly p, int n, poly e, const ring r)
Definition: p_polys.cc:4074

◆ id_Transp()

ideal id_Transp ( ideal  a,
const ring  rRing 
)

transpose a module

Definition at line 1905 of file simpleideals.cc.

1906 {
1907  int r = a->rank, c = IDELEMS(a);
1908  ideal b = idInit(r,c);
1909 
1910  int i;
1911  for (i=c; i>0; i--)
1912  {
1913  poly p=a->m[i-1];
1914  while(p!=NULL)
1915  {
1916  poly h=p_Head(p, rRing);
1917  int co=__p_GetComp(h, rRing)-1;
1918  p_SetComp(h, i, rRing);
1919  p_Setm(h, rRing);
1920  h->next=b->m[co];
1921  b->m[co]=h;
1922  pIter(p);
1923  }
1924  }
1925  for (i=IDELEMS(b)-1; i>=0; i--)
1926  {
1927  poly p=b->m[i];
1928  if(p!=NULL)
1929  {
1930  b->m[i]=p_SortMerge(p,rRing,TRUE);
1931  }
1932  }
1933  return b;
1934 }
static poly p_SortMerge(poly p, const ring r, BOOLEAN revert=FALSE)
Definition: p_polys.h:1231

◆ id_Vec2Ideal()

ideal id_Vec2Ideal ( poly  vec,
const ring  R 
)

Definition at line 1376 of file simpleideals.cc.

1377 {
1378  ideal result=idInit(1,1);
1380  p_Vec2Polys(vec, &(result->m), &(IDELEMS(result)),R);
1381  return result;
1382 }
fq_nmod_poly_t * vec
Definition: facHensel.cc:108
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
void p_Vec2Polys(poly v, poly **p, int *len, const ring r)
Definition: p_polys.cc:3741

◆ idElem()

int idElem ( const ideal  F)

number of non-zero polys in F

number of non-zero polys in F

Definition at line 221 of file simpleideals.cc.

222 {
223  assume (F != NULL);
224 
225  int i=0;
226 
227  for(int j=IDELEMS(F)-1;j>=0;j--)
228  {
229  if ((F->m)[j]!=NULL) i++;
230  }
231  return i;
232 }

◆ idGetNextChoise()

void idGetNextChoise ( int  r,
int  end,
BOOLEAN endch,
int *  choise 
)

Definition at line 1023 of file simpleideals.cc.

1024 {
1025  int i = r-1,j;
1026  while ((i >= 0) && (choise[i] == end))
1027  {
1028  i--;
1029  end--;
1030  }
1031  if (i == -1)
1032  *endch = TRUE;
1033  else
1034  {
1035  choise[i]++;
1036  for (j=i+1; j<r; j++)
1037  {
1038  choise[j] = choise[i]+j-i;
1039  }
1040  *endch = FALSE;
1041  }
1042 }

◆ idGetNumberOfChoise()

int idGetNumberOfChoise ( int  t,
int  d,
int  begin,
int  end,
int *  choise 
)

Definition at line 1049 of file simpleideals.cc.

1050 {
1051  int * localchoise,i,result=0;
1052  BOOLEAN b=FALSE;
1053 
1054  if (d<=1) return 1;
1055  localchoise=(int*)omAlloc((d-1)*sizeof(int));
1056  idInitChoise(d-1,begin,end,&b,localchoise);
1057  while (!b)
1058  {
1059  result++;
1060  i = 0;
1061  while ((i<t) && (localchoise[i]==choise[i])) i++;
1062  if (i>=t)
1063  {
1064  i = t+1;
1065  while ((i<d) && (localchoise[i-1]==choise[i])) i++;
1066  if (i>=d)
1067  {
1068  omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
1069  return result;
1070  }
1071  }
1072  idGetNextChoise(d-1,end,&b,localchoise);
1073  }
1074  omFreeSize((ADDRESS)localchoise,(d-1)*sizeof(int));
1075  return 0;
1076 }
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)

◆ idInit()

ideal idInit ( int  idsize,
int  rank 
)

creates an ideal / module

creates an ideal / module

Definition at line 35 of file simpleideals.cc.

36 {
37  assume( idsize >= 0 && rank >= 0 );
38 
39  ideal hh = (ideal)omAllocBin(sip_sideal_bin);
40 
41  IDELEMS(hh) = idsize; // ncols
42  hh->nrows = 1; // ideal/module!
43 
44  hh->rank = rank; // ideal: 1, module: >= 0!
45 
46  if (idsize>0)
47  hh->m = (poly *)omAlloc0(idsize*sizeof(poly));
48  else
49  hh->m = NULL;
50 
51  return hh;
52 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205

◆ idInitChoise()

void idInitChoise ( int  r,
int  beg,
int  end,
BOOLEAN endch,
int *  choise 
)

Definition at line 1001 of file simpleideals.cc.

1002 {
1003  /*returns the first choise of r numbers between beg and end*/
1004  int i;
1005  for (i=0; i<r; i++)
1006  {
1007  choise[i] = 0;
1008  }
1009  if (r <= end-beg+1)
1010  for (i=0; i<r; i++)
1011  {
1012  choise[i] = beg+i;
1013  }
1014  if (r > end-beg+1)
1015  *endch = TRUE;
1016  else
1017  *endch = FALSE;
1018 }

◆ idIs0()

BOOLEAN idIs0 ( ideal  h)

returns true if h is the zero ideal

Definition at line 892 of file simpleideals.cc.

893 {
894  assume (h != NULL); // will fail :(
895 // if (h == NULL) return TRUE;
896 
897  for( int i = IDELEMS(h)-1; i >= 0; i-- )
898  if(h->m[i] != NULL)
899  return FALSE;
900 
901  return TRUE;
902 
903 }

◆ idShow()

void idShow ( const ideal  id,
const ring  lmRing,
const ring  tailRing,
const int  debugPrint = 0 
)

Definition at line 57 of file simpleideals.cc.

58 {
59  assume( debugPrint >= 0 );
60 
61  if( id == NULL )
62  PrintS("(NULL)");
63  else
64  {
65  Print("Module of rank %ld,real rank %ld and %d generators.\n",
66  id->rank,id_RankFreeModule(id, lmRing, tailRing),IDELEMS(id));
67 
68  int j = (id->ncols*id->nrows) - 1;
69  while ((j > 0) && (id->m[j]==NULL)) j--;
70  for (int i = 0; i <= j; i++)
71  {
72  Print("generator %d: ",i); p_wrp(id->m[i], lmRing, tailRing);PrintLn();
73  }
74  }
75 }
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:373
void PrintLn()
Definition: reporter.cc:310

◆ idSkipZeroes()

void idSkipZeroes ( ideal  ide)

gives an ideal/module the minimal possible size

Definition at line 181 of file simpleideals.cc.

182 {
183  assume (ide != NULL);
184 
185  int k;
186  int j = -1;
187  int idelems=IDELEMS(ide);
188  BOOLEAN change=FALSE;
189 
190  for (k=0; k<idelems; k++)
191  {
192  if (ide->m[k] != NULL)
193  {
194  j++;
195  if (change)
196  {
197  ide->m[j] = ide->m[k];
198  }
199  }
200  else
201  {
202  change=TRUE;
203  }
204  }
205  if (change)
206  {
207  if (j == -1)
208  j = 0;
209  else
210  {
211  for (k=j+1; k<idelems; k++)
212  ide->m[k] = NULL;
213  }
214  j++;
215  pEnlargeSet(&(ide->m),idelems,j-idelems);
216  IDELEMS(ide) = j;
217  }
218 }

Variable Documentation

◆ sip_sideal_bin

EXTERN_VAR omBin sip_sideal_bin

Definition at line 54 of file simpleideals.h.