My Project  UNKNOWN_GIT_VERSION
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 283 of file fglm.cc.

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

◆ fglmQuotProc()

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

Definition at line 360 of file fglm.cc.

361 {
362  FglmState state = FglmOk;
363 
364  // STICKYPROT("quotstart\n");
365  ideal sourceIdeal = (ideal)first->Data();
366  poly quot = (poly)second->Data();
367  ideal destIdeal = NULL;
368 
369  state = fglmIdealcheck( sourceIdeal );
370  if ( state == FglmOk )
371  {
372  if ( quot == NULL ) state= FglmPolyIsZero;
373  else if ( pIsConstant( quot ) ) state= FglmPolyIsOne;
374  }
375 
376  if ( state == FglmOk )
377  {
378  assumeStdFlag( first );
379  if ( fglmquot( sourceIdeal, quot, destIdeal ) == FALSE )
380  state= FglmNotReduced;
381  }
382 
383  switch (state)
384  {
385  case FglmOk:
386  break;
387  case FglmHasOne:
388  destIdeal= idInit(1,1);
389  (destIdeal->m)[0]= pOne();
390  state= FglmOk;
391  break;
392  case FglmNotZeroDim:
393  Werror( "The ideal %s has to be 0-dimensional", first->Name() );
394  destIdeal= NULL;
395  break;
396  case FglmNotReduced:
397  Werror( "The poly %s has to be reduced", second->Name() );
398  destIdeal= NULL;
399  break;
400  case FglmPolyIsOne:
401  int k;
402  destIdeal= idInit( IDELEMS(sourceIdeal), 1 );
403  for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
404  (destIdeal->m)[k]= pCopy( (sourceIdeal->m)[k] );
405  state= FglmOk;
406  break;
407  case FglmPolyIsZero:
408  destIdeal= idInit(1,1);
409  (destIdeal->m)[0]= pOne();
410  state= FglmOk;
411  break;
412  default:
413  destIdeal= idInit(1,1);
414  }
415 
416  result->rtyp = IDEAL_CMD;
417  result->data= (void *)destIdeal;
418  setFlag( result, FLAG_STD );
419  // STICKYPROT("quotend\n");
420  return (state != FglmOk);
421 } // fglmQuotProt
int k
Definition: cfEzgcd.cc:92
void * Data()
Definition: subexpr.cc:1182
@ FglmPolyIsOne
Definition: fglm.cc:51
@ FglmPolyIsZero
Definition: fglm.cc:52
BOOLEAN fglmquot(ideal sourceIdeal, poly quot, ideal &destIdeal)
Definition: fglmzero.cc:1220
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:233
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180
#define IDELEMS(i)
Definition: simpleideals.h:24

◆ findUniProc()

BOOLEAN findUniProc ( leftv  result,
leftv  first 
)

Definition at line 428 of file fglm.cc.

429 {
430  ideal sourceIdeal;
431  ideal destIdeal = NULL;
432  FglmState state;
433 
434  sourceIdeal = (ideal)first->Data();
435 
436  assumeStdFlag( first );
437  state= fglmIdealcheck( sourceIdeal );
438  if ( state == FglmOk )
439  {
440  // check for special cases: if the input contains
441  // univariate polys, try to reduce the problem
442  int i,k;
443  int count=0;
444  BOOLEAN * purePowers = (BOOLEAN *)omAlloc0( currRing->N*sizeof( BOOLEAN ) );
445  for ( k= IDELEMS( sourceIdeal ) - 1; k >= 0; k-- )
446  {
447  if((i=pIsUnivariate(sourceIdeal->m[k]))>0)
448  {
449  if (purePowers[i-1]==0)
450  {
451  purePowers[i-1]=k;
452  count++;
453  if (count==currRing->N) break;
454  }
455  }
456  }
457  if (count==currRing->N)
458  {
459  destIdeal=idInit(currRing->N,1);
460  for(k=currRing->N-1; k>=0; k--) destIdeal->m[k]=pCopy(sourceIdeal->m[purePowers[k]]);
461  }
462  omFreeSize((ADDRESS)purePowers, currRing->N*sizeof( BOOLEAN ) );
463  if (destIdeal!=NULL)
464  state = FglmOk;
465  else if ( FindUnivariateWrapper( sourceIdeal, destIdeal ) == FALSE )
466  state = FglmNotReduced;
467  }
468  switch (state)
469  {
470  case FglmOk:
471  break;
472  case FglmHasOne:
473  destIdeal= idInit(1,1);
474  (destIdeal->m)[0]= pOne();
475  state= FglmOk;
476  break;
477  case FglmNotZeroDim:
478  Werror( "The ideal %s has to be 0-dimensional", first->Name() );
479  destIdeal= NULL;
480  break;
481  case FglmNotReduced:
482  Werror( "The ideal %s has to be reduced", first->Name() );
483  destIdeal= NULL;
484  break;
485  default:
486  destIdeal= idInit(1,1);
487  }
488 
489  result->rtyp = IDEAL_CMD;
490  result->data= (void *)destIdeal;
491 
492  return FALSE;
493 }
int BOOLEAN
Definition: auxiliary.h:85
int i
Definition: cfEzgcd.cc:125
BOOLEAN FindUnivariateWrapper(ideal source, ideal &destIdeal)
Definition: fglmzero.cc:1238
#define pIsUnivariate(p)
Definition: polys.h:244
int status int void size_t count
Definition: si_signals.h:59

◆ FindUnivariateWrapper()

BOOLEAN FindUnivariateWrapper ( ideal  source,
ideal &  dest 
)

Definition at line 1238 of file fglmzero.cc.

1239 {
1240  BOOLEAN fglmok;
1241 
1242  idealFunctionals L( 100, (currRing->N) );
1243  fglmok = CalculateFunctionals( source, L );
1244  if ( fglmok == TRUE ) {
1245  destIdeal= FindUnivariatePolys( L );
1246  return TRUE;
1247  }
1248  else
1249  return FALSE;
1250 }
#define TRUE
Definition: auxiliary.h:98
static ideal FindUnivariatePolys(const idealFunctionals &l)
Definition: fglmzero.cc:1120
static BOOLEAN CalculateFunctionals(const ideal &theIdeal, idealFunctionals &l)
Definition: fglmzero.cc:675