My Project  debian-1:4.1.2-p1+ds-2
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 }

◆ 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

◆ 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 }

◆ 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 }
FALSE
#define FALSE
Definition: auxiliary.h:96
sleftv::Data
void * Data()
Definition: subexpr.cc:1175
FglmPolyIsOne
Definition: fglm.cc:48
FglmPolyIsZero
Definition: fglm.cc:49
pIsConstant
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:224
pIsUnivariate
#define pIsUnivariate(p)
Definition: polys.h:235
k
int k
Definition: cfEzgcd.cc:92
fglmConsistency
FglmState fglmConsistency(idhdl sringHdl, idhdl dringHdl, int *vperm)
Definition: fglm.cc:121
result
return result
Definition: facAbsBiFact.cc:76
fglmUpdateresult
void fglmUpdateresult(ideal &result)
Definition: fglm.cc:89
ADDRESS
void * ADDRESS
Definition: auxiliary.h:135
FglmState
FglmState
Definition: fglm.cc:39
FglmNotReduced
Definition: fglm.cc:44
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
idhdl
idrec * idhdl
Definition: ring.h:20
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:125
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
IDEAL_CMD
Definition: grammar.cc:284
pOne
#define pOne()
Definition: polys.h:299
sleftv::data
void * data
Definition: subexpr.h:87
FglmNotZeroDim
Definition: fglm.cc:45
fglmzero
BOOLEAN fglmzero(ring sourceRing, ideal &sourceIdeal, ring destRing, ideal &destideal, BOOLEAN switchBack=TRUE, BOOLEAN deleteIdeal=FALSE)
Definition: fglmzero.cc:1193
FglmHasOne
Definition: fglm.cc:42
FindUnivariatePolys
static ideal FindUnivariatePolys(const idealFunctionals &l)
Definition: fglmzero.cc:1118
FglmIncompatibleRings
Definition: fglm.cc:46
IDTYP
#define IDTYP(a)
Definition: ipid.h:113
IDRING
#define IDRING(a)
Definition: ipid.h:121
idrec
Definition: idrec.h:33
FindUnivariateWrapper
BOOLEAN FindUnivariateWrapper(ideal source, ideal &destIdeal)
Definition: fglmzero.cc:1236
FglmOk
Definition: fglm.cc:41
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:34
myynest
VAR int myynest
Definition: febase.cc:40
assumeStdFlag
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1551
fglmIdealcheck
FglmState fglmIdealcheck(const ideal theIdeal)
Definition: fglm.cc:242
NULL
#define NULL
Definition: omList.c:11
idealFunctionals
Definition: fglmzero.cc:74
currRingHdl
VAR idhdl currRingHdl
Definition: ipid.cc:58
fglmUpdatesource
ideal fglmUpdatesource(const ideal sourceIdeal)
Definition: fglm.cc:57
FglmNoIdeal
Definition: fglm.cc:43
sleftv::Name
const char * Name()
Definition: subexpr.h:119
setFlag
#define setFlag(A, F)
Definition: ipid.h:107
CalculateFunctionals
static BOOLEAN CalculateFunctionals(const ideal &theIdeal, idealFunctionals &l)
Definition: fglmzero.cc:673
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
count
int status int void size_t count
Definition: si_signals.h:58
pCopy
#define pCopy(p)
return a copy of the poly
Definition: polys.h:174
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:23
FLAG_STD
#define FLAG_STD
Definition: ipid.h:103
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
fglmquot
BOOLEAN fglmquot(ideal sourceIdeal, poly quot, ideal &destIdeal)
Definition: fglmzero.cc:1218
rSetHdl
void rSetHdl(idhdl h)
Definition: ipshell.cc:5085
IDIDEAL
#define IDIDEAL(a)
Definition: ipid.h:127