walkMain.h File Reference

#include "misc/intvec.h"
#include "misc/int64vec.h"

Go to the source code of this file.

Enumerations
enum	WalkState {   WalkNoIdeal , WalkIncompatibleRings , WalkIntvecProblem , WalkOverFlowError ,   WalkIncompatibleDestRing , WalkIncompatibleSourceRing , WalkOk }

Functions
WalkState	walkstep64 (ideal &G, int64vec *currw, int step)
WalkState	walk64 (ideal I, int64vec *currw64, ring destRing, int64vec *destVec64, ideal &destIdeal, BOOLEAN sourceIsSB=FALSE)
WalkState	fractalWalk64 (ideal sourceIdeal, ring destRing, ideal &destIdeal, BOOLEAN sourceIsSB, BOOLEAN unperturbedStartVectorStrategy)
WalkState	unperturbedFirstStep64 (ideal &G, int64vec *currw64, ring destRing)

Enumeration Type Documentation

WalkState

enum WalkState

Enumerator
WalkNoIdeal
WalkIncompatibleRings
WalkIntvecProblem
WalkOverFlowError
WalkIncompatibleDestRing
WalkIncompatibleSourceRing
WalkOk

Definition at line 7 of file walkMain.h.

              {
    WalkNoIdeal,
    WalkIncompatibleRings,
    WalkIntvecProblem,
    WalkOverFlowError,
    /*
    these could be defined to make error management more elegant
    WalkOverFlowError1,
    WalkOverFlowError2,
    WalkOverFlowError3,
    WalkOverFlowError4,
    WalkOverFlowError5,
    WalkOverFlowError6,
    WalkOverFlowError7,
    WalkOverFlowError8,
    WalkOverFlowError9,
    WalkOverFlowError10,
    WalkOverFlowError11,
    WalkOverFlowError12,
    WalkOverFlowError13,
    */
    WalkIncompatibleDestRing,
    WalkIncompatibleSourceRing,
    WalkOk
 
};

Function Documentation

fractalWalk64()

WalkState fractalWalk64	(	ideal	sourceIdeal,
		ring	destRing,
		ideal &	destIdeal,
		BOOLEAN	sourceIsSB,
		BOOLEAN	unperturbedStartVectorStrategy
	)

Definition at line 614 of file walkMain.cc.

{
 
  overflow_error=FALSE; //global
  WalkState state=WalkOk;
  BITSET save1,save2;
  SI_SAVE_OPT(save1,save2);
 
  si_opt_1|= (Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
  ideal G;
 
  if(!sourceIsSB)
  {
    G=idStd(sourceIdeal);
  }
 
  else
  {
    G=idInterRed(idCopy(sourceIdeal));
  }
 
  SI_RESTORE_OPT(save1,save2); //switches REDSB off
 
  //matrices for the orders of the rings
  intvec *destMat=int64VecToIntVec(rGetGlobalOrderMatrix(destRing));
  intvec *currMat=int64VecToIntVec(rGetGlobalOrderMatrix(currRing));
 
  int64vec* currw64=getNthRow64(currMat,1); //start vector
 
  state=firstFractalWalkStep64(G,currw64,currMat,destRing,
                               unperturbedStartVectorStrategy);
  delete currMat;
 
  state=fractalRec64(G,currw64,destMat,1,1);
  if(state==WalkOk)
    destIdeal=G;
 
  if(overflow_error)
    state=WalkOverFlowError;
 
  delete currw64;
  delete destMat;
  return state;
}

unperturbedFirstStep64()

WalkState unperturbedFirstStep64	(	ideal &	G,
		int64vec *	currw64,
		ring	destRing
	)

Definition at line 358 of file walkMain.cc.

{
  WalkState state=WalkOk;
  /* OLDRING **************************************************** */
  ideal nextG;
  BITSET save1,save2;
  SI_SAVE_OPT(save1,save2);
 
  if (currwOnBorder64(G,currw64))
  {
    ideal Gw=init64(G,currw64);
    ring oldRing=currRing;
  /* NEWRING **************************************************** */
    ring rnew=rCopy0AndAddA(destRing,currw64);
    rComplete(rnew);
    rChangeCurrRing(rnew);
 
    ideal newGw=idrMoveR(Gw, oldRing,rnew);
 
      //turn off bucket representation of polynomials and on redSB
    //si_opt_1|=Sy_bit(OPT_NOT_BUCKETS);
    si_opt_1|=Sy_bit(OPT_REDSB);
 
    ideal newStdGw=idStd(newGw);
 
    //turn on bucket representation of polynomials and off redSB
    SI_RESTORE_OPT(save1,save2);
 
    matrix L=matIdLift(newGw,newStdGw);
    idDelete(&newStdGw);
    idDelete(&newGw);
 
    nextG=idrMoveR(G,oldRing,rnew); idTest(nextG);
 
    matrix nextGmat=(matrix)nextG;
 
    matrix resMat=mp_Mult(nextGmat,L,rnew);
    idDelete((ideal *)&nextGmat);
    idDelete((ideal *)&L);
 
    nextG=(ideal)resMat;
 
    si_opt_1|=Sy_bit(OPT_REDSB);
    nextG = idInterRed(nextG);
    SI_RESTORE_OPT(save1,save2);
  }
  else
  {
    ring oldRing=currRing;
    ring rnew=rCopy0AndAddA(destRing,currw64);
    rComplete(rnew);
    rChangeCurrRing(rnew);
    nextG=idrMoveR(G,oldRing,rnew);
  }
 
  G=nextG;
  return(state);
}

walk64()

WalkState walk64	(	ideal	I,
		int64vec *	currw64,
		ring	destRing,
		int64vec *	destVec64,
		ideal &	destIdeal,
		BOOLEAN	sourceIsSB = FALSE
	)

Definition at line 222 of file walkMain.cc.

{
  //some initializations
  WalkState state=WalkOk;
  BITSET save1,save2;
  SI_SAVE_OPT(save1,save2);
 
  si_opt_1|=Sy_bit(OPT_REDTAIL);
  overflow_error=FALSE;
  int step=0;
  ideal G=I;
 
  si_opt_1|=Sy_bit(OPT_REDSB);
  if(!sourceIsSB)
  {
    ideal GG=idStd(G);
    idDelete(&G); G=GG;
  }
  else
    G=idInterRed(G);
  SI_RESTORE_OPT(save1,save2);
 
  ideal nextG;
  state=firstWalkStep64(G,currw64,destRing);
  nextG=G;
 
  if(overflow_error)
  {
    state=WalkOverFlowError;
    return(state);
  }
 
  int64 nexttvec0,nexttvec1;
  //int64vec* nexttvec64=nextt64(nextG,currw64,destVec64);
  nextt64(nextG,currw64,destVec64,nexttvec0,nexttvec1);
 
  //while(0<t<=1) ( t=((*nexttvec64)[0])/((*nexttvec64)[1]) )
  //while( (*nexttvec64)[0]<=(*nexttvec64)[1] ) {
  while (nexttvec0<=nexttvec1 )
  {
    step=step+1;
 
    //int64vec *tt=nextw64(currw64,destVec64,nexttvec64);
    int64vec *tt=nextw64(currw64,destVec64,nexttvec0,nexttvec1);
    delete currw64; currw64=tt; tt=NULL;
 
    if (TEST_OPT_PROT)
    {
      PrintS("walk step:"); currw64->show(); PrintLn();
    }
 
    state=walkStep64(nextG,currw64);
    //uppdates nextG if all is OK
 
    if(overflow_error)
      return(WalkOverFlowError);
 
    //delete nexttvec64;
    //nexttvec64=nextt64(nextG,currw64,destVec64);
    nextt64(nextG,currw64,destVec64,nexttvec0,nexttvec1);
 
  }
 
  destIdeal=sortRedSB(nextG);
  return(state);
}

walkstep64()

WalkState walkstep64	(	ideal &	G,
		int64vec *	currw,
		int	step
	)