My Project
Loading...
Searching...
No Matches
Enumerations | Functions
fglm.cc File Reference
#include "kernel/mod2.h"
#include "misc/options.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/maps.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/fglm/fglm.h"
#include "Singular/fglm.h"
#include "Singular/ipid.h"
#include "Singular/ipshell.h"
#include "Singular/tok.h"

Go to the source code of this file.

Enumerations

enum  FglmState {
  FglmOk , FglmHasOne , FglmNoIdeal , FglmNotReduced ,
  FglmNotZeroDim , FglmIncompatibleRings , FglmPolyIsOne , FglmPolyIsZero
}
 

Functions

ideal fglmUpdatesource (const ideal sourceIdeal)
 
void fglmUpdateresult (ideal &result)
 
FglmState fglmConsistency (ring sring, ring dring, int *vperm)
 
FglmState fglmIdealcheck (const ideal theIdeal)
 
BOOLEAN fglmProc (leftv result, leftv first, leftv second)
 
ideal fglmQuot (ideal first, poly second)
 
BOOLEAN fglmQuotProc (leftv result, leftv first, leftv second)
 
ideal findUni (ideal first)
 
BOOLEAN findUniProc (leftv result, leftv first)
 

Enumeration Type Documentation

◆ FglmState

Enumerator
FglmOk 
FglmHasOne 
FglmNoIdeal 
FglmNotReduced 
FglmNotZeroDim 
FglmIncompatibleRings 
FglmPolyIsOne 
FglmPolyIsZero 

Definition at line 39 of file fglm.cc.

39 {
40 FglmOk,
46 // for fglmquot:
49};
@ FglmOk
Definition fglm.cc:40
@ FglmNotReduced
Definition fglm.cc:43
@ FglmHasOne
Definition fglm.cc:41
@ FglmNotZeroDim
Definition fglm.cc:44
@ FglmIncompatibleRings
Definition fglm.cc:45
@ FglmPolyIsOne
Definition fglm.cc:47
@ FglmPolyIsZero
Definition fglm.cc:48
@ FglmNoIdeal
Definition fglm.cc:42

Function Documentation

◆ fglmConsistency()

FglmState fglmConsistency ( ring  sring,
ring  dring,
int vperm 
)

Definition at line 121 of file fglm.cc.

122{
123 int k;
124 FglmState state= FglmOk;
125
126 if ( sring->cf != dring->cf )
127 {
128 WerrorS( "rings must have same characteristic" );
130 }
131 if ( (sring->OrdSgn != 1) || (dring->OrdSgn != 1) )
132 {
133 WerrorS( "only works for global orderings" );
135 }
136 if ( sring->N != dring->N )
137 {
138 WerrorS( "rings must have same number of variables" );
140 }
141 if ( rPar(sring) != rPar(dring) )
142 {
143 WerrorS( "rings must have same number of parameters" );
145 }
146 if ( state != FglmOk ) return state;
147 // now the rings have the same number of variables resp. parameters.
148 // check if the names of the variables resp. parameters do agree:
149 int nvar = sring->N;
150 int npar = rPar(sring);
151 int * pperm;
152 if ( npar > 0 )
153 pperm= (int *)omAlloc0( (npar+1)*sizeof( int ) );
154 else
155 pperm= NULL;
158 dring->cf->type);
159 for ( k= nvar; (k > 0) && (state == FglmOk); k-- )
160 if ( vperm[k] <= 0 )
161 {
162 WerrorS( "variable names do not agree" );
164 }
165 for ( k= npar-1; (k >= 0) && (state == FglmOk); k-- )
166 if ( pperm[k] >= 0 )
167 {
168 WerrorS( "parameter names do not agree" );
170 }
171 if (pperm != NULL) // OB: ????
172 omFreeSize( (ADDRESS)pperm, (npar+1)*sizeof( int ) );
173 if ( state != FglmOk ) return state;
174 // check if both rings are qrings or not
175 if ( sring->qideal != NULL )
176 {
177 if ( dring->qideal == NULL )
178 {
179 WerrorS( "source ring is a qring, destination ring not" );
181 }
182 // both rings are qrings, now check if both quotients define the same ideal.
183 // check if sring->qideal is contained in dring->qideal:
185 nMapFunc nMap=n_SetMap(dring->cf, sring->cf );
186 ideal sqind = idInit( IDELEMS( sring->qideal ), 1 );
187 for ( k= IDELEMS( sring->qideal )-1; k >= 0; k-- )
188 (sqind->m)[k]= p_PermPoly( (sring->qideal->m)[k], vperm, sring,
189 dring, nMap);
190 ideal sqindred = kNF( dring->qideal, NULL, sqind );
191 if ( ! idIs0( sqindred ) )
192 {
193 WerrorS( "the quotients do not agree" );
195 }
196 idDelete( & sqind );
197 idDelete( & sqindred );
199 if ( state != FglmOk ) return state;
200 // check if dring->qideal is contained in sring->qideal:
201 int * dsvperm = (int *)omAlloc0( (nvar+1)*sizeof( int ) );
202 maFindPerm( dring->names, nvar, NULL, 0, sring->names, nvar, NULL, 0,
203 dsvperm, NULL, sring->cf->type);
204 nMap=n_SetMap(currRing->cf, dring->cf);
205 ideal dqins = idInit( IDELEMS( dring->qideal ), 1 );
206 for ( k= IDELEMS( dring->qideal )-1; k >= 0; k-- )
207 (dqins->m)[k]=p_PermPoly( (dring->qideal->m)[k], dsvperm, sring,
208 currRing, nMap);
209 ideal dqinsred = kNF( sring->qideal, NULL, dqins );
210 if ( ! idIs0( dqinsred ) )
211 {
212 WerrorS( "the quotients do not agree" );
214 }
215 idDelete( & dqins );
216 idDelete( & dqinsred );
217 omFreeSize( (ADDRESS)dsvperm, (nvar+1)*sizeof( int ) );
218 if ( state != FglmOk ) return state;
219 }
220 else
221 {
222 if ( dring->qideal != NULL )
223 {
224 WerrorS( "source ring is a qring, destination ring not" );
226 }
227 }
228 return FglmOk;
229}
int k
Definition cfEzgcd.cc:99
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:704
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
void WerrorS(const char *s)
Definition feFopen.cc:24
FglmState
Definition fglm.cc:39
#define idDelete(H)
delete an ideal
Definition ideals.h:29
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition kstd1.cc:3227
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
Definition maps.cc:163
#define omFreeSize(addr, size)
#define omAlloc0(size)
#define NULL
Definition omList.c:12
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4152
void rChangeCurrRing(ring r)
Definition polys.cc:15
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:604
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition ring.h:630
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define IDELEMS(i)

◆ fglmIdealcheck()

FglmState fglmIdealcheck ( const ideal  theIdeal)

Definition at line 240 of file fglm.cc.

241{
242 FglmState state = FglmOk;
243 int power;
244 int k;
245 BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
246
247 for ( k= IDELEMS( theIdeal ) - 1; (state == FglmOk) && (k >= 0); k-- )
248 {
249 poly p = (theIdeal->m)[k];
250 if (p!=NULL)
251 {
252 if( pIsConstant( p ) ) state= FglmHasOne;
253 else if ( (power= pIsPurePower( p )) > 0 )
254 {
255 fglmASSERT( 0 < power && power <= currRing->N, "illegal power" );
256 if ( purePowers[power-1] == TRUE ) state= FglmNotReduced;
257 else purePowers[power-1]= TRUE;
258 }
259 for ( int l = IDELEMS( theIdeal ) - 1; state == FglmOk && l >= 0; l-- )
260 if ( (k != l) && pDivisibleBy( p, (theIdeal->m)[l] ) )
261 state= FglmNotReduced;
262 }
263 }
264 if ( state == FglmOk )
265 {
266 for ( k= currRing->N-1 ; (state == FglmOk) && (k >= 0); k-- )
267 if ( purePowers[k] == FALSE ) state= FglmNotZeroDim;
268 }
269 omFreeSize( (ADDRESS)purePowers, currRing->N*sizeof( BOOLEAN ) );
270 return state;
271}
int BOOLEAN
Definition auxiliary.h:87
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
int l
Definition cfEzgcd.cc:100
int p
Definition cfModGcd.cc:4086
#define fglmASSERT(ignore1, ignore2)
Definition fglm.h:23
#define pIsConstant(p)
like above, except that Comp must be 0
Definition polys.h:238
#define pIsPurePower(p)
Definition polys.h:248
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
Definition polys.h:138

◆ fglmProc()

BOOLEAN fglmProc ( leftv  result,
leftv  first,
leftv  second 
)

Definition at line 277 of file fglm.cc.

278{
279 FglmState state = FglmOk;
280
282 // ring destRing = currRing;
284 ring sourceRing = (ring)first->Data();
285 rChangeCurrRing( sourceRing );
286 // ring sourceRing = currRing;
287
288 int * vperm = (int *)omAlloc0( (sourceRing->N+1)*sizeof( int ) );
289 state= fglmConsistency( sourceRing, destRing, vperm );
290 omFreeSize( (ADDRESS)vperm, (sourceRing->N+1)*sizeof(int) );
291
292 if ( state == FglmOk )
293 {
294 idhdl ih = sourceRing->idroot->get( second->Name(), myynest );
295 if ( (ih != NULL) && (IDTYP(ih)==IDEAL_CMD) )
296 {
298 if ( sourceRing->qideal != NULL )
300 else
302 state= fglmIdealcheck( sourceIdeal );
303 if ( state == FglmOk )
304 {
305 // Now the settings are compatible with FGLM
307 if ( fglmzero( sourceRing, sourceIdeal, destRing, destIdeal, FALSE, (currRing->qideal != NULL) ) == FALSE )
308 state= FglmNotReduced;
309 }
310 } else state= FglmNoIdeal;
311 }
312 if ( currRing != destRing )
314 switch (state)
315 {
316 case FglmOk:
317 if ( currRing->qideal != NULL ) fglmUpdateresult( destIdeal );
318 break;
319 case FglmHasOne:
320 destIdeal= idInit(1,1);
321 (destIdeal->m)[0]= pOne();
322 state= FglmOk;
323 break;
325 WerrorS( "source ring and current ring are incompatible" );
327 break;
328 case FglmNoIdeal:
329 Werror( "Can't find ideal %s in source ring", second->Name() );
331 break;
332 case FglmNotZeroDim:
333 Werror( "The ideal %s has to be 0-dimensional", second->Name() );
335 break;
336 case FglmNotReduced:
337 Werror( "The ideal %s has to be given by a reduced SB", second->Name() );
339 break;
340 default:
341 destIdeal= idInit(1,1);
342 }
343
344 result->rtyp = IDEAL_CMD;
345 result->data= (void *)destIdeal;
347 return (state != FglmOk);
348}
Definition idrec.h:35
Class used for (list of) interpreter objects.
Definition subexpr.h:83
void * Data()
Definition subexpr.cc:1193
return result
VAR int myynest
Definition febase.cc:41
FglmState fglmConsistency(ring sring, ring dring, int *vperm)
Definition fglm.cc:121
FglmState fglmIdealcheck(const ideal theIdeal)
Definition fglm.cc:240
ideal fglmUpdatesource(const ideal sourceIdeal)
Definition fglm.cc:57
void fglmUpdateresult(ideal &result)
Definition fglm.cc:89
@ IDEAL_CMD
Definition grammar.cc:285
#define setFlag(A, F)
Definition ipid.h:113
#define IDIDEAL(a)
Definition ipid.h:133
#define IDTYP(a)
Definition ipid.h:119
#define FLAG_STD
Definition ipid.h:106
BOOLEAN fglmzero(ring sourceRing, ideal &sourceIdeal, ring destRing, ideal &destideal, BOOLEAN switchBack=TRUE, BOOLEAN deleteIdeal=FALSE)
Definition fglmzero.cc:1193
#define pOne()
Definition polys.h:315
void Werror(const char *fmt,...)
Definition reporter.cc:189
BOOLEAN assumeStdFlag(leftv h)
Definition subexpr.cc:1588

◆ fglmQuot()

ideal fglmQuot ( ideal  first,
poly  second 
)

Definition at line 350 of file fglm.cc.

351{
352 FglmState state = FglmOk;
353
354 ideal sourceIdeal = first;
355 poly quot = second;
357
358 state = fglmIdealcheck( sourceIdeal );
359 if ( state == FglmOk )
360 {
361 if ( quot == NULL ) state= FglmPolyIsZero;
362 else if ( pIsConstant( quot ) ) state= FglmPolyIsOne;
363 }
364
365 if ( state == FglmOk )
366 {
368 state= FglmNotReduced;
369 }
370
371 switch (state)
372 {
373 case FglmOk:
374 break;
375 case FglmHasOne:
376 destIdeal= idInit(1,1);
377 (destIdeal->m)[0]= pOne();
378 state= FglmOk;
379 break;
380 case FglmNotZeroDim:
381 WerrorS( "The ideal has to be 0-dimensional" );
382 destIdeal= idInit(1,1);
383 break;
384 case FglmNotReduced:
385 WerrorS( "The poly has to be reduced" );
386 destIdeal= idInit(1,1);
387 break;
388 case FglmPolyIsOne:
389 int k;
391 for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
392 (destIdeal->m)[k]= pCopy( (sourceIdeal->m)[k] );
393 state= FglmOk;
394 break;
395 case FglmPolyIsZero:
396 destIdeal= idInit(1,1);
397 (destIdeal->m)[0]= pOne();
398 state= FglmOk;
399 break;
400 default:
401 destIdeal= idInit(1,1);
402 }
403
404 return destIdeal;
405}
BOOLEAN fglmquot(ideal sourceIdeal, poly quot, ideal &destIdeal)
Definition fglmzero.cc:1218
#define pCopy(p)
return a copy of the poly
Definition polys.h:185

◆ fglmQuotProc()

BOOLEAN fglmQuotProc ( leftv  result,
leftv  first,
leftv  second 
)

Definition at line 411 of file fglm.cc.

412{
413 FglmState state = FglmOk;
414
415 // STICKYPROT("quotstart\n");
416 ideal sourceIdeal = (ideal)first->Data();
417 poly quot = (poly)second->Data();
419
420 state = fglmIdealcheck( sourceIdeal );
421 if ( state == FglmOk )
422 {
423 if ( quot == NULL ) state= FglmPolyIsZero;
424 else if ( pIsConstant( quot ) ) state= FglmPolyIsOne;
425 }
426
427 if ( state == FglmOk )
428 {
429 assumeStdFlag( first );
431 state= FglmNotReduced;
432 }
433
434 switch (state)
435 {
436 case FglmOk:
437 break;
438 case FglmHasOne:
439 destIdeal= idInit(1,1);
440 (destIdeal->m)[0]= pOne();
441 state= FglmOk;
442 break;
443 case FglmNotZeroDim:
444 Werror( "The ideal %s has to be 0-dimensional", first->Name() );
446 break;
447 case FglmNotReduced:
448 Werror( "The poly %s has to be reduced", second->Name() );
450 break;
451 case FglmPolyIsOne:
452 int k;
454 for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
455 (destIdeal->m)[k]= pCopy( (sourceIdeal->m)[k] );
456 state= FglmOk;
457 break;
458 case FglmPolyIsZero:
459 destIdeal= idInit(1,1);
460 (destIdeal->m)[0]= pOne();
461 state= FglmOk;
462 break;
463 default:
464 destIdeal= idInit(1,1);
465 }
466
467 result->rtyp = IDEAL_CMD;
468 result->data= (void *)destIdeal;
470 // STICKYPROT("quotend\n");
471 return (state != FglmOk);
472} // fglmQuotProt
const char * Name()
Definition subexpr.h:120

◆ fglmUpdateresult()

void fglmUpdateresult ( ideal result)

Definition at line 89 of file fglm.cc.

90{
91 int k, l;
93 for ( k= IDELEMS( result )-1; k >=0; k-- )
94 {
95 if ( (result->m)[k] != NULL )
96 {
97 found= FALSE;
98 for ( l= IDELEMS( currRing->qideal )-1; (l >= 0) && ( found == FALSE ); l-- )
99 if ( pDivisibleBy( (currRing->qideal->m)[l], (result->m)[k] ) )
100 found= TRUE;
101 if ( found ) pDelete( & ((result->m)[k]) );
102 }
103 }
105}
bool found
#define pDelete(p_ptr)
Definition polys.h:186
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size

◆ fglmUpdatesource()

ideal fglmUpdatesource ( const ideal  sourceIdeal)

Definition at line 57 of file fglm.cc.

58{
59 int k, l, offset;
62 for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
63 (newSource->m)[k]= pCopy( (sourceIdeal->m)[k] );
65 for ( l= IDELEMS( currRing->qideal )-1; l >= 0; l-- )
66 {
67 if ( (currRing->qideal->m)[l] != NULL )
68 {
69 found= FALSE;
70 for ( k= IDELEMS( sourceIdeal )-1; (k >= 0) && (found == FALSE); k-- )
71 if ( pDivisibleBy( (sourceIdeal->m)[k], (currRing->qideal->m)[l] ) )
72 found= TRUE;
73 if ( ! found )
74 {
75 (newSource->m)[offset]= pCopy( (currRing->qideal->m)[l] );
76 offset++;
77 }
78 }
79 }
81 return newSource;
82}
STATIC_VAR int offset
Definition janet.cc:29

◆ findUni()

ideal findUni ( ideal  first)

Definition at line 474 of file fglm.cc.

475{
478 FglmState state;
479
480 sourceIdeal = first;
481
482 state= fglmIdealcheck( sourceIdeal );
483 if ( state == FglmOk )
484 {
485 // check for special cases: if the input contains
486 // univariate polys, try to reduce the problem
487 int i,k;
488 int count=0;
489 BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
490 for ( k= IDELEMS( sourceIdeal ) - 1; k >= 0; k-- )
491 {
492 if((i=pIsUnivariate(sourceIdeal->m[k]))>0)
493 {
494 if (purePowers[i-1]==0)
495 {
496 purePowers[i-1]=k;
497 count++;
498 if (count==currRing->N) break;
499 }
500 }
501 }
502 if (count==currRing->N)
503 {
505 for(k=currRing->N-1; k>=0; k--) destIdeal->m[k]=pCopy(sourceIdeal->m[purePowers[k]]);
506 }
508 if (destIdeal!=NULL)
509 state = FglmOk;
511 state = FglmNotReduced;
512 }
513 switch (state)
514 {
515 case FglmOk:
516 break;
517 case FglmHasOne:
518 destIdeal= idInit(1,1);
519 (destIdeal->m)[0]= pOne();
520 state= FglmOk;
521 break;
522 case FglmNotZeroDim:
523 WerrorS( "The ideal has to be 0-dimensional" );
524 destIdeal= idInit(1,1);
525 break;
526 case FglmNotReduced:
527 Werror( "The ideal has to be reduced" );
528 destIdeal= idInit(1,1);
529 break;
530 default:
531 destIdeal= idInit(1,1);
532 }
533
534 return destIdeal;
535}
int i
Definition cfEzgcd.cc:132
BOOLEAN FindUnivariateWrapper(ideal source, ideal &destIdeal)
Definition fglmzero.cc:1236
#define pIsUnivariate(p)
Definition polys.h:249
int status int void size_t count
Definition si_signals.h:59

◆ findUniProc()

BOOLEAN findUniProc ( leftv  result,
leftv  first 
)

Definition at line 541 of file fglm.cc.

542{
545 FglmState state;
546
547 sourceIdeal = (ideal)first->Data();
548
549 assumeStdFlag( first );
550 state= fglmIdealcheck( sourceIdeal );
551 if ( state == FglmOk )
552 {
553 // check for special cases: if the input contains
554 // univariate polys, try to reduce the problem
555 int i,k;
556 int count=0;
557 BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
558 for ( k= IDELEMS( sourceIdeal ) - 1; k >= 0; k-- )
559 {
560 if((i=pIsUnivariate(sourceIdeal->m[k]))>0)
561 {
562 if (purePowers[i-1]==0)
563 {
564 purePowers[i-1]=k;
565 count++;
566 if (count==currRing->N) break;
567 }
568 }
569 }
570 if (count==currRing->N)
571 {
573 for(k=currRing->N-1; k>=0; k--) destIdeal->m[k]=pCopy(sourceIdeal->m[purePowers[k]]);
574 }
576 if (destIdeal!=NULL)
577 state = FglmOk;
579 state = FglmNotReduced;
580 }
581 switch (state)
582 {
583 case FglmOk:
584 break;
585 case FglmHasOne:
586 destIdeal= idInit(1,1);
587 (destIdeal->m)[0]= pOne();
588 state= FglmOk;
589 break;
590 case FglmNotZeroDim:
591 Werror( "The ideal %s has to be 0-dimensional", first->Name() );
593 break;
594 case FglmNotReduced:
595 Werror( "The ideal %s has to be reduced", first->Name() );
597 break;
598 default:
599 destIdeal= idInit(1,1);
600 }
601
602 result->rtyp = IDEAL_CMD;
603 result->data= (void *)destIdeal;
604
605 return FALSE;
606}