Functions
fglm.h File Reference
#include "kernel/mod2.h"
#include "kernel/ideals.h"
#include "kernel/structs.h"

Go to the source code of this file.

Functions

BOOLEAN fglmProc (leftv result, leftv first, leftv second)
 
BOOLEAN fglmQuotProc (leftv result, leftv first, leftv second)
 
BOOLEAN FindUnivariateWrapper (ideal source, ideal &dest)
 
BOOLEAN findUniProc (leftv result, leftv first)
 
ideal fglmhomProc (leftv first, leftv second)
 

Function Documentation

◆ fglmhomProc()

ideal fglmhomProc ( leftv  first,
leftv  second 
)

◆ fglmProc()

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

Definition at line 279 of file fglm.cc.

280 {
281  FglmState state = FglmOk;
282 
283  idhdl destRingHdl = currRingHdl;
284  // ring destRing = currRing;
285  ideal destIdeal = NULL;
286  idhdl sourceRingHdl = (idhdl)first->data;
287  rSetHdl( sourceRingHdl );
288  // ring sourceRing = currRing;
289 
290  int * vperm = (int *)omAlloc0( (currRing->N+1)*sizeof( int ) );
291  state= fglmConsistency( sourceRingHdl, destRingHdl, vperm );
292  omFreeSize( (ADDRESS)vperm, (currRing->N+1)*sizeof(int) );
293 
294  if ( state == FglmOk )
295  {
296  idhdl ih = currRing->idroot->get( second->Name(), myynest );
297  if ( (ih != NULL) && (IDTYP(ih)==IDEAL_CMD) )
298  {
299  ideal sourceIdeal;
300  if ( currRing->qideal != NULL )
301  sourceIdeal= fglmUpdatesource( IDIDEAL( ih ) );
302  else
303  sourceIdeal = IDIDEAL( ih );
304  state= fglmIdealcheck( sourceIdeal );
305  if ( state == FglmOk )
306  {
307  // Now the settings are compatible with FGLM
308  assumeStdFlag( (leftv)ih );
309  if ( fglmzero( IDRING(sourceRingHdl), sourceIdeal, IDRING(destRingHdl), destIdeal, FALSE, (currRing->qideal != NULL) ) == FALSE )
310  state= FglmNotReduced;
311  }
312  } else state= FglmNoIdeal;
313  }
314  if ( currRingHdl != destRingHdl )
315  rSetHdl( destRingHdl );
316  switch (state)
317  {
318  case FglmOk:
319  if ( currRing->qideal != NULL ) fglmUpdateresult( destIdeal );
320  break;
321  case FglmHasOne:
322  destIdeal= idInit(1,1);
323  (destIdeal->m)[0]= pOne();
324  state= FglmOk;
325  break;
327  Werror( "ring %s and current ring are incompatible", first->Name() );
328  destIdeal= NULL;
329  break;
330  case FglmNoIdeal:
331  Werror( "Can't find ideal %s in ring %s", second->Name(), first->Name() );
332  destIdeal= NULL;
333  break;
334  case FglmNotZeroDim:
335  Werror( "The ideal %s has to be 0-dimensional", second->Name() );
336  destIdeal= NULL;
337  break;
338  case FglmNotReduced:
339  Werror( "The ideal %s has to be given by a reduced SB", second->Name() );
340  destIdeal= NULL;
341  break;
342  default:
343  destIdeal= idInit(1,1);
344  }
345 
346  result->rtyp = IDEAL_CMD;
347  result->data= (void *)destIdeal;
348  setFlag( result, FLAG_STD );
349  return (state != FglmOk);
350 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:82
FglmState fglmIdealcheck(const ideal theIdeal)
Definition: fglm.cc:242
#define FALSE
Definition: auxiliary.h:96
FglmState fglmConsistency(idhdl sringHdl, idhdl dringHdl, int *vperm)
Definition: fglm.cc:121
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
BOOLEAN fglmzero(ring sourceRing, ideal &sourceIdeal, ring destRing, ideal &destideal, BOOLEAN switchBack=TRUE, BOOLEAN deleteIdeal=FALSE)
Definition: fglmzero.cc:1193
#define IDIDEAL(a)
Definition: ipid.h:128
void * ADDRESS
Definition: auxiliary.h:135
const char * Name()
Definition: subexpr.h:120
Definition: idrec.h:34
void * data
Definition: subexpr.h:88
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define IDTYP(a)
Definition: ipid.h:114
ideal fglmUpdatesource(const ideal sourceIdeal)
Definition: fglm.cc:57
#define setFlag(A, F)
Definition: ipid.h:108
void fglmUpdateresult(ideal &result)
Definition: fglm.cc:89
idrec * idhdl
Definition: ring.h:21
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1552
#define pOne()
Definition: polys.h:311
#define FLAG_STD
Definition: ipid.h:104
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define NULL
Definition: omList.c:12
#define IDRING(a)
Definition: ipid.h:122
int rtyp
Definition: subexpr.h:91
VAR int myynest
Definition: febase.cc:41
FglmState
Definition: fglm.cc:39
void rSetHdl(idhdl h)
Definition: ipshell.cc:5086
VAR idhdl currRingHdl
Definition: ipid.cc:59
Definition: fglm.cc:40
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ fglmQuotProc()

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

Definition at line 356 of file fglm.cc.

357 {
358  FglmState state = FglmOk;
359 
360  // STICKYPROT("quotstart\n");
361  ideal sourceIdeal = (ideal)first->Data();
362  poly quot = (poly)second->Data();
363  ideal destIdeal = NULL;
364 
365  state = fglmIdealcheck( sourceIdeal );
366  if ( state == FglmOk )
367  {
368  if ( quot == NULL ) state= FglmPolyIsZero;
369  else if ( pIsConstant( quot ) ) state= FglmPolyIsOne;
370  }
371 
372  if ( state == FglmOk )
373  {
374  assumeStdFlag( first );
375  if ( fglmquot( sourceIdeal, quot, destIdeal ) == FALSE )
376  state= FglmNotReduced;
377  }
378 
379  switch (state)
380  {
381  case FglmOk:
382  break;
383  case FglmHasOne:
384  destIdeal= idInit(1,1);
385  (destIdeal->m)[0]= pOne();
386  state= FglmOk;
387  break;
388  case FglmNotZeroDim:
389  Werror( "The ideal %s has to be 0-dimensional", first->Name() );
390  destIdeal= NULL;
391  break;
392  case FglmNotReduced:
393  Werror( "The poly %s has to be reduced", second->Name() );
394  destIdeal= NULL;
395  break;
396  case FglmPolyIsOne:
397  int k;
398  destIdeal= idInit( IDELEMS(sourceIdeal), 1 );
399  for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
400  (destIdeal->m)[k]= pCopy( (sourceIdeal->m)[k] );
401  state= FglmOk;
402  break;
403  case FglmPolyIsZero:
404  destIdeal= idInit(1,1);
405  (destIdeal->m)[0]= pOne();
406  state= FglmOk;
407  break;
408  default:
409  destIdeal= idInit(1,1);
410  }
411 
412  result->rtyp = IDEAL_CMD;
413  result->data= (void *)destIdeal;
414  setFlag( result, FLAG_STD );
415  // STICKYPROT("quotend\n");
416  return (state != FglmOk);
417 } // fglmQuotProt
FglmState fglmIdealcheck(const ideal theIdeal)
Definition: fglm.cc:242
#define FALSE
Definition: auxiliary.h:96
BOOLEAN fglmquot(ideal sourceIdeal, poly quot, ideal &destIdeal)
Definition: fglmzero.cc:1218
int k
Definition: cfEzgcd.cc:92
const char * Name()
Definition: subexpr.h:120
void * data
Definition: subexpr.h:88
#define setFlag(A, F)
Definition: ipid.h:108
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:234
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1552
#define pOne()
Definition: polys.h:311
#define IDELEMS(i)
Definition: simpleideals.h:23
#define FLAG_STD
Definition: ipid.h:104
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define NULL
Definition: omList.c:12
int rtyp
Definition: subexpr.h:91
void * Data()
Definition: subexpr.cc:1176
FglmState
Definition: fglm.cc:39
Definition: fglm.cc:40
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define pCopy(p)
return a copy of the poly
Definition: polys.h:181

◆ findUniProc()

BOOLEAN findUniProc ( leftv  result,
leftv  first 
)

Definition at line 424 of file fglm.cc.

425 {
426  ideal sourceIdeal;
427  ideal destIdeal = NULL;
428  FglmState state;
429 
430  sourceIdeal = (ideal)first->Data();
431 
432  assumeStdFlag( first );
433  state= fglmIdealcheck( sourceIdeal );
434  if ( state == FglmOk )
435  {
436  // check for special cases: if the input contains
437  // univariate polys, try to reduce the problem
438  int i,k;
439  int count=0;
440  BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
441  for ( k= IDELEMS( sourceIdeal ) - 1; k >= 0; k-- )
442  {
443  if((i=pIsUnivariate(sourceIdeal->m[k]))>0)
444  {
445  if (purePowers[i-1]==0)
446  {
447  purePowers[i-1]=k;
448  count++;
449  if (count==currRing->N) break;
450  }
451  }
452  }
453  if (count==currRing->N)
454  {
455  destIdeal=idInit(currRing->N,1);
456  for(k=currRing->N-1; k>=0; k--) destIdeal->m[k]=pCopy(sourceIdeal->m[purePowers[k]]);
457  }
458  omFreeSize((ADDRESS)purePowers, currRing->N*sizeof( BOOLEAN ) );
459  if (destIdeal!=NULL)
460  state = FglmOk;
461  else if ( FindUnivariateWrapper( sourceIdeal, destIdeal ) == FALSE )
462  state = FglmNotReduced;
463  }
464  switch (state)
465  {
466  case FglmOk:
467  break;
468  case FglmHasOne:
469  destIdeal= idInit(1,1);
470  (destIdeal->m)[0]= pOne();
471  state= FglmOk;
472  break;
473  case FglmNotZeroDim:
474  Werror( "The ideal %s has to be 0-dimensional", first->Name() );
475  destIdeal= NULL;
476  break;
477  case FglmNotReduced:
478  Werror( "The ideal %s has to be reduced", first->Name() );
479  destIdeal= NULL;
480  break;
481  default:
482  destIdeal= idInit(1,1);
483  }
484 
485  result->rtyp = IDEAL_CMD;
486  result->data= (void *)destIdeal;
487 
488  return FALSE;
489 }
int status int void size_t count
Definition: si_signals.h:59
FglmState fglmIdealcheck(const ideal theIdeal)
Definition: fglm.cc:242
#define FALSE
Definition: auxiliary.h:96
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:135
int k
Definition: cfEzgcd.cc:92
const char * Name()
Definition: subexpr.h:120
void * data
Definition: subexpr.h:88
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1552
int i
Definition: cfEzgcd.cc:125
#define pOne()
Definition: polys.h:311
#define IDELEMS(i)
Definition: simpleideals.h:23
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define NULL
Definition: omList.c:12
int rtyp
Definition: subexpr.h:91
void * Data()
Definition: subexpr.cc:1176
#define pIsUnivariate(p)
Definition: polys.h:245
BOOLEAN FindUnivariateWrapper(ideal source, ideal &destIdeal)
Definition: fglmzero.cc:1236
FglmState
Definition: fglm.cc:39
int BOOLEAN
Definition: auxiliary.h:87
Definition: fglm.cc:40
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define pCopy(p)
return a copy of the poly
Definition: polys.h:181

◆ FindUnivariateWrapper()

BOOLEAN FindUnivariateWrapper ( ideal  source,
ideal &  dest 
)

Definition at line 1236 of file fglmzero.cc.

1237 {
1238  BOOLEAN fglmok;
1239 
1240  idealFunctionals L( 100, (currRing->N) );
1241  fglmok = CalculateFunctionals( source, L );
1242  if ( fglmok == TRUE ) {
1243  destIdeal= FindUnivariatePolys( L );
1244  return TRUE;
1245  }
1246  else
1247  return FALSE;
1248 }
#define FALSE
Definition: auxiliary.h:96
#define TRUE
Definition: auxiliary.h:100
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static ideal FindUnivariatePolys(const idealFunctionals &l)
Definition: fglmzero.cc:1118
static BOOLEAN CalculateFunctionals(const ideal &theIdeal, idealFunctionals &l)
Definition: fglmzero.cc:673
int BOOLEAN
Definition: auxiliary.h:87