My Project
Loading...
Searching...
No Matches
Macros | Functions | Variables
walk.cc File Reference
#include "kernel/mod2.h"
#include "misc/intvec.h"
#include "Singular/cntrlc.h"
#include "misc/options.h"
#include "omalloc/omalloc.h"
#include "Singular/ipshell.h"
#include "Singular/ipconv.h"
#include "coeffs/ffields.h"
#include "coeffs/coeffs.h"
#include "Singular/subexpr.h"
#include "polys/templates/p_Procs.h"
#include "polys/monomials/maps.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/GBEngine/khstd.h"
#include "Singular/walk.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "Singular/ipid.h"
#include "Singular/tok.h"
#include "coeffs/numbers.h"
#include "polys/monomials/ring.h"
#include "kernel/GBEngine/kstd1.h"
#include "polys/matpol.h"
#include "polys/weight.h"
#include "kernel/GBEngine/syz.h"
#include "Singular/lists.h"
#include "polys/prCopy.h"
#include "polys/clapsing.h"
#include "coeffs/mpr_complex.h"
#include <cmath>
#include "misc/mylimits.h"

Go to the source code of this file.

Macros

#define BUCHBERGER_ALG
 
#define CHECK_IDEAL_MWALK
 
#define INVEPS_SMALL_IN_FRACTAL
 
#define INVEPS_SMALL_IN_MPERTVECTOR
 
#define INVEPS_SMALL_IN_TRAN
 
#define FIRST_STEP_FRACTAL
 
#define MSTDCC_FRACTAL
 

Functions

BOOLEAN ErrorCheck ()
 
void Set_Error (BOOLEAN f)
 
static intset initec (int maxnr)
 
static unsigned long * initsevS (int maxnr)
 
static int * initS_2_R (int maxnr)
 
static ideal kInterRedCC (ideal F, ideal Q)
 
static void idString (ideal L, const char *st)
 
static void ivString (intvec *iv, const char *ch)
 
static long gcd (const long a, const long b)
 
static void cancel (mpz_t zaehler, mpz_t nenner)
 
static int MLmWeightedDegree (const poly p, intvec *weight)
 
static int MwalkWeightDegree (poly p, intvec *weight_vector)
 
static void MLmWeightedDegree_gmp (mpz_t result, const poly p, intvec *weight)
 
static poly MpolyInitialForm (poly g, intvec *curr_weight)
 
ideal MwalkInitialForm (ideal G, intvec *ivw)
 
static int test_w_in_ConeCC (ideal G, intvec *iv)
 
static long Mlcm (long &i1, long &i2)
 
static long MivDotProduct (intvec *a, intvec *b)
 
static intvecMivSub (intvec *a, intvec *b)
 
static intvecMExpPol (poly f)
 
int MivSame (intvec *u, intvec *v)
 
int M3ivSame (intvec *temp, intvec *u, intvec *v)
 
static ideal MstdCC (ideal G)
 
static ideal MstdhomCC (ideal G)
 
intvecMivMatrixOrder (intvec *iv)
 
intvecMivMatrixOrderRefine (intvec *iv, intvec *iw)
 
intvecMivdp (int nR)
 
intvecMivlp (int nR)
 
intvecMPertVectors (ideal G, intvec *ivtarget, int pdeg)
 
intvecMPertVectorslp (ideal G, intvec *ivtarget, int pdeg)
 
intvecMivMatrixOrderlp (int nV)
 
intvecMivMatrixOrderdp (int nV)
 
intvecMivWeightOrderlp (intvec *ivstart)
 
intvecMivWeightOrderdp (intvec *ivstart)
 
intvecMivUnit (int nV)
 
intvecMfpertvector (ideal G, intvec *ivtarget)
 
static ideal MidMult (ideal A, ideal B)
 
static ideal MLifttwoIdeal (ideal Gw, ideal M, ideal G)
 
static int MivComp (intvec *iva, intvec *ivb)
 
static int MivAbsMax (intvec *vec)
 
static int MivAbsMaxArg (intvec *vec)
 
static intvecMwalkNextWeightCC (intvec *curr_weight, intvec *target_weight, ideal G)
 
intvecMkInterRedNextWeight (intvec *iva, intvec *ivb, ideal G)
 
static ring VMrDefault (intvec *va)
 
static ring VMrRefine (intvec *va, intvec *vb)
 
static ring VMatrDefault (intvec *va)
 
static ring VMatrRefine (intvec *va, intvec *vb)
 
static void VMrDefaultlp (void)
 
static void DefRingPar (intvec *va)
 
static void DefRingParlp (void)
 
static int isNegNolVector (intvec *hilb)
 
static ideal middleOfCone (ideal G, ideal Gomega)
 
static ideal LastGB (ideal G, intvec *curr_weight, int tp_deg)
 
static int lengthpoly (ideal G)
 
static int maxlengthpoly (ideal G)
 
static int islengthpoly2 (ideal G)
 
static ideal idHeadCC (ideal h)
 
static int test_G_GB_walk (ideal H0, ideal H1)
 
static ideal Rec_LastGB (ideal G, intvec *curr_weight, intvec *orig_target_weight, int tp_deg, int npwinc)
 
ideal MAltwalk2 (ideal Go, intvec *curr_weight, intvec *target_weight)
 
static intvecNewVectorlp (ideal I)
 
static intvecMWalkRandomNextWeight (ideal G, intvec *orig_M, intvec *target_weight, int weight_rad, int pert_deg)
 
static ideal REC_GB_Mwalk (ideal G, intvec *curr_weight, intvec *orig_target_weight, int tp_deg, int npwinc)
 
ideal MwalkAlt (ideal Go, intvec *curr_weight, intvec *target_weight)
 
ideal Mwalk (ideal Go, intvec *orig_M, intvec *target_M, ring baseRing, int reduction, int printout)
 
ideal Mrwalk (ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int pert_deg, int reduction, int printout)
 
ideal Mpwalk (ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight, int nP, int reduction, int printout)
 
ideal Mprwalk (ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int op_deg, int tp_deg, int nP, int reduction, int printout)
 
intvecMMatrixone (int nV)
 
static ideal rec_fractal_call (ideal G, int nlev, intvec *ivtarget, int reduction, int printout)
 
static ideal rec_r_fractal_call (ideal G, int nlev, intvec *ivtarget, int weight_rad, int reduction, int printout)
 
ideal Mfwalk (ideal G, intvec *ivstart, intvec *ivtarget, int reduction, int printout)
 
ideal Mfrwalk (ideal G, intvec *ivstart, intvec *ivtarget, int weight_rad, int reduction, int printout)
 
ideal TranMImprovwalk (ideal G, intvec *curr_weight, intvec *target_tmp, int nP)
 
static ideal Mpwalk_MAltwalk1 (ideal Go, intvec *curr_weight, int tp_deg)
 
ideal MAltwalk1 (ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight)
 

Variables

VAR int nstep
 kstd2.cc More...
 
EXTERN_VAR BOOLEAN pSetm_error
 
VAR BOOLEAN Overflow_Error = FALSE
 
VAR int Xnlev
 
VAR int ngleich
 
VAR intvecXsigma
 
VAR intvecXtau
 
VAR int xn
 
VAR intvecXivinput
 
VAR intvecXivlp
 
VAR intvecXivNull
 
VAR int nnflow
 
VAR int Xcall
 
VAR int Xngleich
 

Macro Definition Documentation

◆ BUCHBERGER_ALG

#define BUCHBERGER_ALG

Definition at line 11 of file walk.cc.

◆ CHECK_IDEAL_MWALK

#define CHECK_IDEAL_MWALK

Definition at line 18 of file walk.cc.

◆ FIRST_STEP_FRACTAL

#define FIRST_STEP_FRACTAL

Definition at line 27 of file walk.cc.

◆ INVEPS_SMALL_IN_FRACTAL

#define INVEPS_SMALL_IN_FRACTAL

Definition at line 23 of file walk.cc.

◆ INVEPS_SMALL_IN_MPERTVECTOR

#define INVEPS_SMALL_IN_MPERTVECTOR

Definition at line 24 of file walk.cc.

◆ INVEPS_SMALL_IN_TRAN

#define INVEPS_SMALL_IN_TRAN

Definition at line 25 of file walk.cc.

◆ MSTDCC_FRACTAL

#define MSTDCC_FRACTAL

Definition at line 28 of file walk.cc.

Function Documentation

◆ cancel()

static void cancel ( mpz_t  zaehler,
mpz_t  nenner 
)
static

Definition at line 588 of file walk.cc.

589{
590// assume(zaehler >= 0 && nenner > 0);
591 mpz_t g;
592 mpz_init(g);
593 mpz_gcd(g, zaehler, nenner);
594
595 mpz_div(zaehler , zaehler, g);
596 mpz_div(nenner , nenner, g);
597
598 mpz_clear(g);
599}
g
Definition: cfModGcd.cc:4090

◆ DefRingPar()

static void DefRingPar ( intvec va)
static

Definition at line 2939 of file walk.cc.

2940{
2941 int nv = currRing->N;
2942 int nb = rBlocks(currRing) + 1;
2943
2945
2946 /*weights: entries for 3 blocks: NULL Made:???*/
2947 res->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2948 res->wvhdl[0] = (int*) omAlloc(nv*sizeof(int));
2949 for(int i=0; i<nv; i++)
2950 res->wvhdl[0][i] = (*va)[i];
2951
2952 /* order: a,lp,C,0 */
2953
2954 res->order = (rRingOrder_t *) omAlloc(nb * sizeof(rRingOrder_t *));
2955 res->block0 = (int *)omAlloc0(nb * sizeof(int *));
2956 res->block1 = (int *)omAlloc0(nb * sizeof(int *));
2957
2958 // ringorder a for the first block: var 1..nv
2959 res->order[0] = ringorder_a;
2960 res->block0[0] = 1;
2961 res->block1[0] = nv;
2962
2963 // ringorder lp for the second block: var 1..nv
2964 res->order[1] = ringorder_lp;
2965 res->block0[1] = 1;
2966 res->block1[1] = nv;
2967
2968 // ringorder C for the third block
2969 // it is very important within "idLift",
2970 // especially, by ring syz_ring=rCurrRingAssure_SyzComp();
2971 // therefore, nb must be (nBlocks(currRing) + 1)
2972 res->order[2] = ringorder_C;
2973
2974 // the last block: everything is 0
2975 res->order[3] = (rRingOrder_t)0;
2976
2977 // polynomial ring
2978 res->OrdSgn = 1;
2979
2980
2981 // complete ring intializations
2982 rComplete(res);
2983
2984 // execute the created ring
2986}
#define FALSE
Definition: auxiliary.h:96
int i
Definition: cfEzgcd.cc:132
CanonicalForm res
Definition: facAbsFact.cc:60
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omAlloc0(size)
Definition: omAllocDecl.h:211
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
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3450
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1421
static int rBlocks(const ring r)
Definition: ring.h:568
rRingOrder_t
order stuff
Definition: ring.h:68
@ ringorder_lp
Definition: ring.h:77
@ ringorder_a
Definition: ring.h:70
@ ringorder_C
Definition: ring.h:73
int * int_ptr
Definition: structs.h:54

◆ DefRingParlp()

static void DefRingParlp ( void  )
static

Definition at line 2988 of file walk.cc.

2989{
2990 int nv = currRing->N;
2991
2992 ring r=rCopy0(currRing,FALSE,FALSE);
2993
2994 int nb = rBlocks(currRing) + 1;
2995
2996 /*weights: entries for 3 blocks: NULL Made:???*/
2997
2998 r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2999
3000 /* order: lp,C,0 */
3001 r->order = (rRingOrder_t *) omAlloc(nb * sizeof(rRingOrder_t *));
3002 r->block0 = (int *)omAlloc0(nb * sizeof(int *));
3003 r->block1 = (int *)omAlloc0(nb * sizeof(int *));
3004
3005 /* ringorder lp for the first block: var 1..nv */
3006 r->order[0] = ringorder_lp;
3007 r->block0[0] = 1;
3008 r->block1[0] = nv;
3009
3010 /* ringorder C for the second block */
3011 r->order[1] = ringorder_C;
3012
3013 /* the last block: everything is 0 */
3014 r->order[2] = (rRingOrder_t)0;
3015
3016 /*polynomial ring*/
3017 r->OrdSgn = 1;
3018
3019
3020// if (rParameter(currRing)!=NULL)
3021// {
3022// r->cf->extRing->qideal->m[0]=p_Copy(currRing->cf->extRing->qideal->m[0], currRing->cf->extRing);
3023// int l=rPar(currRing);
3024// r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr));
3025//
3026// for(int i=l-1;i>=0;i--)
3027// {
3028// rParameter(r)[i]=omStrDup(rParameter(currRing)[i]);
3029// }
3030// }
3031
3032 // complete ring intializations
3033
3034 rComplete(r);
3035
3036 // execute the created ring
3037 rChangeCurrRing(r);
3038}

◆ ErrorCheck()

BOOLEAN ErrorCheck ( )

◆ gcd()

static long gcd ( const long  a,
const long  b 
)
inlinestatic

Definition at line 532 of file walk.cc.

533{
534 long r, p0 = a, p1 = b;
535 //assume(p0 >= 0 && p1 >= 0);
536 if(p0 < 0)
537 {
538 p0 = -p0;
539 }
540 if(p1 < 0)
541 {
542 p1 = -p1;
543 }
544 while(p1 != 0)
545 {
546 r = p0 % p1;
547 p0 = p1;
548 p1 = r;
549 }
550 return p0;
551}
CanonicalForm b
Definition: cfModGcd.cc:4103

◆ idHeadCC()

static ideal idHeadCC ( ideal  h)
static

Definition at line 3513 of file walk.cc.

3514{
3515 int i, nH =IDELEMS(h);
3516
3517 ideal m = idInit(nH,h->rank);
3518
3519 for (i=nH-1;i>=0; i--)
3520 {
3521 if (h->m[i]!=NULL)
3522 {
3523 m->m[i]=pHead(h->m[i]);
3524 }
3525 }
3526 return m;
3527}
int m
Definition: cfEzgcd.cc:128
STATIC_VAR Poly * h
Definition: janet.cc:971
#define NULL
Definition: omList.c:12
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ idString()

static void idString ( ideal  L,
const char *  st 
)
static

Definition at line 424 of file walk.cc.

425{
426 int i, nL = IDELEMS(L);
427
428 Print("\n// ideal %s = ", st);
429 for(i=0; i<nL-1; i++)
430 {
431 Print(" %s, ", pString(L->m[i]));
432 }
433 Print(" %s;", pString(L->m[nL-1]));
434}
#define Print
Definition: emacs.cc:80
char * pString(poly p)
Definition: polys.h:306

◆ initec()

static intset initec ( int  maxnr)
inlinestatic

Definition at line 98 of file walk.cc.

99{
100 return (intset)omAlloc(maxnr*sizeof(int));
101}
int * intset
Definition: kutil.h:53

◆ initS_2_R()

static int * initS_2_R ( int  maxnr)
inlinestatic

Definition at line 107 of file walk.cc.

108{
109 return (int*)omAlloc0(maxnr*sizeof(int));
110}

◆ initsevS()

static unsigned long * initsevS ( int  maxnr)
inlinestatic

Definition at line 103 of file walk.cc.

104{
105 return (unsigned long*)omAlloc0(maxnr*sizeof(unsigned long));
106}

◆ islengthpoly2()

static int islengthpoly2 ( ideal  G)
static

Definition at line 3477 of file walk.cc.

3478{
3479 int i;
3480 for(i=IDELEMS(G)-1; i>=0; i--)
3481 {
3482 if((G->m[i]!=NULL) /* len >=0 */
3483 && (G->m[i]->next!=NULL) /* len >=1 */
3484 && (G->m[i]->next->next!=NULL)) /* len >=2 */
3485 {
3486 return 1;
3487 }
3488 }
3489 return 0;
3490}
STATIC_VAR TreeM * G
Definition: janet.cc:31

◆ isNegNolVector()

static int isNegNolVector ( intvec hilb)
static

Definition at line 3061 of file walk.cc.

3062{
3063 int i;
3064 for(i=hilb->length()-1; i>=0; i--)
3065 {
3066 if((* hilb)[i]<=0)
3067 {
3068 return 1;
3069 }
3070 }
3071 return 0;
3072}
int length() const
Definition: intvec.h:94

◆ ivString()

static void ivString ( intvec iv,
const char *  ch 
)
static

Definition at line 492 of file walk.cc.

493{
494 int nV = iv->length()-1;
495 Print("\n// intvec %s = ", ch);
496
497 for(int i=0; i<nV; i++)
498 {
499 Print("%d, ", (*iv)[i]);
500 }
501 Print("%d;", (*iv)[nV]);
502}

◆ kInterRedCC()

static ideal kInterRedCC ( ideal  F,
ideal  Q 
)
static

Definition at line 268 of file walk.cc.

269{
270 int j;
271 kStrategy strat = new skStrategy;
272/*
273 if (TEST_OPT_PROT)
274 {
275 writeTime("start InterRed:");
276 mflush();
277 }
278 strat->syzComp = 0;
279*/
280 strat->kAllAxis = (currRing->ppNoether) != NULL;
281 strat->kNoether=pCopy((currRing->ppNoether));
282 strat->ak = id_RankFreeModule(F, currRing);
283 initBuchMoraCrit(strat);
284 strat->NotUsedAxis = (BOOLEAN *)omAlloc((currRing->N+1)*sizeof(BOOLEAN));
285 for(j=currRing->N; j>0; j--)
286 {
287 strat->NotUsedAxis[j] = TRUE;
288 }
289 strat->enterS = enterSBba;
290 strat->posInT = posInT0;
291 strat->initEcart = initEcartNormal;
292 strat->sl = -1;
293 strat->tl = -1;
294 strat->tmax = setmaxT;
295 strat->T = initT();
296 strat->R = initR();
297 strat->sevT = initsevT();
299 {
300 strat->honey = TRUE;
301 }
302
303 //initSCC(F,Q,strat);
304 initS(F,Q,strat);
305
306 /*
307 timetmp=clock();//22.01.02
308 initSSpecialCC(F,Q,NULL,strat);
309 tininitS=tininitS+clock()-timetmp;//22.01.02
310 */
312 {
313 strat->noTailReduction=FALSE;
314 }
315 updateS(TRUE,strat);
316
318 {
319 completeReduce(strat);
320 }
321 if(strat->kNoether!=NULL) pLmFree(&strat->kNoether);
322 omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
323 omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
324 omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
325 omFreeSize((ADDRESS)strat->NotUsedAxis,(currRing->N+1)*sizeof(BOOLEAN));
326 omfree(strat->sevT);
327 omfree(strat->S_2_R);
328 omfree(strat->R);
329
330 if(strat->fromQ)
331 {
332 for(j=0; j<IDELEMS(strat->Shdl); j++)
333 {
334 if(strat->fromQ[j])
335 {
336 pDelete(&strat->Shdl->m[j]);
337 }
338 }
339 omFreeSize((ADDRESS)strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
340 strat->fromQ = NULL;
341 }
342/*
343 if (TEST_OPT_PROT)
344 {
345 writeTime("end Interred:");
346 mflush();
347 }
348*/
349 ideal shdl=strat->Shdl;
350 idSkipZeroes(shdl);
351 delete(strat);
352
353 return shdl;
354}
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
void * ADDRESS
Definition: auxiliary.h:119
int * S_2_R
Definition: kutil.h:342
char noTailReduction
Definition: kutil.h:378
TSet T
Definition: kutil.h:326
intset ecartS
Definition: kutil.h:309
char honey
Definition: kutil.h:377
poly kNoether
Definition: kutil.h:329
BOOLEAN * NotUsedAxis
Definition: kutil.h:332
int ak
Definition: kutil.h:353
TObject ** R
Definition: kutil.h:340
int tl
Definition: kutil.h:350
unsigned long * sevT
Definition: kutil.h:325
ideal Shdl
Definition: kutil.h:303
int tmax
Definition: kutil.h:350
char kAllAxis
Definition: kutil.h:376
intset fromQ
Definition: kutil.h:321
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:286
void(* initEcart)(TObject *L)
Definition: kutil.h:280
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:281
int sl
Definition: kutil.h:348
unsigned long * sevS
Definition: kutil.h:322
int j
Definition: facHensel.cc:110
KINLINE TSet initT()
Definition: kInline.h:84
KINLINE TObject ** initR()
Definition: kInline.h:95
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
int posInT0(const TSet, const int length, LObject &)
Definition: kutil.cc:4907
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:7635
void initEcartNormal(TObject *h)
Definition: kutil.cc:1304
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:8594
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9476
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10340
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:8829
#define setmaxT
Definition: kutil.h:33
class sTObject TObject
Definition: kutil.h:57
#define omfree(addr)
Definition: omAllocDecl.h:237
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define TEST_OPT_INTSTRATEGY
Definition: options.h:111
#define TEST_OPT_REDSB
Definition: options.h:105
#define pDelete(p_ptr)
Definition: polys.h:186
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:70
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:760
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
#define Q
Definition: sirandom.c:26

◆ LastGB()

static ideal LastGB ( ideal  G,
intvec curr_weight,
int  tp_deg 
)
static

Definition at line 3145 of file walk.cc.

3146{
3147 BOOLEAN nError = Overflow_Error;
3149
3150 int i, nV = currRing->N;
3151 int nwalk=0, endwalks=0, nnwinC=1;
3152 int nlast = 0;
3153 ideal Gomega, M, F, Gomega1, Gomega2, M1,F1,result,ssG;
3154 ring newRing, oldRing, TargetRing;
3155 intvec* iv_M_lp;
3156 intvec* target_weight;
3157 intvec* iv_lp = Mivlp(nV); //define (1,0,...,0)
3158 intvec* pert_target_vector;
3159 intvec* ivNull = new intvec(nV);
3160 intvec* extra_curr_weight = new intvec(nV);
3161 intvec* next_weight;
3162
3163#ifndef BUCHBERGER_ALG
3164 intvec* hilb_func;
3165#endif
3166
3167 // to avoid (1,0,...,0) as the target vector
3168 intvec* last_omega = new intvec(nV);
3169 for(i=nV-1; i>0; i--)
3170 {
3171 (*last_omega)[i] = 1;
3172 }
3173 (*last_omega)[0] = 10000;
3174
3175 ring EXXRing = currRing;
3176
3177 // compute a pertubed weight vector of the target weight vector
3178 if(tp_deg > 1 && tp_deg <= nV)
3179 {
3180 //..25.03.03 VMrDefaultlp();// VMrDefault(target_weight);
3181 if (rParameter (currRing) != NULL)
3182 {
3183 DefRingParlp();
3184 }
3185 else
3186 {
3187 VMrDefaultlp();
3188 }
3189 TargetRing = currRing;
3190 ssG = idrMoveR(G,EXXRing,currRing);
3191 iv_M_lp = MivMatrixOrderlp(nV);
3192 //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
3193 target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
3194 delete iv_M_lp;
3195 pert_target_vector = target_weight;
3196
3197 rChangeCurrRing(EXXRing);
3198 G = idrMoveR(ssG, TargetRing,currRing);
3199 }
3200 else
3201 {
3202 target_weight = Mivlp(nV);
3203 }
3204 //Print("\n// ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
3205
3206 while(1)
3207 {
3208 nwalk++;
3209 nstep++;
3210#ifdef TIME_TEST
3211 to=clock();
3212#endif
3213 // compute a next weight vector
3214 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
3215#ifdef TIME_TEST
3216 xtnw=xtnw+clock()-to;
3217#endif
3218
3219#ifdef PRINT_VECTORS
3220 MivString(curr_weight, target_weight, next_weight);
3221#endif
3222
3223 if(Overflow_Error == TRUE)
3224 {
3225 newRing = currRing;
3226 nnwinC = 0;
3227 if(tp_deg == 1)
3228 {
3229 nlast = 1;
3230 }
3231 delete next_weight;
3232
3233 //idElements(G, "G");
3234 //Print("\n// ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
3235
3236 break;
3237 }
3238
3239 if(MivComp(next_weight, ivNull) == 1)
3240 {
3241 //Print("\n// ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
3242 newRing = currRing;
3243 delete next_weight;
3244 break;
3245 }
3246
3247 if(MivComp(next_weight, target_weight) == 1)
3248 endwalks = 1;
3249
3250 for(i=nV-1; i>=0; i--)
3251 {
3252 (*extra_curr_weight)[i] = (*curr_weight)[i];
3253 }
3254 /* 06.11.01 NOT Changed */
3255 for(i=nV-1; i>=0; i--)
3256 {
3257 (*curr_weight)[i] = (*next_weight)[i];
3258 }
3259 oldRing = currRing;
3260#ifdef TIME_TEST
3261 to=clock();
3262#endif
3263 // compute an initial form ideal of <G> w.r.t. "curr_vector"
3264 Gomega = MwalkInitialForm(G, curr_weight);
3265#ifdef TIME_TEST
3266 xtif=xtif+clock()-to;
3267#endif
3268
3269#ifdef ENDWALKS
3270 if(endwalks == 1)
3271 {
3272 Print("\n// ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
3273/*
3274 idElements(Gomega, "Gw");
3275 headidString(Gomega, "Gw");
3276*/
3277 }
3278#endif
3279
3280#ifndef BUCHBERGER_ALG
3281 if(isNolVector(curr_weight) == 0)
3282 {
3283 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
3284 }
3285 else
3286 {
3287 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
3288 }
3289#endif // BUCHBERGER_ALG
3290
3291 /* define a new ring that its ordering is "(a(curr_weight),lp) */
3292 //..25.03.03 VMrDefault(curr_weight);
3293 if (rParameter (currRing) != NULL)
3294 {
3295 DefRingPar(curr_weight);
3296 }
3297 else
3298 {
3299 rChangeCurrRing(VMrDefault(curr_weight));
3300 }
3301 newRing = currRing;
3302 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
3303
3304#ifdef TIME_TEST
3305 to=clock();
3306#endif
3307 /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
3308#ifdef BUCHBERGER_ALG
3309 M = MstdhomCC(Gomega1);
3310#else
3311 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
3312 delete hilb_func;
3313#endif // BUCHBERGER_ALG
3314#ifdef TIME_TEST
3315 xtstd=xtstd+clock()-to;
3316#endif
3317 /* change the ring to oldRing */
3318 rChangeCurrRing(oldRing);
3319 M1 = idrMoveR(M, newRing,currRing);
3320 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
3321
3322#ifdef TIME_TEST
3323 to=clock();
3324#endif
3325 /* compute a reduced Groebner basis of <G> w.r.t. "newRing" */
3326 F = MLifttwoIdeal(Gomega2, M1, G);
3327#ifdef TIME_TEST
3328 xtlift=xtlift+clock()-to;
3329#endif
3330
3331 idDelete(&M1);
3332 idDelete(&G);
3333
3334 /* change the ring to newRing */
3335 rChangeCurrRing(newRing);
3336 F1 = idrMoveR(F, oldRing,currRing);
3337
3338#ifdef TIME_TEST
3339 to=clock();
3340#endif
3341 /* reduce the Groebner basis <G> w.r.t. new ring */
3342 G = kInterRedCC(F1, NULL);
3343#ifdef TIME_TEST
3344 xtred=xtred+clock()-to;
3345#endif
3346 idDelete(&F1);
3347
3348 if(endwalks == 1)
3349 {
3350 //Print("\n// ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
3351 break;
3352 }
3353
3354 delete next_weight;
3355 }//while
3356
3357 delete ivNull;
3358
3359 if(tp_deg != 1)
3360 {
3361 //..25.03.03 VMrDefaultlp();//define and execute the ring "lp"
3362 if (rParameter (currRing) != NULL)
3363 {
3364 DefRingParlp();
3365 }
3366 else
3367 {
3368 VMrDefaultlp();
3369 }
3370 F1 = idrMoveR(G, newRing,currRing);
3371
3372 if(nnwinC == 0 || test_w_in_ConeCC(F1, pert_target_vector) != 1)
3373 {
3374 oldRing = currRing;
3375 rChangeCurrRing(newRing);
3376 G = idrMoveR(F1, oldRing,currRing);
3377 Print("\n// takes %d steps and calls the recursion of level %d:",
3378 nwalk, tp_deg-1);
3379
3380 F1 = LastGB(G,curr_weight, tp_deg-1);
3381 }
3382
3383 TargetRing = currRing;
3384 rChangeCurrRing(EXXRing);
3385 result = idrMoveR(F1, TargetRing,currRing);
3386 }
3387 else
3388 {
3389 if(nlast == 1)
3390 {
3391 //OMEGA_OVERFLOW_LASTGB:
3392 /*
3393 if(MivSame(curr_weight, iv_lp) == 1)
3394 if (rParameter(currRing) != NULL)
3395 DefRingParlp();
3396 else
3397 VMrDefaultlp();
3398 else
3399 if (rParameter(currRing) != NULL)
3400 DefRingPar(curr_weight);
3401 else
3402 VMrDefault(curr_weight);
3403 */
3404
3405 //..25.03.03 VMrDefaultlp();//define and execute the ring "lp"
3406 if (rParameter (currRing) != NULL)
3407 {
3408 DefRingParlp();
3409 }
3410 else
3411 {
3412 VMrDefaultlp();
3413 }
3414
3415 F1 = idrMoveR(G, newRing,currRing);
3416 //Print("\n// Apply \"std\" in ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
3417
3418 G = MstdCC(F1);
3419 idDelete(&F1);
3420 newRing = currRing;
3421 }
3422
3423 rChangeCurrRing(EXXRing);
3424 result = idrMoveR(G, newRing,currRing);
3425 }
3426 delete target_weight;
3427 delete last_omega;
3428 delete iv_lp;
3429
3430 if(Overflow_Error == FALSE)
3431 {
3432 Overflow_Error = nError;
3433 }
3434 return(result);
3435}
Definition: intvec.h:23
return result
Definition: facAbsBiFact.cc:75
intvec * hFirstSeries(ideal A, intvec *module_w, ideal Q, intvec *wdegree)
Definition: hilb.cc:2036
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2447
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:248
char * rString(ring r)
Definition: ring.cc:673
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition: ring.h:625
#define M
Definition: sirandom.c:25
@ isHomog
Definition: structs.h:37
int F1(int a1, int &r1)
F1.
static ideal kInterRedCC(ideal F, ideal Q)
Definition: walk.cc:268
VAR int nstep
kstd2.cc
Definition: walk.cc:80
static ideal MstdhomCC(ideal G)
Definition: walk.cc:947
static int MivComp(intvec *iva, intvec *ivb)
Definition: walk.cc:1798
intvec * MPertVectors(ideal G, intvec *ivtarget, int pdeg)
Definition: walk.cc:1088
static ideal MLifttwoIdeal(ideal Gw, ideal M, ideal G)
Definition: walk.cc:1721
static ring VMrDefault(intvec *va)
Definition: walk.cc:2680
static void DefRingParlp(void)
Definition: walk.cc:2988
VAR BOOLEAN Overflow_Error
Definition: walk.cc:88
intvec * Mivlp(int nR)
Definition: walk.cc:1022
ideal MwalkInitialForm(ideal G, intvec *ivw)
Definition: walk.cc:761
static ideal LastGB(ideal G, intvec *curr_weight, int tp_deg)
Definition: walk.cc:3145
intvec * MivMatrixOrderlp(int nV)
Definition: walk.cc:1401
intvec * MkInterRedNextWeight(intvec *iva, intvec *ivb, ideal G)
Definition: walk.cc:2570
static void VMrDefaultlp(void)
Definition: walk.cc:2898
static void DefRingPar(intvec *va)
Definition: walk.cc:2939
static ideal MstdCC(ideal G)
Definition: walk.cc:932
static int test_w_in_ConeCC(ideal G, intvec *iv)
Definition: walk.cc:785

◆ lengthpoly()

static int lengthpoly ( ideal  G)
static

Definition at line 3440 of file walk.cc.

3441{
3442 int i;
3443 for(i=IDELEMS(G)-1; i>=0; i--)
3444 {
3445 if((G->m[i]!=NULL) /* len >=0 */
3446 && (G->m[i]->next!=NULL) /* len >=1 */
3447 && (G->m[i]->next->next!=NULL) /* len >=2 */
3448 && (G->m[i]->next->next->next!=NULL) /* len >=3 */
3449 && (G->m[i]->next->next->next->next!=NULL) /* len >=4*/ )
3450 {
3451 return 1;
3452 }
3453 }
3454 return 0;
3455}

◆ M3ivSame()

int M3ivSame ( intvec temp,
intvec u,
intvec v 
)

Definition at line 914 of file walk.cc.

915{
916 assume(temp->length() == u->length() && u->length() == v->length());
917
918 if((MivSame(temp, u)) == 1)
919 {
920 return 0;
921 }
922 if((MivSame(temp, v)) == 1)
923 {
924 return 1;
925 }
926 return 2;
927}
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
#define assume(x)
Definition: mod2.h:389
int MivSame(intvec *u, intvec *v)
Definition: walk.cc:893

◆ MAltwalk1()

ideal MAltwalk1 ( ideal  Go,
int  op_deg,
int  tp_deg,
intvec curr_weight,
intvec target_weight 
)

Definition at line 9671 of file walk.cc.

9673{
9674 Set_Error(FALSE );
9676#ifdef TIME_TEST
9677 BOOLEAN nOverflow_Error = FALSE;
9678#endif
9679 // Print("// pSetm_Error = (%d)", ErrorCheck());
9680
9681#ifdef TIME_TEST
9682 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0; xtextra=0;
9683 xftinput = clock();
9684 clock_t tostd, tproc;
9685#endif
9686
9687 nstep = 0;
9688 int i, nV = currRing->N;
9689 int nwalk=0, endwalks=0;
9690 int op_tmp = op_deg;
9691 ideal Gomega, M, F, G, Gomega1, Gomega2, M1, F1;
9692 ring newRing, oldRing;
9693 intvec* next_weight;
9694 intvec* iv_M_dp;
9695 intvec* ivNull = new intvec(nV);
9696 intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
9697 intvec* exivlp = Mivlp(nV);
9698 //intvec* extra_curr_weight = new intvec(nV);
9699#ifndef BUCHBERGER_ALG
9700 intvec* hilb_func;
9701#endif
9702 intvec* cw_tmp = curr_weight;
9703
9704 // to avoid (1,0,...,0) as the target vector
9705 intvec* last_omega = new intvec(nV);
9706 for(i=nV-1; i>0; i--)
9707 {
9708 (*last_omega)[i] = 1;
9709 }
9710 (*last_omega)[0] = 10000;
9711
9712 ring XXRing = currRing;
9713
9714#ifdef TIME_TEST
9715 to=clock();
9716#endif
9717 /* compute a pertubed weight vector of the original weight vector.
9718 The perturbation degree is recursive decrease until that vector
9719 stays inn the correct cone. */
9720 while(1)
9721 {
9722 if(Overflow_Error == FALSE)
9723 {
9724 if(MivComp(curr_weight, iv_dp) == 1)
9725 {
9726 //rOrdStr(currRing) = "dp"
9727 if(op_tmp == op_deg)
9728 {
9729 G = MstdCC(Go);
9730 if(op_deg != 1)
9731 {
9732 iv_M_dp = MivMatrixOrderdp(nV);
9733 }
9734 }
9735 }
9736 }
9737 else
9738 {
9739 if(op_tmp == op_deg)
9740 {
9741 //rOrdStr(currRing) = (a(...),lp,C)
9742 if (rParameter(currRing) != NULL)
9743 {
9744 DefRingPar(cw_tmp);
9745 }
9746 else
9747 {
9748 rChangeCurrRing(VMrDefault(cw_tmp));
9749 }
9750 G = idrMoveR(Go, XXRing,currRing);
9751 G = MstdCC(G);
9752 if(op_deg != 1)
9753 iv_M_dp = MivMatrixOrder(cw_tmp);
9754 }
9755 }
9757 if(op_deg != 1)
9758 {
9759 curr_weight = MPertVectors(G, iv_M_dp, op_deg);
9760 }
9761 else
9762 {
9763 curr_weight = cw_tmp;
9764 break;
9765 }
9766 if(Overflow_Error == FALSE)
9767 {
9768 break;
9769 }
9771 op_deg --;
9772 }
9773#ifdef TIME_TEST
9774 tostd=clock()-to;
9775#endif
9776
9777 if(op_tmp != 1 )
9778 delete iv_M_dp;
9779 delete iv_dp;
9780
9781 if(currRing->order[0] == ringorder_a)
9782 goto NEXT_VECTOR;
9783
9784 while(1)
9785 {
9786 nwalk ++;
9787 nstep ++;
9788
9789#ifdef TIME_TEST
9790 to = clock();
9791#endif
9792 // compute an initial form ideal of <G> w.r.t. "curr_vector"
9793 Gomega = MwalkInitialForm(G, curr_weight);
9794#ifdef TIME_TEST
9795 xtif=xtif+clock()-to;
9796#endif
9797#if 0
9798 if(Overflow_Error == TRUE)
9799 {
9800 for(i=nV-1; i>=0; i--)
9801 (*curr_weight)[i] = (*extra_curr_weight)[i];
9802 delete extra_curr_weight;
9803
9804 newRing = currRing;
9805 goto MSTD_ALT1;
9806 }
9807#endif
9808#ifndef BUCHBERGER_ALG
9809 if(isNolVector(curr_weight) == 0)
9810 {
9811 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
9812 }
9813 else
9814 {
9815 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
9816 }
9817#endif // BUCHBERGER_ALG
9818
9819 oldRing = currRing;
9820
9821 // define a new ring which ordering is "(a(curr_weight),lp)
9822 if (rParameter(currRing) != NULL)
9823 {
9824 DefRingPar(curr_weight);
9825 }
9826 else
9827 {
9828 rChangeCurrRing(VMrDefault(curr_weight));
9829 }
9830 newRing = currRing;
9831 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
9832
9833#ifdef TIME_TEST
9834 to=clock();
9835#endif
9836 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
9837#ifdef BUCHBERGER_ALG
9838 M = MstdhomCC(Gomega1);
9839#else
9840 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
9841 delete hilb_func;
9842#endif // BUCHBERGER_ALG
9843#ifdef TIME_TEST
9844 xtstd=xtstd+clock()-to;
9845#endif
9846
9847 // change the ring to oldRing
9848 rChangeCurrRing(oldRing);
9849 M1 = idrMoveR(M, newRing,currRing);
9850 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
9851
9852#ifdef TIME_TEST
9853 to=clock();
9854#endif
9855 // compute a reduced Groebner basis of <G> w.r.t. "newRing" by the lifting process
9856 F = MLifttwoIdeal(Gomega2, M1, G);
9857#ifdef TIME_TEST
9858 xtlift=xtlift+clock()-to;
9859#endif
9860
9861 idDelete(&M1);
9862 idDelete(&Gomega2);
9863 idDelete(&G);
9864
9865 // change the ring to newRing
9866 rChangeCurrRing(newRing);
9867 F1 = idrMoveR(F, oldRing,currRing);
9868 if (oldRing!=IDRING(currRingHdl)) rDelete(oldRing); // do not delete the global currRing
9869 oldRing=NULL;
9870
9871#ifdef TIME_TEST
9872 to=clock();
9873#endif
9874 // reduce the Groebner basis <G> w.r.t. new ring
9875 G = kInterRedCC(F1, NULL);
9876#ifdef TIME_TEST
9877 xtred=xtred+clock()-to;
9878#endif
9879 idDelete(&F1);
9880
9881 if(endwalks == 1)
9882 {
9883 break;
9884 }
9885 NEXT_VECTOR:
9886#ifdef TIME_TEST
9887 to=clock();
9888#endif
9889 // compute a next weight vector
9890 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
9891#ifdef TIME_TEST
9892 xtnw=xtnw+clock()-to;
9893#endif
9894#ifdef PRINT_VECTORS
9895 MivString(curr_weight, target_weight, next_weight);
9896#endif
9897 if(Overflow_Error == TRUE)
9898 {
9899 newRing = currRing;
9900
9901 if (rParameter(currRing) != NULL)
9902 {
9903 DefRingPar(target_weight);
9904 }
9905 else
9906 {
9907 rChangeCurrRing(VMrDefault(target_weight));
9908 }
9909 F1 = idrMoveR(G, newRing,currRing);
9910 G = MstdCC(F1);
9911 idDelete(&F1);
9912 newRing = currRing;
9913 break; //for while
9914 }
9915
9916
9917 /* G is the wanted Groebner basis if next_weight == curr_weight */
9918 if(MivComp(next_weight, ivNull) == 1)
9919 {
9920 newRing = currRing;
9921 delete next_weight;
9922 break; //for while
9923 }
9924
9925 if(MivComp(next_weight, target_weight) == 1)
9926 {
9927 if(tp_deg == 1 || MivSame(target_weight, exivlp) == 0)
9928 endwalks = 1;
9929 else
9930 {
9931 // MSTD_ALT1:
9932#ifdef TIME_TEST
9933 nOverflow_Error = Overflow_Error;
9934 tproc = clock()-xftinput;
9935#endif
9936
9937 //Print("\n// main routine takes %d steps and calls \"Mpwalk\" (1,%d):", nwalk, tp_deg);
9938
9939 // compute the red. GB of <G> w.r.t. the lex order by the "recursive-modified" perturbation walk alg (1,tp_deg)
9940 G = Mpwalk_MAltwalk1(G, curr_weight, tp_deg);
9941 delete next_weight;
9942 break; // for while
9943 }
9944 }
9945
9946 //NOT Changed, to free memory
9947 for(i=nV-1; i>=0; i--)
9948 {
9949 //(*extra_curr_weight)[i] = (*curr_weight)[i];
9950 (*curr_weight)[i] = (*next_weight)[i];
9951 }
9952 delete next_weight;
9953 }//while
9954
9955 rChangeCurrRing(XXRing);
9956 ideal result = idrMoveR(G, newRing,currRing);
9957 id_Delete(&G, newRing);
9958
9959 delete ivNull;
9960 if(op_deg != 1 )
9961 {
9962 delete curr_weight;
9963 }
9964 delete exivlp;
9965#ifdef TIME_TEST
9966/*
9967 Print("\n// \"Main procedure\" took %d steps, %.2f sec. and Overflow_Error(%d)",
9968 nwalk, ((double) tproc)/1000000, nOverflow_Error);
9969
9970 TimeStringFractal(xftinput, tostd, xtif, xtstd,xtextra, xtlift, xtred, xtnw);
9971*/
9972 // Print("\n// pSetm_Error = (%d)", ErrorCheck());
9973 // Print("\n// Overflow_Error? (%d)", Overflow_Error);
9974 // Print("\n// Awalk1 took %d steps.\n", nstep);
9975#endif
9976 return(result);
9977}
VAR idhdl currRingHdl
Definition: ipid.cc:59
#define IDRING(a)
Definition: ipid.h:127
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
intvec * MivUnit(int nV)
Definition: walk.cc:1496
intvec * MivMatrixOrderdp(int nV)
Definition: walk.cc:1417
intvec * MivMatrixOrder(intvec *iv)
Definition: walk.cc:963
void Set_Error(BOOLEAN f)
Definition: walk.cc:86
static ideal Mpwalk_MAltwalk1(ideal Go, intvec *curr_weight, int tp_deg)
Definition: walk.cc:9377

◆ MAltwalk2()

ideal MAltwalk2 ( ideal  Go,
intvec curr_weight,
intvec target_weight 
)

Definition at line 4280 of file walk.cc.

4281{
4284 //BOOLEAN nOverflow_Error = FALSE;
4285 //Print("// pSetm_Error = (%d)", ErrorCheck());
4286#ifdef TIME_TEST
4287 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0; xtextra=0;
4288 xftinput = clock();
4289 clock_t tostd, tproc;
4290#endif
4291 nstep = 0;
4292 int i, nV = currRing->N;
4293 int nwalk=0, endwalks=0;
4294 // int nhilb = 1;
4295 ideal Gomega, M, F, Gomega1, Gomega2, M1, F1, G;
4296 //ideal G1;
4297 //ring endRing;
4298 ring newRing, oldRing;
4299 intvec* ivNull = new intvec(nV);
4300 intvec* next_weight;
4301 //intvec* extra_curr_weight = new intvec(nV);
4302 //intvec* hilb_func;
4303 intvec* exivlp = Mivlp(nV);
4304 ring XXRing = currRing;
4305
4306 //Print("\n// ring r_input = %s;", rString(currRing));
4307#ifdef TIME_TEST
4308 to = clock();
4309#endif
4310 /* compute the reduced Groebner basis of the given ideal w.r.t.
4311 a "fast" monomial order, e.g. degree reverse lex. order (dp) */
4312 G = MstdCC(Go);
4313#ifdef TIME_TEST
4314 tostd=clock()-to;
4315
4316 Print("\n// Computation of the first std took = %.2f sec",
4317 ((double) tostd)/1000000);
4318#endif
4319 if(currRing->order[0] == ringorder_a)
4320 {
4321 goto NEXT_VECTOR;
4322 }
4323 while(1)
4324 {
4325 nwalk ++;
4326 nstep ++;
4327#ifdef TIME_TEST
4328 to = clock();
4329#endif
4330 /* compute an initial form ideal of <G> w.r.t. "curr_vector" */
4331 Gomega = MwalkInitialForm(G, curr_weight);
4332#ifdef TIME_TEST
4333 xtif=xtif+clock()-to;
4334#endif
4335/*
4336 if(Overflow_Error == TRUE)
4337 {
4338 for(i=nV-1; i>=0; i--)
4339 (*curr_weight)[i] = (*extra_curr_weight)[i];
4340 delete extra_curr_weight;
4341 goto LAST_GB_ALT2;
4342 }
4343*/
4344 oldRing = currRing;
4345
4346 /* define a new ring that its ordering is "(a(curr_weight),lp) */
4347 if (rParameter(currRing) != NULL)
4348 {
4349 DefRingPar(curr_weight);
4350 }
4351 else
4352 {
4353 rChangeCurrRing(VMrDefault(curr_weight));
4354 }
4355 newRing = currRing;
4356 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
4357#ifdef TIME_TEST
4358 to = clock();
4359#endif
4360 /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
4361 M = MstdhomCC(Gomega1);
4362#ifdef TIME_TEST
4363 xtstd=xtstd+clock()-to;
4364#endif
4365 /* change the ring to oldRing */
4366 rChangeCurrRing(oldRing);
4367 M1 = idrMoveR(M, newRing,currRing);
4368 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
4369#ifdef TIME_TEST
4370 to = clock();
4371#endif
4372 /* compute the reduced Groebner basis of <G> w.r.t. "newRing"
4373 by the liftig process */
4374 F = MLifttwoIdeal(Gomega2, M1, G);
4375#ifdef TIME_TEST
4376 xtlift=xtlift+clock()-to;
4377#endif
4378 idDelete(&M1);
4379 idDelete(&Gomega2);
4380 idDelete(&G);
4381
4382 /* change the ring to newRing */
4383 rChangeCurrRing(newRing);
4384 F1 = idrMoveR(F, oldRing,currRing);
4385#ifdef TIME_TEST
4386 to = clock();
4387#endif
4388 /* reduce the Groebner basis <G> w.r.t. newRing */
4389 G = kInterRedCC(F1, NULL);
4390#ifdef TIME_TEST
4391 xtred=xtred+clock()-to;
4392#endif
4393 idDelete(&F1);
4394
4395 if(endwalks == 1)
4396 break;
4397
4398 NEXT_VECTOR:
4399#ifdef TIME_TEST
4400 to = clock();
4401#endif
4402 /* compute a next weight vector */
4403 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
4404#ifdef TIME_TEST
4405 xtnw=xtnw+clock()-to;
4406#endif
4407#ifdef PRINT_VECTORS
4408 MivString(curr_weight, target_weight, next_weight);
4409#endif
4410
4411 if(Overflow_Error == TRUE)
4412 {
4413 /*
4414 ivString(next_weight, "omega");
4415 PrintS("\n// ** The weight vector does NOT stay in Cone!!\n");
4416 */
4417#ifdef TEST_OVERFLOW
4418 goto TEST_OVERFLOW_OI;
4419#endif
4420
4421 newRing = currRing;
4422 if (rParameter(currRing) != NULL)
4423 {
4424 DefRingPar(target_weight);
4425 }
4426 else
4427 {
4428 rChangeCurrRing(VMrDefault(target_weight)); // Aenderung
4429 }
4430 F1 = idrMoveR(G, newRing,currRing);
4431 G = MstdCC(F1);
4432 idDelete(&F1);
4433 newRing = currRing;
4434 break;
4435 }
4436
4437 if(MivComp(next_weight, ivNull) == 1)
4438 {
4439 newRing = currRing;
4440 delete next_weight;
4441 break;
4442 }
4443
4444 if(MivComp(next_weight, target_weight) == 1)
4445 {
4446 if(MivSame(target_weight, exivlp)==1)
4447 {
4448 // LAST_GB_ALT2:
4449 //nOverflow_Error = Overflow_Error;
4450#ifdef TIME_TEST
4451 tproc = clock()-xftinput;
4452#endif
4453 //Print("\n// takes %d steps and calls the recursion of level 2:", nwalk);
4454 /* call the changed perturbation walk algorithm with degree 2 */
4455 G = Rec_LastGB(G, curr_weight, target_weight, 2,1);
4456 newRing = currRing;
4457 delete next_weight;
4458 break;
4459 }
4460 endwalks = 1;
4461 }
4462
4463 for(i=nV-1; i>=0; i--)
4464 {
4465 //(*extra_curr_weight)[i] = (*curr_weight)[i];
4466 (*curr_weight)[i] = (*next_weight)[i];
4467 }
4468 delete next_weight;
4469 }
4470#ifdef TEST_OVERFLOW
4471 TEST_OVERFLOW_OI:
4472#endif
4473 rChangeCurrRing(XXRing);
4474 G = idrMoveR(G, newRing,currRing);
4475 delete ivNull;
4476 delete exivlp;
4477
4478#ifdef TIME_TEST
4479 /*Print("\n// \"Main procedure\" took %d steps dnd %.2f sec. Overflow_Error (%d)",
4480 nwalk, ((double) tproc)/1000000, nOverflow_Error);
4481*/
4482 TimeStringFractal(xftinput, tostd, xtif, xtstd, xtextra,xtlift, xtred,xtnw);
4483
4484 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
4485 //Print("\n// Overflow_Error? (%d)", nOverflow_Error);
4486 //Print("\n// Awalk2 took %d steps!!", nstep);
4487#endif
4488
4489 return(G);
4490}
static ideal Rec_LastGB(ideal G, intvec *curr_weight, intvec *orig_target_weight, int tp_deg, int npwinc)
Definition: walk.cc:3933

◆ maxlengthpoly()

static int maxlengthpoly ( ideal  G)
static

Definition at line 3460 of file walk.cc.

3461{
3462 int i,k,length=0;
3463 for(i=IDELEMS(G)-1; i>=0; i--)
3464 {
3465 k = pLength(G->m[i]);
3466 if(k>length)
3467 {
3468 length = k;
3469 }
3470 }
3471 return length;
3472}
int k
Definition: cfEzgcd.cc:99
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
static int pLength(poly a)
Definition: p_polys.h:188

◆ MExpPol()

static intvec * MExpPol ( poly  f)
static

Definition at line 877 of file walk.cc.

878{
879 int i, nR = currRing->N;
880 intvec* result = new intvec(nR);
881
882 for(i=nR-1; i>=0; i--)
883 {
884 (*result)[i] = pGetExp(f,i+1);
885 }
886 return result;
887}
FILE * f
Definition: checklibs.c:9
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41

◆ Mfpertvector()

intvec * Mfpertvector ( ideal  G,
intvec ivtarget 
)

Definition at line 1512 of file walk.cc.

1513{
1514 int i, j, nG = IDELEMS(G);
1515 int nV = currRing->N;
1516 int niv = nV*nV;
1517
1518
1519 // Calculate maxA = Max(A2) + Max(A3) + ... + Max(AnV),
1520 // where the Ai are the i-te rows of the matrix 'targer_ord'.
1521 int ntemp, maxAi, maxA=0;
1522 for(i=1; i<nV; i++)
1523 {
1524 maxAi = (*ivtarget)[i*nV];
1525 if(maxAi<0)
1526 {
1527 maxAi = -maxAi;
1528 }
1529 for(j=i*nV+1; j<(i+1)*nV; j++)
1530 {
1531 ntemp = (*ivtarget)[j];
1532 if(ntemp < 0)
1533 {
1534 ntemp = -ntemp;
1535 }
1536 if(ntemp > maxAi)
1537 {
1538 maxAi = ntemp;
1539 }
1540 }
1541 maxA = maxA + maxAi;
1542 }
1543 intvec* ivUnit = Mivdp(nV);
1544
1545 // Calculate inveps = 1/eps, where 1/eps > deg(p)*maxA for all p in G.
1546 mpz_t tot_deg; mpz_init(tot_deg);
1547 mpz_t maxdeg; mpz_init(maxdeg);
1548 mpz_t inveps; mpz_init(inveps);
1549
1550
1551 for(i=nG-1; i>=0; i--)
1552 {
1553 mpz_set_ui(maxdeg, MwalkWeightDegree(G->m[i], ivUnit));
1554 if (mpz_cmp(maxdeg, tot_deg) > 0 )
1555 {
1556 mpz_set(tot_deg, maxdeg);
1557 }
1558 }
1559
1560 delete ivUnit;
1561 //inveps = (tot_deg * maxA) + 1;
1562 mpz_mul_ui(inveps, tot_deg, maxA);
1563 mpz_add_ui(inveps, inveps, 1);
1564
1565 // takes "small" inveps
1566#ifdef INVEPS_SMALL_IN_FRACTAL
1567 if(mpz_cmp_ui(inveps, nV)>0 && nV > 3)
1568 {
1569 mpz_cdiv_q_ui(inveps, inveps, nV);
1570 }
1571 // choose the small inverse epsilon
1572#endif
1573
1574 // PrintLn(); mpz_out_str(stdout, 10, inveps);
1575
1576 // Calculate the perturbed target orders:
1577 mpz_t *ivtemp=(mpz_t *)omAlloc(nV*sizeof(mpz_t));
1578 mpz_t *pert_vector=(mpz_t *)omAlloc(niv*sizeof(mpz_t));
1579
1580 for(i=0; i < nV; i++)
1581 {
1582 mpz_init_set_si(ivtemp[i], (*ivtarget)[i]);
1583 mpz_init_set_si(pert_vector[i], (*ivtarget)[i]);
1584 }
1585
1586 mpz_t ztmp; mpz_init(ztmp);
1587 // BOOLEAN isneg = FALSE;
1588
1589 for(i=1; i<nV; i++)
1590 {
1591 for(j=0; j<nV; j++)
1592 {
1593 mpz_mul(ztmp, inveps, ivtemp[j]);
1594 if((*ivtarget)[i*nV+j]<0)
1595 {
1596 mpz_sub_ui(ivtemp[j], ztmp, -(*ivtarget)[i*nV+j]);
1597 }
1598 else
1599 {
1600 mpz_add_ui(ivtemp[j], ztmp,(*ivtarget)[i*nV+j]);
1601 }
1602 }
1603
1604 for(j=0; j<nV; j++)
1605 {
1606 mpz_init_set(pert_vector[i*nV+j],ivtemp[j]);
1607 }
1608 }
1609
1610 // 2147483647 is max. integer representation in SINGULAR
1611 mpz_t sing_int;
1612 mpz_init_set_ui(sing_int, 2147483647);
1613
1614 intvec* result = new intvec(niv);
1615 BOOLEAN nflow = FALSE;
1616
1617 // computes gcd
1618 mpz_set(ztmp, pert_vector[0]);
1619 for(i=0; i<niv; i++)
1620 {
1621 mpz_gcd(ztmp, ztmp, pert_vector[i]);
1622 if(mpz_cmp_si(ztmp, 1)==0)
1623 {
1624 break;
1625 }
1626 }
1627
1628 for(i=0; i<niv; i++)
1629 {
1630 mpz_divexact(pert_vector[i], pert_vector[i], ztmp);
1631 (* result)[i] = mpz_get_si(pert_vector[i]);
1632 }
1633
1634 //CHECK_OVERFLOW:
1635
1636 for(i=0; i<niv; i++)
1637 {
1638 if(mpz_cmp(pert_vector[i], sing_int)>0)
1639 {
1640 if(nflow == FALSE)
1641 {
1642 Xnlev = i / nV;
1643 nflow = TRUE;
1645 Print("\n// Xlev = %d and the %d-th element is", Xnlev, i+1);
1646 PrintS("\n// ** OVERFLOW in \"Mfpertvector\": ");
1647 mpz_out_str( stdout, 10, pert_vector[i]);
1648 PrintS(" is greater than 2147483647 (max. integer representation)");
1649 Print("\n// So vector[%d] := %d is wrong!!", i+1, (*result)[i]);
1650 }
1651 }
1652 }
1653 if(Overflow_Error == TRUE)
1654 {
1655 ivString(result, "new_vector");
1656 }
1657 omFree(pert_vector);
1658 omFree(ivtemp);
1659 mpz_clear(ztmp);
1660 mpz_clear(tot_deg);
1661 mpz_clear(maxdeg);
1662 mpz_clear(inveps);
1663 mpz_clear(sing_int);
1664
1666 for(j=0; j<IDELEMS(G); j++)
1667 {
1668 poly p=G->m[j];
1669 while(p!=NULL)
1670 {
1671 p_Setm(p,currRing);
1672 pIter(p);
1673 }
1674 }
1675 return result;
1676}
int p
Definition: cfModGcd.cc:4078
#define pIter(p)
Definition: monomials.h:37
#define omFree(addr)
Definition: omAllocDecl.h:261
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
void PrintS(const char *s)
Definition: reporter.cc:284
static void ivString(intvec *iv, const char *ch)
Definition: walk.cc:492
VAR int Xnlev
Definition: walk.cc:1511
static int MwalkWeightDegree(poly p, intvec *weight_vector)
Definition: walk.cc:668
intvec * Mivdp(int nR)
Definition: walk.cc:1007

◆ Mfrwalk()

ideal Mfrwalk ( ideal  G,
intvec ivstart,
intvec ivtarget,
int  weight_rad,
int  reduction,
int  printout 
)

Definition at line 8212 of file walk.cc.

8214{
8215 BITSET save1 = si_opt_1; // save current options
8216 //check that weight radius is valid
8217 if(weight_rad < 0)
8218 {
8219 WerrorS("Invalid radius.\n");
8220 return NULL;
8221 }
8222 if(reduction == 0)
8223 {
8224 si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
8225 si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
8226 }
8229 //Print("// pSetm_Error = (%d)", ErrorCheck());
8230 //Print("\n// ring ro = %s;", rString(currRing));
8231
8232 nnflow = 0;
8233 Xngleich = 0;
8234 Xcall = 0;
8235#ifdef TIME_TEST
8236 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0; xtextra=0;
8237 xftinput = clock();
8238#endif
8239 ring oldRing = currRing;
8240 int i, nV = currRing->N;
8241 XivNull = new intvec(nV);
8242 Xivinput = ivtarget;
8243 ngleich = 0;
8244#ifdef TIME_TEST
8245 to=clock();
8246#endif
8247 ideal I = MstdCC(G);
8248 G = NULL;
8249#ifdef TIME_TEST
8250 xftostd=clock()-to;
8251#endif
8252 Xsigma = ivstart;
8253
8254 Xnlev=nV;
8255
8256#ifdef FIRST_STEP_FRACTAL
8257 ideal Gw = MwalkInitialForm(I, ivstart);
8258 for(i=IDELEMS(Gw)-1; i>=0; i--)
8259 {
8260 if((Gw->m[i]!=NULL) // len >=0
8261 && (Gw->m[i]->next!=NULL) // len >=1
8262 && (Gw->m[i]->next->next!=NULL)) // len >=2
8263 {
8264 intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
8265 intvec* Mdp;
8266 if(ivstart->length() == nV)
8267 {
8268 if(MivSame(ivstart, iv_dp) != 1)
8269 Mdp = MivWeightOrderdp(ivstart);
8270 else
8271 Mdp = MivMatrixOrderdp(nV);
8272 }
8273 else
8274 {
8275 Mdp = ivstart;
8276 }
8277
8278 Xsigma = Mfpertvector(I, Mdp);
8280
8281 delete Mdp;
8282 delete iv_dp;
8283 break;
8284 }
8285 }
8286 idDelete(&Gw);
8287#endif
8288
8289 ideal I1;
8290 intvec* Mlp;
8291 Xivlp = Mivlp(nV);
8292
8293 if(ivtarget->length() == nV)
8294 {
8295 if(MivComp(ivtarget, Xivlp) != 1)
8296 {
8297 if (rParameter(currRing) != NULL)
8298 DefRingPar(ivtarget);
8299 else
8300 rChangeCurrRing(VMrDefault(ivtarget));
8301
8302 I1 = idrMoveR(I, oldRing,currRing);
8303 Mlp = MivWeightOrderlp(ivtarget);
8304 Xtau = Mfpertvector(I1, Mlp);
8305 }
8306 else
8307 {
8308 if (rParameter(currRing) != NULL)
8309 DefRingParlp();
8310 else
8311 VMrDefaultlp();
8312
8313 I1 = idrMoveR(I, oldRing,currRing);
8314 Mlp = MivMatrixOrderlp(nV);
8315 Xtau = Mfpertvector(I1, Mlp);
8316 }
8317 }
8318 else
8319 {
8320 rChangeCurrRing(VMatrDefault(ivtarget));
8321 I1 = idrMoveR(I,oldRing,currRing);
8322 Mlp = ivtarget;
8323 Xtau = Mfpertvector(I1, Mlp);
8324 }
8325 delete Mlp;
8327
8328 //ivString(Xsigma, "Xsigma");
8329 //ivString(Xtau, "Xtau");
8330
8331 id_Delete(&I, oldRing);
8332 ring tRing = currRing;
8333 if(ivtarget->length() == nV)
8334 {
8335/*
8336 if (rParameter(currRing) != NULL)
8337 DefRingPar(ivstart);
8338 else
8339 rChangeCurrRing(VMrDefault(ivstart));
8340*/
8341 rChangeCurrRing(VMrRefine(ivtarget,ivstart));
8342 }
8343 else
8344 {
8345 //rChangeCurrRing(VMatrDefault(ivstart));
8346 rChangeCurrRing(VMatrRefine(ivtarget,ivstart));
8347 }
8348
8349 I = idrMoveR(I1,tRing,currRing);
8350#ifdef TIME_TEST
8351 to=clock();
8352#endif
8353 ideal J = MstdCC(I);
8354 idDelete(&I);
8355#ifdef TIME_TEST
8356 xftostd=xftostd+clock()-to;
8357#endif
8358 ideal resF;
8359 ring helpRing = currRing;
8360
8361 J = rec_r_fractal_call(J,1,ivtarget,weight_rad,reduction,printout);
8362 //idString(J,"//*** Mfrwalk: J");
8363 //Print("\n//** Mfrwalk hier (1)\n");
8364 rChangeCurrRing(oldRing);
8365 //Print("\n//** Mfrwalk hier (2)\n");
8366 resF = idrMoveR(J, helpRing,currRing);
8367 //Print("\n//** Mfrwalk hier (3)\n");
8368 //idSkipZeroes(resF);
8369 //Print("\n//** Mfrwalk hier (4)\n");
8370 si_opt_1 = save1; //set original options, e. g. option(RedSB)
8371 delete Xivlp;
8372 //delete Xsigma;
8373 delete Xtau;
8374 delete XivNull;
8375 //Print("\n//** Mfrwalk hier (5)\n");
8376#ifdef TIME_TEST
8377 TimeStringFractal(xftinput, xftostd, xtif, xtstd, xtextra,
8378 xtlift, xtred, xtnw);
8379
8380
8381 // Print("\n// pSetm_Error = (%d)", ErrorCheck());
8382 Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
8383 Print("\n// the numbers of Overflow_Error (%d)", nnflow);
8384#endif
8385 //Print("\n//** Mfrwalk hier (6)\n");
8386 //idString(resF,"resF");
8387 //Print("\n//** Mfrwalk hier (7)\n");
8388 return(resF);
8389}
void reduction(LList *sPolyList, CListOld *critPairs, LList *gPrev, RList *rules, LTagList *lTag, RTagList *rTag, ideal gbPrev, PList *rejectedGBList, int plus)
Definition: f5gb.cc:1089
void WerrorS(const char *s)
Definition: feFopen.cc:24
VAR unsigned si_opt_1
Definition: options.c:5
#define OPT_REDTAIL
Definition: options.h:92
#define OPT_REDSB
Definition: options.h:77
#define BITSET
Definition: structs.h:16
intvec * MivWeightOrderdp(intvec *ivstart)
Definition: walk.cc:1456
VAR intvec * Xtau
Definition: walk.cc:4507
static ring VMrRefine(intvec *va, intvec *vb)
Definition: walk.cc:2731
static ideal rec_r_fractal_call(ideal G, int nlev, intvec *ivtarget, int weight_rad, int reduction, int printout)
Definition: walk.cc:7453
VAR intvec * Xivlp
Definition: walk.cc:4510
intvec * MivWeightOrderlp(intvec *ivstart)
Definition: walk.cc:1436
VAR intvec * XivNull
Definition: walk.cc:6927
VAR int Xcall
Definition: walk.cc:6945
static ring VMatrRefine(intvec *va, intvec *vb)
Definition: walk.cc:2841
VAR intvec * Xivinput
Definition: walk.cc:4509
VAR intvec * Xsigma
Definition: walk.cc:4506
VAR int ngleich
Definition: walk.cc:4505
intvec * Mfpertvector(ideal G, intvec *ivtarget)
Definition: walk.cc:1512
static ring VMatrDefault(intvec *va)
Definition: walk.cc:2790
VAR int nnflow
Definition: walk.cc:6944
VAR int Xngleich
Definition: walk.cc:6946

◆ Mfwalk()

ideal Mfwalk ( ideal  G,
intvec ivstart,
intvec ivtarget,
int  reduction,
int  printout 
)

Definition at line 8031 of file walk.cc.

8033{
8034 BITSET save1 = si_opt_1; // save current options
8035 if(reduction == 0)
8036 {
8037 si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
8038 //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
8039 }
8042 //Print("// pSetm_Error = (%d)", ErrorCheck());
8043 //Print("\n// ring ro = %s;", rString(currRing));
8044
8045 nnflow = 0;
8046 Xngleich = 0;
8047 Xcall = 0;
8048#ifdef TIME_TEST
8049 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0; xtextra=0;
8050 xftinput = clock();
8051#endif
8052 ring oldRing = currRing;
8053 int i, nV = currRing->N;
8054 XivNull = new intvec(nV);
8055 Xivinput = ivtarget;
8056 ngleich = 0;
8057#ifdef TIME_TEST
8058 to=clock();
8059#endif
8060 ideal I = MstdCC(G);
8061 G = NULL;
8062#ifdef TIME_TEST
8063 xftostd=clock()-to;
8064#endif
8065 Xsigma = ivstart;
8066
8067 Xnlev=nV;
8068
8069#ifdef FIRST_STEP_FRACTAL
8070 ideal Gw = MwalkInitialForm(I, ivstart);
8071 for(i=IDELEMS(Gw)-1; i>=0; i--)
8072 {
8073 if((Gw->m[i]!=NULL) // len >=0
8074 && (Gw->m[i]->next!=NULL) // len >=1
8075 && (Gw->m[i]->next->next!=NULL)) // len >=2
8076 {
8077 intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
8078 intvec* Mdp;
8079 if(ivstart->length() == nV)
8080 {
8081 if(MivSame(ivstart, iv_dp) != 1)
8082 Mdp = MivWeightOrderdp(ivstart);
8083 else
8084 Mdp = MivMatrixOrderdp(nV);
8085 }
8086 else
8087 {
8088 Mdp = ivstart;
8089 }
8090
8091 Xsigma = Mfpertvector(I, Mdp);
8093
8094 delete Mdp;
8095 delete iv_dp;
8096 break;
8097 }
8098 }
8099 idDelete(&Gw);
8100#endif
8101
8102 ideal I1;
8103 intvec* Mlp;
8104 Xivlp = Mivlp(nV);
8105
8106 if(ivtarget->length() == nV)
8107 {
8108 if(MivComp(ivtarget, Xivlp) != 1)
8109 {
8110 if (rParameter(currRing) != NULL)
8111 DefRingPar(ivtarget);
8112 else
8113 rChangeCurrRing(VMrDefault(ivtarget));
8114
8115 I1 = idrMoveR(I, oldRing,currRing);
8116 Mlp = MivWeightOrderlp(ivtarget);
8117 Xtau = Mfpertvector(I1, Mlp);
8118 }
8119 else
8120 {
8121 if (rParameter(currRing) != NULL)
8122 DefRingParlp();
8123 else
8124 VMrDefaultlp();
8125
8126 I1 = idrMoveR(I, oldRing,currRing);
8127 Mlp = MivMatrixOrderlp(nV);
8128 Xtau = Mfpertvector(I1, Mlp);
8129 }
8130 }
8131 else
8132 {
8133 rChangeCurrRing(VMatrDefault(ivtarget));
8134 I1 = idrMoveR(I,oldRing,currRing);
8135 Mlp = ivtarget;
8136 Xtau = Mfpertvector(I1, Mlp);
8137 }
8138 delete Mlp;
8140
8141 //ivString(Xsigma, "Xsigma");
8142 //ivString(Xtau, "Xtau");
8143
8144 id_Delete(&I, oldRing);
8145 ring tRing = currRing;
8146 if(ivtarget->length() == nV)
8147 {
8148/*
8149 if (rParameter(currRing) != NULL)
8150 DefRingPar(ivstart);
8151 else
8152 rChangeCurrRing(VMrDefault(ivstart));
8153*/
8154 rChangeCurrRing(VMrRefine(ivtarget,ivstart));
8155 }
8156 else
8157 {
8158 //rChangeCurrRing(VMatrDefault(ivstart));
8159 rChangeCurrRing(VMatrRefine(ivtarget,ivstart));
8160 }
8161
8162 I = idrMoveR(I1,tRing,currRing);
8163#ifdef TIME_TEST
8164 to=clock();
8165#endif
8166 ideal J = MstdCC(I);
8167 idDelete(&I);
8168#ifdef TIME_TEST
8169 xftostd=xftostd+clock()-to;
8170#endif
8171 ideal resF;
8172 ring helpRing = currRing;
8173
8174 J = rec_fractal_call(J,1,ivtarget,reduction,printout);
8175 //idString(J,"//** Mfwalk: J");
8176 rChangeCurrRing(oldRing);
8177 //Print("\n//Mfwalk: (2)\n");
8178 resF = idrMoveR(J, helpRing,currRing);
8179 //Print("\n//Mfwalk: (3)\n");
8180 idSkipZeroes(resF);
8181 //Print("\n//Mfwalk: (4)\n");
8182
8183 si_opt_1 = save1; //set original options, e. g. option(RedSB)
8184 delete Xivlp;
8185 //delete Xsigma;
8186 delete Xtau;
8187 delete XivNull;
8188 //Print("\n//Mfwalk: (5)\n");
8189#ifdef TIME_TEST
8190 TimeStringFractal(xftinput, xftostd, xtif, xtstd, xtextra,
8191 xtlift, xtred, xtnw);
8192
8193
8194 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
8195 Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
8196 Print("\n// the numbers of Overflow_Error (%d)", nnflow);
8197#endif
8198 //Print("\n//Mfwalk: (6)\n");
8199 //idString(resF,"//** Mfwalk: resF");
8200 return(idCopy(resF));
8201}
ideal idCopy(ideal A)
Definition: ideals.h:60
static ideal rec_fractal_call(ideal G, int nlev, intvec *ivtarget, int reduction, int printout)
Definition: walk.cc:6951

◆ middleOfCone()

static ideal middleOfCone ( ideal  G,
ideal  Gomega 
)
static

Definition at line 3079 of file walk.cc.

3080{
3081 BOOLEAN middle = FALSE;
3082 int i,j,N = IDELEMS(Gomega);
3083 poly p,lm,factor1,factor2;
3084
3085 ideal Go = idCopy(G);
3086
3087 // check whether leading monomials of G and Gomega coincide
3088 // and return NULL if not
3089 for(i=0; i<N; i++)
3090 {
3091 if(!pIsConstant(pSub(pCopy(Gomega->m[i]),pCopy(pHead(G->m[i])))))
3092 {
3093 idDelete(&Go);
3094 return NULL;
3095 }
3096 }
3097 for(i=0; i<N; i++)
3098 {
3099 for(j=0; j<N; j++)
3100 {
3101 if(i!=j)
3102 {
3103 p = pCopy(Gomega->m[i]);
3104 lm = pCopy(Gomega->m[j]);
3105 pIter(p);
3106 while(p!=NULL)
3107 {
3108 if(pDivisibleBy(lm,p))
3109 {
3110 if(middle == FALSE)
3111 {
3112 middle = TRUE;
3113 }
3114 factor1 = singclap_pdivide(pHead(p),lm,currRing);
3115 factor2 = pMult(pCopy(factor1),pCopy(Go->m[j]));
3116 pDelete(&factor1);
3117 Go->m[i] = pAdd((Go->m[i]),pNeg(pCopy(factor2)));
3118 pDelete(&factor2);
3119 }
3120 pIter(p);
3121 }
3122 pDelete(&lm);
3123 pDelete(&p);
3124 }
3125 }
3126 }
3127
3128 if(middle == TRUE)
3129 {
3130 return Go;
3131 }
3132 idDelete(&Go);
3133 return NULL;
3134}
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
poly singclap_pdivide(poly f, poly g, const ring r)
Definition: clapsing.cc:624
#define pAdd(p, q)
Definition: polys.h:203
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:238
#define pNeg(p)
Definition: polys.h:198
#define pSub(a, b)
Definition: polys.h:287
#define pMult(p, q)
Definition: polys.h:207
#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

◆ MidMult()

static ideal MidMult ( ideal  A,
ideal  B 
)
static

Definition at line 1683 of file walk.cc.

1684{
1685 int mA = IDELEMS(A), mB = IDELEMS(B);
1686
1687 if(A==NULL || B==NULL)
1688 {
1689 return NULL;
1690 }
1691 if(mB < mA)
1692 {
1693 mA = mB;
1694 }
1695 ideal result = idInit(mA, 1);
1696
1697 int i, k=0;
1698 for(i=0; i<mA; i++)
1699 {
1700 result->m[k] = pMult(A->m[i], pCopy(B->m[i]));
1701 A->m[i]=NULL;
1702 if (result->m[k]!=NULL)
1703 {
1704 k++;
1705 }
1706 }
1707
1708 idDelete(&A);
1710 return result;
1711}
b *CanonicalForm B
Definition: facBivar.cc:52
#define A
Definition: sirandom.c:24

◆ MivAbsMax()

static int MivAbsMax ( intvec vec)
static

Definition at line 1815 of file walk.cc.

1816{
1817 int i,k;
1818 if((*vec)[0] < 0)
1819 {
1820 k = -(*vec)[0];
1821 }
1822 else
1823 {
1824 k = (*vec)[0];
1825 }
1826 for(i=1; i < (vec->length()); i++)
1827 {
1828 if((*vec)[i] < 0)
1829 {
1830 if(-(*vec)[i] > k)
1831 {
1832 k = -(*vec)[i];
1833 }
1834 }
1835 else
1836 {
1837 if((*vec)[i] > k)
1838 {
1839 k = (*vec)[i];
1840 }
1841 }
1842 }
1843 return k;
1844}
fq_nmod_poly_t * vec
Definition: facHensel.cc:108

◆ MivAbsMaxArg()

static int MivAbsMaxArg ( intvec vec)
static

Definition at line 1850 of file walk.cc.

1851{
1852 int k = MivAbsMax(vec);
1853 int i=0;
1854 while(1)
1855 {
1856 if((*vec)[i] == k || (*vec)[i] == -k)
1857 {
1858 break;
1859 }
1860 i++;
1861 }
1862 return i;
1863}
static int MivAbsMax(intvec *vec)
Definition: walk.cc:1815

◆ MivComp()

static int MivComp ( intvec iva,
intvec ivb 
)
inlinestatic

Definition at line 1798 of file walk.cc.

1799{
1800 assume(iva->length() == ivb->length());
1801 int i;
1802 for(i=iva->length()-1; i>=0; i--)
1803 {
1804 if((*iva)[i] - (*ivb)[i] != 0)
1805 {
1806 return 0;
1807 }
1808 }
1809 return 1;
1810}

◆ MivDotProduct()

static long MivDotProduct ( intvec a,
intvec b 
)
inlinestatic

Definition at line 845 of file walk.cc.

846{
847 assume( a->length() == b->length());
848 int i, n = a->length();
849 long result = 0;
850
851 for(i=n-1; i>=0; i--)
852 {
853 result += (*a)[i] * (*b)[i];
854 }
855 return result;
856}

◆ Mivdp()

intvec * Mivdp ( int  nR)

Definition at line 1007 of file walk.cc.

1008{
1009 int i;
1010 intvec* ivm = new intvec(nR);
1011
1012 for(i=nR-1; i>=0; i--)
1013 {
1014 (*ivm)[i] = 1;
1015 }
1016 return ivm;
1017}

◆ Mivlp()

intvec * Mivlp ( int  nR)

Definition at line 1022 of file walk.cc.

1023{
1024 intvec* ivm = new intvec(nR);
1025 (*ivm)[0] = 1;
1026
1027 return ivm;
1028}

◆ MivMatrixOrder()

intvec * MivMatrixOrder ( intvec iv)

Definition at line 963 of file walk.cc.

964{
965 int i, nR = iv->length();
966
967 intvec* ivm = new intvec(nR*nR);
968
969 for(i=0; i<nR; i++)
970 {
971 (*ivm)[i] = (*iv)[i];
972 }
973 for(i=1; i<nR; i++)
974 {
975 (*ivm)[i*nR+i-1] = 1;
976 }
977 return ivm;
978}

◆ MivMatrixOrderdp()

intvec * MivMatrixOrderdp ( int  nV)

Definition at line 1417 of file walk.cc.

1418{
1419 int i;
1420 intvec* ivM = new intvec(nV*nV);
1421
1422 for(i=0; i<nV; i++)
1423 {
1424 (*ivM)[i] = 1;
1425 }
1426 for(i=1; i<nV; i++)
1427 {
1428 (*ivM)[(i+1)*nV - i] = -1;
1429 }
1430 return(ivM);
1431}

◆ MivMatrixOrderlp()

intvec * MivMatrixOrderlp ( int  nV)

Definition at line 1401 of file walk.cc.

1402{
1403 int i;
1404 intvec* ivM = new intvec(nV*nV);
1405
1406 for(i=0; i<nV; i++)
1407 {
1408 (*ivM)[i*nV + i] = 1;
1409 }
1410 return(ivM);
1411}

◆ MivMatrixOrderRefine()

intvec * MivMatrixOrderRefine ( intvec iv,
intvec iw 
)

Definition at line 983 of file walk.cc.

984{
985 assume((iv->length())*(iv->length()) == iw->length());
986 int i,j, nR = iv->length();
987
988 intvec* ivm = new intvec(nR*nR);
989
990 for(i=0; i<nR; i++)
991 {
992 (*ivm)[i] = (*iv)[i];
993 }
994 for(i=1; i<nR; i++)
995 {
996 for(j=0; j<nR; j++)
997 {
998 (*ivm)[j+i*nR] = (*iw)[j+i*nR];
999 }
1000 }
1001 return ivm;
1002}

◆ MivSame()

int MivSame ( intvec u,
intvec v 
)

Definition at line 893 of file walk.cc.

894{
895 assume(u->length() == v->length());
896
897 int i, niv = u->length();
898
899 for (i=0; i<niv; i++)
900 {
901 if ((*u)[i] != (*v)[i])
902 {
903 return 0;
904 }
905 }
906 return 1;
907}

◆ MivSub()

static intvec * MivSub ( intvec a,
intvec b 
)
static

Definition at line 861 of file walk.cc.

862{
863 assume( a->length() == b->length());
864 int i, n = a->length();
865 intvec* result = new intvec(n);
866
867 for(i=n-1; i>=0; i--)
868 {
869 (*result)[i] = (*a)[i] - (*b)[i];
870 }
871 return result;
872}

◆ MivUnit()

intvec * MivUnit ( int  nV)

Definition at line 1496 of file walk.cc.

1497{
1498 int i;
1499 intvec* ivM = new intvec(nV);
1500 for(i=nV-1; i>=0; i--)
1501 {
1502 (*ivM)[i] = 1;
1503 }
1504 return(ivM);
1505}

◆ MivWeightOrderdp()

intvec * MivWeightOrderdp ( intvec ivstart)

Definition at line 1456 of file walk.cc.

1457{
1458 int i;
1459 int nV = ivstart->length();
1460 intvec* ivM = new intvec(nV*nV);
1461
1462 for(i=0; i<nV; i++)
1463 {
1464 (*ivM)[i] = (*ivstart)[i];
1465 }
1466 for(i=0; i<nV; i++)
1467 {
1468 (*ivM)[nV+i] = 1;
1469 }
1470 for(i=2; i<nV; i++)
1471 {
1472 (*ivM)[(i+1)*nV - i] = -1;
1473 }
1474 return(ivM);
1475}

◆ MivWeightOrderlp()

intvec * MivWeightOrderlp ( intvec ivstart)

Definition at line 1436 of file walk.cc.

1437{
1438 int i;
1439 int nV = ivstart->length();
1440 intvec* ivM = new intvec(nV*nV);
1441
1442 for(i=0; i<nV; i++)
1443 {
1444 (*ivM)[i] = (*ivstart)[i];
1445 }
1446 for(i=1; i<nV; i++)
1447 {
1448 (*ivM)[i*nV + i-1] = 1;
1449 }
1450 return(ivM);
1451}

◆ MkInterRedNextWeight()

intvec * MkInterRedNextWeight ( intvec iva,
intvec ivb,
ideal  G 
)

Definition at line 2570 of file walk.cc.

2571{
2572 intvec* tmp = new intvec(iva->length());
2573 intvec* result;
2574
2575 if(G == NULL)
2576 {
2577 return tmp;
2578 }
2579 if(MivComp(iva, ivb) == 1)
2580 {
2581 return tmp;
2582 }
2583 result = MwalkNextWeightCC(iva, ivb, G);
2584
2585 if(MivComp(result, iva) == 1)
2586 {
2587 delete result;
2588 return tmp;
2589 }
2590
2591 delete tmp;
2592 return result;
2593}
static intvec * MwalkNextWeightCC(intvec *curr_weight, intvec *target_weight, ideal G)
Definition: walk.cc:2228

◆ Mlcm()

static long Mlcm ( long &  i1,
long &  i2 
)
inlinestatic

Definition at line 835 of file walk.cc.

836{
837 long temp = gcd(i1, i2);
838 return ((i1 / temp)* i2);
839}
static long gcd(const long a, const long b)
Definition: walk.cc:532

◆ MLifttwoIdeal()

static ideal MLifttwoIdeal ( ideal  Gw,
ideal  M,
ideal  G 
)
static

Definition at line 1721 of file walk.cc.

1722{
1723 ideal Mtmp = idLift(Gw, M, NULL, FALSE, TRUE, TRUE, NULL);
1724
1725 // If Gw is a GB, then isSB = TRUE, otherwise FALSE
1726 // So, it is better, if one tests whether Gw is a GB
1727 // in ideals.cc:
1728 // idLift (ideal mod, ideal submod,ideal * rest, BOOLEAN goodShape,
1729 // BOOLEAN isSB,BOOLEAN divide,matrix * unit)
1730
1731 // Let be Mtmp = {m1,...,ms}, where mi=sum hij.in_gj, for all i=1,...,s
1732 // We compute F = {f1,...,fs}, where fi=sum hij.gj
1733 int i, j, nM = IDELEMS(Mtmp);
1734 ideal idpol, idLG;
1735 ideal F = idInit(nM, 1);
1736
1737 for(i=0; i<nM; i++)
1738 {
1739 idpol = idVec2Ideal(Mtmp->m[i]);
1740 idLG = MidMult(idpol, G);
1741 idpol = NULL;
1742 F->m[i] = NULL;
1743 for(j=IDELEMS(idLG)-1; j>=0; j--)
1744 {
1745 F->m[i] = pAdd(F->m[i], idLG->m[j]);
1746 idLG->m[j]=NULL;
1747 }
1748 idDelete(&idLG);
1749 }
1750 idDelete(&Mtmp);
1751 return F;
1752}
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = M...
Definition: ideals.cc:1105
static ideal idVec2Ideal(poly vec)
Definition: ideals.h:169
static ideal MidMult(ideal A, ideal B)
Definition: walk.cc:1683

◆ MLmWeightedDegree()

static int MLmWeightedDegree ( const poly  p,
intvec weight 
)
inlinestatic

Definition at line 621 of file walk.cc.

622{
623 /* 2147483647 is max. integer representation in SINGULAR */
624 mpz_t sing_int;
625 mpz_init_set_ui(sing_int, 2147483647);
626
627 int i, wgrad;
628
629 mpz_t zmul;
630 mpz_init(zmul);
631 mpz_t zvec;
632 mpz_init(zvec);
633 mpz_t zsum;
634 mpz_init(zsum);
635
636 for (i=currRing->N; i>0; i--)
637 {
638 mpz_set_si(zvec, (*weight)[i-1]);
639 mpz_mul_ui(zmul, zvec, pGetExp(p, i));
640 mpz_add(zsum, zsum, zmul);
641 }
642
643 wgrad = mpz_get_ui(zsum);
644
645 if(mpz_cmp(zsum, sing_int)>0)
646 {
647 if(Overflow_Error == FALSE)
648 {
649 PrintLn();
650 PrintS("\n// ** OVERFLOW in \"MwalkInitialForm\": ");
651 mpz_out_str( stdout, 10, zsum);
652 PrintS(" is greater than 2147483647 (max. integer representation)");
654 }
655 }
656
657 mpz_clear(zmul);
658 mpz_clear(zvec);
659 mpz_clear(zsum);
660 mpz_clear(sing_int);
661
662 return wgrad;
663}
void PrintLn()
Definition: reporter.cc:310

◆ MLmWeightedDegree_gmp()

static void MLmWeightedDegree_gmp ( mpz_t  result,
const poly  p,
intvec weight 
)
static

Definition at line 690 of file walk.cc.

691{
692 /* 2147483647 is max. integer representation in SINGULAR */
693 mpz_t sing_int;
694 mpz_init_set_ui(sing_int, 2147483647);
695
696 int i;
697
698 mpz_t zmul;
699 mpz_init(zmul);
700 mpz_t zvec;
701 mpz_init(zvec);
702 mpz_t ztmp;
703 mpz_init(ztmp);
704
705 for (i=currRing->N; i>0; i--)
706 {
707 mpz_set_si(zvec, (*weight)[i-1]);
708 mpz_mul_ui(zmul, zvec, pGetExp(p, i));
709 mpz_add(ztmp, ztmp, zmul);
710 }
711 mpz_init_set(result, ztmp);
712 mpz_clear(ztmp);
713 mpz_clear(sing_int);
714 mpz_clear(zvec);
715 mpz_clear(zmul);
716}

◆ MMatrixone()

intvec * MMatrixone ( int  nV)

Definition at line 6932 of file walk.cc.

6933{
6934 int i,j;
6935 intvec* ivM = new intvec(nV*nV);
6936
6937 for(i=0; i<nV; i++)
6938 for(j=0; j<nV; j++)
6939 (*ivM)[i*nV + j] = 1;
6940
6941 return(ivM);
6942}

◆ MPertVectors()

intvec * MPertVectors ( ideal  G,
intvec ivtarget,
int  pdeg 
)

Definition at line 1088 of file walk.cc.

1089{
1090 // ivtarget is a matrix order of a degree reverse lex. order
1091 int nV = currRing->N;
1092 //assume(pdeg <= nV && pdeg >= 0);
1093
1094 int i, j, nG = IDELEMS(G);
1095 intvec* v_null = new intvec(nV);
1096
1097 // Check that the perturbed degree is valid
1098 if(pdeg > nV || pdeg <= 0)
1099 {
1100 WerrorS("//** The perturbed degree is wrong!!");
1101 return v_null;
1102 }
1103 delete v_null;
1104
1105 if(pdeg == 1)
1106 {
1107 return ivtarget;
1108 }
1109 mpz_t *pert_vector = (mpz_t*)omAlloc(nV*sizeof(mpz_t));
1110 mpz_t *pert_vector1 = (mpz_t*)omAlloc(nV*sizeof(mpz_t));
1111
1112 for(i=0; i<nV; i++)
1113 {
1114 mpz_init_set_si(pert_vector[i], (*ivtarget)[i]);
1115 mpz_init_set_si(pert_vector1[i], (*ivtarget)[i]);
1116 }
1117 // Calculate max1 = Max(A2)+Max(A3)+...+Max(Apdeg),
1118 // where the Ai are the i-te rows of the matrix target_ord.
1119 int ntemp, maxAi, maxA=0;
1120 for(i=1; i<pdeg; i++)
1121 {
1122 maxAi = (*ivtarget)[i*nV];
1123 if(maxAi<0)
1124 {
1125 maxAi = -maxAi;
1126 }
1127 for(j=i*nV+1; j<(i+1)*nV; j++)
1128 {
1129 ntemp = (*ivtarget)[j];
1130 if(ntemp < 0)
1131 {
1132 ntemp = -ntemp;
1133 }
1134 if(ntemp > maxAi)
1135 {
1136 maxAi = ntemp;
1137 }
1138 }
1139 maxA += maxAi;
1140 }
1141
1142 // Calculate inveps = 1/eps, where 1/eps > totaldeg(p)*max1 for all p in G.
1143
1144 intvec* ivUnit = Mivdp(nV);
1145
1146 mpz_t tot_deg; mpz_init(tot_deg);
1147 mpz_t maxdeg; mpz_init(maxdeg);
1148 mpz_t inveps; mpz_init(inveps);
1149
1150
1151 for(i=nG-1; i>=0; i--)
1152 {
1153 mpz_set_ui(maxdeg, MwalkWeightDegree(G->m[i], ivUnit));
1154 if (mpz_cmp(maxdeg, tot_deg) > 0 )
1155 {
1156 mpz_set(tot_deg, maxdeg);
1157 }
1158 }
1159
1160 delete ivUnit;
1161 mpz_mul_ui(inveps, tot_deg, maxA);
1162 mpz_add_ui(inveps, inveps, 1);
1163
1164
1165 // takes "small" inveps
1166#ifdef INVEPS_SMALL_IN_MPERTVECTOR
1167 if(mpz_cmp_ui(inveps, pdeg)>0 && pdeg > 3)
1168 {
1169 // Print("\n// choose the\"small\" inverse epsilon := %d / %d = ", mpz_get_si(inveps), pdeg);
1170 mpz_fdiv_q_ui(inveps, inveps, pdeg);
1171 // mpz_out_str(stdout, 10, inveps);
1172 }
1173#else
1174 // PrintS("\n// the \"big\" inverse epsilon: ");
1175 mpz_out_str(stdout, 10, inveps);
1176#endif
1177
1178 // pert(A1) = inveps^(pdeg-1)*A1 + inveps^(pdeg-2)*A2+...+A_pdeg,
1179 // pert_vector := A1
1180 for( i=1; i < pdeg; i++ )
1181 {
1182 for(j=0; j<nV; j++)
1183 {
1184 mpz_mul(pert_vector[j], pert_vector[j], inveps);
1185 if((*ivtarget)[i*nV+j]<0)
1186 {
1187 mpz_sub_ui(pert_vector[j], pert_vector[j],-(*ivtarget)[i*nV+j]);
1188 }
1189 else
1190 {
1191 mpz_add_ui(pert_vector[j], pert_vector[j],(*ivtarget)[i*nV+j]);
1192 }
1193 }
1194 }
1195
1196 // 2147483647 is max. integer representation in SINGULAR
1197 mpz_t sing_int;
1198 mpz_init_set_ui(sing_int, 2147483647);
1199
1200 mpz_t check_int;
1201 mpz_init_set_ui(check_int, 100000);
1202
1203 mpz_t ztemp;
1204 mpz_init(ztemp);
1205 mpz_set(ztemp, pert_vector[0]);
1206 for(i=1; i<nV; i++)
1207 {
1208 mpz_gcd(ztemp, ztemp, pert_vector[i]);
1209 if(mpz_cmp_si(ztemp, 1) == 0)
1210 {
1211 break;
1212 }
1213 }
1214 if(mpz_cmp_si(ztemp, 1) != 0)
1215 {
1216 for(i=0; i<nV; i++)
1217 {
1218 mpz_divexact(pert_vector[i], pert_vector[i], ztemp);
1219 }
1220 }
1221
1222 for(i=0; i<nV; i++)
1223 {
1224 if(mpz_cmp(pert_vector[i], check_int)>=0)
1225 {
1226 for(j=0; j<nV; j++)
1227 {
1228 mpz_fdiv_q_ui(pert_vector1[j], pert_vector[j], 100);
1229 }
1230 }
1231 }
1232
1233 intvec* result = new intvec(nV);
1234
1235 int ntrue=0;
1236
1237 for(i=0; i<nV; i++)
1238 {
1239 (*result)[i] = mpz_get_si(pert_vector1[i]);
1240 if(mpz_cmp(pert_vector1[i], sing_int)>=0)
1241 {
1242 ntrue++;
1243 }
1244 }
1245 if(ntrue > 0 || test_w_in_ConeCC(G,result)==0)
1246 {
1247 ntrue=0;
1248 for(i=0; i<nV; i++)
1249 {
1250 (*result)[i] = mpz_get_si(pert_vector[i]);
1251 if(mpz_cmp(pert_vector[i], sing_int)>=0)
1252 {
1253 ntrue++;
1254 if(Overflow_Error == FALSE)
1255 {
1257 PrintS("\n// ** OVERFLOW in \"MPertvectors\": ");
1258 mpz_out_str( stdout, 10, pert_vector[i]);
1259 PrintS(" is greater than 2147483647 (max. integer representation)");
1260 Print("\n// So vector[%d] := %d is wrong!!", i+1, (*result)[i]);
1261 }
1262 }
1263 }
1264
1265 if(Overflow_Error == TRUE)
1266 {
1267 ivString(result, "pert_vector");
1268 Print("\n// %d element(s) of it is overflow!!", ntrue);
1269 }
1270 }
1271
1272 mpz_clear(ztemp);
1273 mpz_clear(sing_int);
1274 mpz_clear(check_int);
1275 omFree(pert_vector);
1276 omFree(pert_vector1);
1277 mpz_clear(tot_deg);
1278 mpz_clear(maxdeg);
1279 mpz_clear(inveps);
1280
1282 for(j=0; j<IDELEMS(G); j++)
1283 {
1284 poly p=G->m[j];
1285 while(p!=NULL)
1286 {
1287 p_Setm(p,currRing); pIter(p);
1288 }
1289 }
1290 return result;
1291}

◆ MPertVectorslp()

intvec * MPertVectorslp ( ideal  G,
intvec ivtarget,
int  pdeg 
)

Definition at line 1299 of file walk.cc.

1300{
1301 // ivtarget is a matrix order of the lex. order
1302 int nV = currRing->N;
1303 //assume(pdeg <= nV && pdeg >= 0);
1304
1305 int i, j, nG = IDELEMS(G);
1306 intvec* pert_vector = new intvec(nV);
1307
1308 //Checking that the perturbated degree is valid
1309 if(pdeg > nV || pdeg <= 0)
1310 {
1311 WerrorS("//** The perturbed degree is wrong!!");
1312 return pert_vector;
1313 }
1314 for(i=0; i<nV; i++)
1315 {
1316 (*pert_vector)[i]=(*ivtarget)[i];
1317 }
1318 if(pdeg == 1)
1319 {
1320 return pert_vector;
1321 }
1322 // Calculate max1 = Max(A2)+Max(A3)+...+Max(Apdeg),
1323 // where the Ai are the i-te rows of the matrix target_ord.
1324 int ntemp, maxAi, maxA=0;
1325 for(i=1; i<pdeg; i++)
1326 {
1327 maxAi = (*ivtarget)[i*nV];
1328 for(j=i*nV+1; j<(i+1)*nV; j++)
1329 {
1330 ntemp = (*ivtarget)[j];
1331 if(ntemp > maxAi)
1332 {
1333 maxAi = ntemp;
1334 }
1335 }
1336 maxA += maxAi;
1337 }
1338
1339 // Calculate inveps := 1/eps, where 1/eps > deg(p)*max1 for all p in G.
1340 int inveps, tot_deg = 0, maxdeg;
1341
1342 intvec* ivUnit = Mivdp(nV);//19.02
1343 for(i=nG-1; i>=0; i--)
1344 {
1345 // maxdeg = pTotaldegree(G->m[i], currRing); //it's wrong for ex1,2,rose
1346 maxdeg = MwalkWeightDegree(G->m[i], ivUnit);
1347 if (maxdeg > tot_deg )
1348 {
1349 tot_deg = maxdeg;
1350 }
1351 }
1352 delete ivUnit;
1353
1354 inveps = (tot_deg * maxA) + 1;
1355
1356#ifdef INVEPS_SMALL_IN_FRACTAL
1357 // Print("\n// choose the\"small\" inverse epsilon := %d / %d = ", inveps, pdeg);
1358 if(inveps > pdeg && pdeg > 3)
1359 {
1360 inveps = inveps / pdeg;
1361 }
1362 // Print(" %d", inveps);
1363#else
1364 PrintS("\n// the \"big\" inverse epsilon %d", inveps);
1365#endif
1366
1367 // Pert(A1) = inveps^(pdeg-1)*A1 + inveps^(pdeg-2)*A2+...+A_pdeg
1368 for ( i=1; i < pdeg; i++ )
1369 {
1370 for(j=0; j<nV; j++)
1371 {
1372 (*pert_vector)[j] = inveps*((*pert_vector)[j]) + (*ivtarget)[i*nV+j];
1373 }
1374 }
1375
1376 int temp = (*pert_vector)[0];
1377 for(i=1; i<nV; i++)
1378 {
1379 temp = gcd(temp, (*pert_vector)[i]);
1380 if(temp == 1)
1381 {
1382 break;
1383 }
1384 }
1385 if(temp != 1)
1386 {
1387 for(i=0; i<nV; i++)
1388 {
1389 (*pert_vector)[i] = (*pert_vector)[i] / temp;
1390 }
1391 }
1392
1393 intvec* result = pert_vector;
1394 delete pert_vector;
1395 return result;
1396}

◆ MpolyInitialForm()

static poly MpolyInitialForm ( poly  g,
intvec curr_weight 
)
static

Definition at line 722 of file walk.cc.

723{
724 if(g == NULL)
725 {
726 return NULL;
727 }
728 mpz_t max; mpz_init(max);
729 mpz_t maxtmp; mpz_init(maxtmp);
730
731 poly hg, in_w_g = NULL;
732
733 while(g != NULL)
734 {
735 hg = g;
736 pIter(g);
737 MLmWeightedDegree_gmp(maxtmp, hg, curr_weight);
738
739 if(mpz_cmp(maxtmp, max)>0)
740 {
741 mpz_set(max, maxtmp);
742 if (in_w_g!=NULL) pDelete(&in_w_g);
743 in_w_g = pHead(hg);
744 }
745 else
746 {
747 if(mpz_cmp(maxtmp, max)==0)
748 {
749 in_w_g = pAdd(in_w_g, pHead(hg));
750 }
751 }
752 }
753 mpz_clear(maxtmp);
754 mpz_clear(max);
755 return in_w_g;
756}
static int max(int a, int b)
Definition: fast_mult.cc:264
static void MLmWeightedDegree_gmp(mpz_t result, const poly p, intvec *weight)
Definition: walk.cc:690

◆ Mprwalk()

ideal Mprwalk ( ideal  Go,
intvec orig_M,
intvec target_M,
int  weight_rad,
int  op_deg,
int  tp_deg,
int  nP,
int  reduction,
int  printout 
)

Definition at line 6388 of file walk.cc.

6390{
6391 BITSET save1 = si_opt_1; // save current options
6392 if(reduction == 0)
6393 {
6394 si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
6395 si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
6396 }
6399 //Print("// pSetm_Error = (%d)", ErrorCheck());
6400#ifdef TIME_TEST
6401 clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
6402 xtextra=0;
6403 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
6404 tinput = clock();
6405
6406 clock_t tim;
6407#endif
6408 nstep = 0;
6409 int i, ntwC=1, ntestw=1, nV = currRing->N; //polylength
6410
6411 //check that weight radius is valid
6412 if(weight_rad < 0)
6413 {
6414 WerrorS("Invalid radius.\n");
6415 return NULL;
6416 }
6417
6418 //check that perturbation degree is valid
6419 if(op_deg < 1 || tp_deg < 1 || op_deg > nV || tp_deg > nV)
6420 {
6421 WerrorS("Invalid perturbation degree.\n");
6422 return NULL;
6423 }
6424
6425 BOOLEAN endwalks = FALSE;
6426
6427 ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
6428 ring newRing, oldRing, TargetRing;
6429 intvec* iv_M;
6430 intvec* iv_M_dp;
6431 intvec* iv_M_lp;
6432 intvec* exivlp = Mivlp(nV);
6433 intvec* curr_weight = new intvec(nV);
6434 intvec* target_weight = new intvec(nV);
6435 for(i=0; i<nV; i++)
6436 {
6437 (*curr_weight)[i] = (*orig_M)[i];
6438 (*target_weight)[i] = (*target_M)[i];
6439 }
6440 intvec* orig_target = target_weight;
6441 intvec* pert_target_vector = target_weight;
6442 intvec* ivNull = new intvec(nV);
6443 intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
6444#ifndef BUCHBERGER_ALG
6445 intvec* hilb_func;
6446#endif
6447 intvec* next_weight;
6448
6449 // to avoid (1,0,...,0) as the target vector
6450 intvec* last_omega = new intvec(nV);
6451 for(i=nV-1; i>0; i--)
6452 (*last_omega)[i] = 1;
6453 (*last_omega)[0] = 10000;
6454
6455 ring XXRing = currRing;
6456
6457 // perturbs the original vector
6458 if(orig_M->length() == nV)
6459 {
6460 if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
6461 {
6462#ifdef TIME_TEST
6463 to = clock();
6464#endif
6465 G = MstdCC(Go);
6466#ifdef TIME_TEST
6467 tostd = clock()-to;
6468#endif
6469 if(op_deg != 1)
6470 {
6471 iv_M_dp = MivMatrixOrderdp(nV);
6472 curr_weight = MPertVectors(G, iv_M_dp, op_deg);
6473 }
6474 }
6475 else
6476 {
6477 //define ring order := (a(curr_weight),lp);
6478 if (rParameter(currRing) != NULL)
6479 DefRingPar(curr_weight);
6480 else
6481 rChangeCurrRing(VMrDefault(curr_weight));
6482
6483 G = idrMoveR(Go, XXRing,currRing);
6484#ifdef TIME_TEST
6485 to = clock();
6486#endif
6487 G = MstdCC(G);
6488#ifdef TIME_TEST
6489 tostd = clock()-to;
6490#endif
6491 if(op_deg != 1)
6492 {
6493 iv_M_dp = MivMatrixOrder(curr_weight);
6494 curr_weight = MPertVectors(G, iv_M_dp, op_deg);
6495 }
6496 }
6497 }
6498 else
6499 {
6501 G = idrMoveR(Go, XXRing,currRing);
6502#ifdef TIME_TEST
6503 to = clock();
6504#endif
6505 G = MstdCC(G);
6506#ifdef TIME_TEST
6507 tostd = clock()-to;
6508#endif
6509 if(op_deg != 1)
6510 {
6511 curr_weight = MPertVectors(G, orig_M, op_deg);
6512 }
6513 }
6514
6515 delete iv_dp;
6516 if(op_deg != 1) delete iv_M_dp;
6517
6518 ring HelpRing = currRing;
6519
6520 // perturbs the target weight vector
6521 if(target_M->length() == nV)
6522 {
6523 if(tp_deg > 1 && tp_deg <= nV)
6524 {
6525 if (rParameter(currRing) != NULL)
6526 DefRingPar(target_weight);
6527 else
6528 rChangeCurrRing(VMrDefault(target_weight));
6529
6530 TargetRing = currRing;
6531 ssG = idrMoveR(G,HelpRing,currRing);
6532 if(MivSame(target_weight, exivlp) == 1)
6533 {
6534 iv_M_lp = MivMatrixOrderlp(nV);
6535 target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
6536 }
6537 else
6538 {
6539 iv_M_lp = MivMatrixOrder(target_weight);
6540 target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
6541 }
6542 delete iv_M_lp;
6543 pert_target_vector = target_weight;
6544 rChangeCurrRing(HelpRing);
6545 G = idrMoveR(ssG, TargetRing,currRing);
6546 }
6547 }
6548 else
6549 {
6550 if(tp_deg > 1 && tp_deg <= nV)
6551 {
6552 rChangeCurrRing(VMatrDefault(target_M));
6553 TargetRing = currRing;
6554 ssG = idrMoveR(G,HelpRing,currRing);
6555 target_weight = MPertVectors(ssG, target_M, tp_deg);
6556 }
6557 }
6558 if(printout > 0)
6559 {
6560 Print("\n//** Mprwalk: Random Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
6561 ivString(curr_weight, "//** Mprwalk: new current weight");
6562 ivString(target_weight, "//** Mprwalk: new target weight");
6563 }
6564
6565#ifdef TIME_TEST
6566 to = clock();
6567#endif
6568 Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
6569#ifdef TIME_TEST
6570 tif = tif + clock()-to; //time for computing initial form ideal
6571#endif
6572
6573 while(1)
6574 {
6575 nstep ++;
6576#ifdef CHECK_IDEAL_MWALK
6577 if(printout > 1)
6578 {
6579 idString(Gomega,"//** Mprwalk: Gomega");
6580 }
6581#endif
6582
6583 if(reduction == 0 && nstep > 1)
6584 {
6585 FF = middleOfCone(G,Gomega);
6586 if(FF != NULL)
6587 {
6588 idDelete(&G);
6589 G = idCopy(FF);
6590 idDelete(&FF);
6591 goto NEXT_VECTOR;
6592 }
6593 }
6594
6595#ifdef ENDWALKS
6596 if(endwalks == TRUE)
6597 {
6598 if(printout > 0)
6599 {
6600 Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6601 //idElements(G, "G");
6602 //headidString(G, "G");
6603 }
6604 }
6605#endif
6606
6607#ifndef BUCHBERGER_ALG
6608 if(isNolVector(curr_weight) == 0)
6609 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
6610 else
6611 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
6612#endif // BUCHBERGER_ALG
6613
6614 oldRing = currRing;
6615
6616 if(target_M->length() == nV)
6617 {/*
6618 // define a new ring with ordering "(a(curr_weight),lp)
6619 if (rParameter(currRing) != NULL)
6620 DefRingPar(curr_weight);
6621 else
6622 rChangeCurrRing(VMrDefault(curr_weight));
6623*/
6624 rChangeCurrRing(VMrRefine(target_M,curr_weight));
6625 }
6626 else
6627 {
6628 rChangeCurrRing(VMatrRefine(target_M,curr_weight));
6629 }
6630 newRing = currRing;
6631 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
6632#ifdef ENDWALKS
6633 if(endwalks == TRUE)
6634 {
6635 if(printout > 0)
6636 {
6637 Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6638
6639 //idElements(Gomega1, "Gw");
6640 //headidString(Gomega1, "headGw");
6641
6642 PrintS("\n// compute a rGB of Gw:\n");
6643 }
6644#ifndef BUCHBERGER_ALG
6645 ivString(hilb_func, "w");
6646#endif
6647 }
6648#endif
6649#ifdef TIME_TEST
6650 tim = clock();
6651 to = clock();
6652#endif
6653 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
6654#ifdef BUCHBERGER_ALG
6655 M = MstdhomCC(Gomega1);
6656#else
6657 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
6658 delete hilb_func;
6659#endif
6660#ifdef CHECK_IDEAL_MWALK
6661 if(printout > 2)
6662 {
6663 idString(M,"//** Mprwalk: M");
6664 }
6665#endif
6666#ifdef TIME_TEST
6667 if(endwalks == TRUE)
6668 {
6669 xtstd = xtstd+clock()-to;
6670#ifdef ENDWALKS
6671 Print("\n// time for the last std(Gw) = %.2f sec\n",
6672 ((double) clock())/1000000 -((double)tim) /1000000);
6673#endif
6674 }
6675 else
6676 tstd=tstd+clock()-to;
6677#endif
6678 /* change the ring to oldRing */
6679 rChangeCurrRing(oldRing);
6680 M1 = idrMoveR(M, newRing,currRing);
6681 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
6682#ifdef TIME_TEST
6683 to=clock();
6684#endif
6685 /* compute a representation of the generators of submod (M)
6686 with respect to those of mod (Gomega).
6687 Gomega is a reduced Groebner basis w.r.t. the current ring */
6688 F = MLifttwoIdeal(Gomega2, M1, G);
6689#ifdef TIME_TEST
6690 if(endwalks == FALSE)
6691 tlift = tlift+clock()-to;
6692 else
6693 xtlift=clock()-to;
6694#endif
6695#ifdef CHECK_IDEAL_MWALK
6696 if(printout > 2)
6697 {
6698 idString(F,"//** Mprwalk: F");
6699 }
6700#endif
6701
6702 idDelete(&M1);
6703 idDelete(&Gomega2);
6704 idDelete(&G);
6705
6706 // change the ring to newRing
6707 rChangeCurrRing(newRing);
6708 if(reduction == 0)
6709 {
6710 G = idrMoveR(F,oldRing,currRing);
6711 }
6712 else
6713 {
6714 F1 = idrMoveR(F, oldRing,currRing);
6715 if(printout > 2)
6716 {
6717 PrintS("\n //** Mprwalk: reduce the Groebner basis.\n");
6718 }
6719#ifdef TIME_TEST
6720 to=clock();
6721#endif
6722 G = kInterRedCC(F1, NULL);
6723#ifdef TIME_TEST
6724 if(endwalks == FALSE)
6725 tred = tred+clock()-to;
6726 else
6727 xtred=clock()-to;
6728#endif
6729 idDelete(&F1);
6730 }
6731
6732 if(endwalks == TRUE)
6733 break;
6734
6735 NEXT_VECTOR:
6736#ifdef TIME_TEST
6737 to = clock();
6738#endif
6739 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
6740#ifdef TIME_TEST
6741 tnw = tnw + clock() - to;
6742#endif
6743
6744#ifdef TIME_TEST
6745 to = clock();
6746#endif
6747 // compute an initial form ideal of <G> w.r.t. "next_vector"
6748 Gomega = MwalkInitialForm(G, next_weight);
6749#ifdef TIME_TEST
6750 tif = tif + clock()-to; //time for computing initial form ideal
6751#endif
6752
6753 //lengthpoly(Gomega) = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
6754 if(lengthpoly(Gomega) > 0)
6755 {
6756 if(printout > 1)
6757 {
6758 PrintS("\n Mpwalk: there is a polynomial in Gomega with at least 3 monomials.\n");
6759 }
6760 // low-dimensional facet of the cone
6761 delete next_weight;
6762 if(target_M->length() == nV)
6763 {
6764 iv_M = MivMatrixOrder(curr_weight);
6765 }
6766 else
6767 {
6768 iv_M = MivMatrixOrderRefine(curr_weight,target_M);
6769 }
6770#ifdef TIME_TEST
6771 to = clock();
6772#endif
6773 next_weight = MWalkRandomNextWeight(G, iv_M, target_weight, weight_rad, op_deg);
6774#ifdef TIME_TEST
6775 tnw = tnw + clock() - to;
6776#endif
6777 idDelete(&Gomega);
6778#ifdef TIME_TEST
6779 to = clock();
6780#endif
6781 Gomega = MwalkInitialForm(G, next_weight);
6782#ifdef TIME_TEST
6783 tif = tif + clock()-to; //time for computing initial form ideal
6784#endif
6785 delete iv_M;
6786 }
6787
6788#ifdef PRINT_VECTORS
6789 if(printout > 0)
6790 {
6791 MivString(curr_weight, target_weight, next_weight);
6792 }
6793#endif
6794
6795 if(Overflow_Error == TRUE)
6796 {
6797 ntwC = 0;
6798 //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6799 //idElements(G, "G");
6800 delete next_weight;
6801 goto FINISH_160302;
6802 }
6803 if(MivComp(next_weight, ivNull) == 1){
6804 newRing = currRing;
6805 delete next_weight;
6806 //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6807 break;
6808 }
6809 if(MivComp(next_weight, target_weight) == 1)
6810 endwalks = TRUE;
6811
6812 for(i=nV-1; i>=0; i--)
6813 (*curr_weight)[i] = (*next_weight)[i];
6814
6815 delete next_weight;
6816 }// end of while-loop
6817
6818 if(tp_deg != 1)
6819 {
6820 FINISH_160302:
6821 if(target_M->length() == nV)
6822 {
6823 if(MivSame(orig_target, exivlp) == 1)
6824 if (rParameter(currRing) != NULL)
6825 DefRingParlp();
6826 else
6827 VMrDefaultlp();
6828 else
6829 if (rParameter(currRing) != NULL)
6830 DefRingPar(orig_target);
6831 else
6832 rChangeCurrRing(VMrDefault(orig_target));
6833 }
6834 else
6835 {
6836 rChangeCurrRing(VMatrDefault(target_M));
6837 }
6838 TargetRing=currRing;
6839 F1 = idrMoveR(G, newRing,currRing);
6840
6841 // check whether the pertubed target vector stays in the correct cone
6842 if(ntwC != 0)
6843 {
6844 ntestw = test_w_in_ConeCC(F1, pert_target_vector);
6845 }
6846 if(ntestw != 1 || ntwC == 0)
6847 {
6848 if(ntestw != 1 && printout > 2)
6849 {
6850#ifdef PRINT_VECTORS
6851 ivString(pert_target_vector, "tau");
6852#endif
6853 PrintS("\n// **Mprwalk: perturbed target vector doesn't stay in cone.");
6854 Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6855 //idElements(F1, "G");
6856 }
6857 // LastGB is "better" than the kStd subroutine
6858#ifdef TIME_TEST
6859 to=clock();
6860#endif
6861 ideal eF1;
6862 if(nP == 0 || tp_deg == 1 || MivSame(orig_target, exivlp) != 1 || target_M->length() != nV)
6863 {
6864 if(printout > 2)
6865 {
6866 PrintS("\n// ** Mprwalk: Call \"std\" to compute a Groebner basis.\n");
6867 }
6868 eF1 = MstdCC(F1);
6869 idDelete(&F1);
6870 }
6871 else
6872 {
6873 if(printout > 2)
6874 {
6875 PrintS("\n// **Mprwalk: Call \"LastGB\" to compute a Groebner basis.\n");
6876 }
6877 rChangeCurrRing(newRing);
6878 ideal F2 = idrMoveR(F1, TargetRing,currRing);
6879 eF1 = LastGB(F2, curr_weight, tp_deg-1);
6880 F2=NULL;
6881 }
6882#ifdef TIME_TEST
6883 xtextra=clock()-to;
6884#endif
6885 ring exTargetRing = currRing;
6886
6887 rChangeCurrRing(XXRing);
6888 Eresult = idrMoveR(eF1, exTargetRing,currRing);
6889 }
6890 else
6891 {
6892 rChangeCurrRing(XXRing);
6893 Eresult = idrMoveR(F1, TargetRing,currRing);
6894 }
6895 }
6896 else
6897 {
6898 rChangeCurrRing(XXRing);
6899 Eresult = idrMoveR(G, newRing,currRing);
6900 }
6901 si_opt_1 = save1; //set original options, e. g. option(RedSB)
6902 delete ivNull;
6903 if(tp_deg != 1)
6904 delete target_weight;
6905
6906 if(op_deg != 1 )
6907 delete curr_weight;
6908
6909 delete exivlp;
6910 delete last_omega;
6911
6912#ifdef TIME_TEST
6913 TimeStringFractal(tinput, tostd, tif+xtif, tstd+xtstd,0, tlift+xtlift, tred+xtred,
6914 tnw+xtnw);
6915
6916 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
6917 //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep, Overflow_Error);
6918#endif
6919
6920 if(printout > 0)
6921 {
6922 Print("\n//** Mprwalk: Perturbation Walk took %d steps.\n", nstep);
6923 }
6924 return(Eresult);
6925}
void F2(int a2, int &r2)
F2.
static int lengthpoly(ideal G)
Definition: walk.cc:3440
static ideal middleOfCone(ideal G, ideal Gomega)
Definition: walk.cc:3079
static intvec * MWalkRandomNextWeight(ideal G, intvec *orig_M, intvec *target_weight, int weight_rad, int pert_deg)
Definition: walk.cc:4516
intvec * MivMatrixOrderRefine(intvec *iv, intvec *iw)
Definition: walk.cc:983
static void idString(ideal L, const char *st)
Definition: walk.cc:424

◆ Mpwalk()

ideal Mpwalk ( ideal  Go,
int  op_deg,
int  tp_deg,
intvec curr_weight,
intvec target_weight,
int  nP,
int  reduction,
int  printout 
)

Definition at line 5947 of file walk.cc.

5949{
5950 BITSET save1 = si_opt_1; // save current options
5951 if(reduction == 0)
5952 {
5953 si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
5954 si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
5955 }
5956 Set_Error(FALSE );
5958 //Print("// pSetm_Error = (%d)", ErrorCheck());
5959#ifdef TIME_TEST
5960 clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
5961 xtextra=0;
5962 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
5963 tinput = clock();
5964
5965 clock_t tim;
5966#endif
5967 nstep = 0;
5968 int i, ntwC=1, ntestw=1, nV = currRing->N;
5969
5970 //check that perturbation degree is valid
5971 if(op_deg < 1 || tp_deg < 1 || op_deg > nV || tp_deg > nV)
5972 {
5973 WerrorS("Invalid perturbation degree.\n");
5974 return NULL;
5975 }
5976
5977 BOOLEAN endwalks = FALSE;
5978 ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
5979 ring newRing, oldRing, TargetRing;
5980 intvec* iv_M_dp;
5981 intvec* iv_M_lp;
5982 intvec* exivlp = Mivlp(nV);
5983 intvec* orig_target = target_weight;
5984 intvec* pert_target_vector = target_weight;
5985 intvec* ivNull = new intvec(nV);
5986 intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
5987#ifndef BUCHBERGER_ALG
5988 intvec* hilb_func;
5989#endif
5990 intvec* next_weight;
5991
5992 // to avoid (1,0,...,0) as the target vector
5993 intvec* last_omega = new intvec(nV);
5994 for(i=nV-1; i>0; i--)
5995 (*last_omega)[i] = 1;
5996 (*last_omega)[0] = 10000;
5997
5998 ring XXRing = currRing;
5999#ifdef TIME_TEST
6000 to = clock();
6001#endif
6002 // perturbs the original vector
6003 if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
6004 {
6005 G = MstdCC(Go);
6006#ifdef TIME_TEST
6007 tostd = clock()-to;
6008#endif
6009 if(op_deg != 1){
6010 iv_M_dp = MivMatrixOrderdp(nV);
6011 //ivString(iv_M_dp, "iv_M_dp");
6012 curr_weight = MPertVectors(G, iv_M_dp, op_deg);
6013 }
6014 }
6015 else
6016 {
6017 //define ring order := (a(curr_weight),lp);
6018/*
6019 if (rParameter(currRing) != NULL)
6020 DefRingPar(curr_weight);
6021 else
6022 rChangeCurrRing(VMrDefault(curr_weight));
6023*/
6024 rChangeCurrRing(VMrRefine(target_weight,curr_weight));
6025
6026 G = idrMoveR(Go, XXRing,currRing);
6027 G = MstdCC(G);
6028#ifdef TIME_TEST
6029 tostd = clock()-to;
6030#endif
6031 if(op_deg != 1){
6032 iv_M_dp = MivMatrixOrder(curr_weight);
6033 curr_weight = MPertVectors(G, iv_M_dp, op_deg);
6034 }
6035 }
6036 delete iv_dp;
6037 if(op_deg != 1) delete iv_M_dp;
6038
6039 ring HelpRing = currRing;
6040
6041 // perturbs the target weight vector
6042 if(tp_deg > 1 && tp_deg <= nV)
6043 {
6044/*
6045 if (rParameter(currRing) != NULL)
6046 DefRingPar(target_weight);
6047 else
6048 rChangeCurrRing(VMrDefault(target_weight));
6049*/
6050 rChangeCurrRing(VMrRefine(target_weight,curr_weight));
6051
6052 TargetRing = currRing;
6053 ssG = idrMoveR(G,HelpRing,currRing);
6054 if(MivSame(target_weight, exivlp) == 1)
6055 {
6056 iv_M_lp = MivMatrixOrderlp(nV);
6057 target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
6058 }
6059 else
6060 {
6061 iv_M_lp = MivMatrixOrder(target_weight);
6062 target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
6063 }
6064 delete iv_M_lp;
6065 pert_target_vector = target_weight;
6066 rChangeCurrRing(HelpRing);
6067 G = idrMoveR(ssG, TargetRing,currRing);
6068 }
6069 if(printout > 0)
6070 {
6071 Print("\n//** Mpwalk: Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
6072#ifdef PRINT_VECTORS
6073 ivString(curr_weight, "//** Mpwalk: new current weight");
6074 ivString(target_weight, "//** Mpwalk: new target weight");
6075#endif
6076 }
6077 while(1)
6078 {
6079 nstep ++;
6080#ifdef TIME_TEST
6081 to = clock();
6082#endif
6083 // compute an initial form ideal of <G> w.r.t. the weight vector
6084 // "curr_weight"
6085 Gomega = MwalkInitialForm(G, curr_weight);
6086#ifdef TIME_TEST
6087 tif = tif + clock()-to;
6088#endif
6089#ifdef CHECK_IDEAL_MWALK
6090 if(printout > 1)
6091 {
6092 idString(Gomega,"//** Mpwalk: Gomega");
6093 }
6094#endif
6095 if(reduction == 0 && nstep > 1)
6096 {
6097 FF = middleOfCone(G,Gomega);
6098 if(FF != NULL)
6099 {
6100 idDelete(&G);
6101 G = idCopy(FF);
6102 idDelete(&FF);
6103 goto NEXT_VECTOR;
6104 }
6105 }
6106
6107#ifdef ENDWALKS
6108 if(endwalks == TRUE)
6109 {
6110 if(printout > 0)
6111 {
6112 Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6113 }
6114 //idElements(G, "G");
6115 //headidString(G, "G");
6116 }
6117#endif
6118
6119#ifndef BUCHBERGER_ALG
6120 if(isNolVector(curr_weight) == 0)
6121 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
6122 else
6123 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
6124#endif // BUCHBERGER_ALG
6125
6126 oldRing = currRing;
6127
6128 // define a new ring with ordering "(a(curr_weight),lp)
6129/*
6130 if (rParameter(currRing) != NULL)
6131 DefRingPar(curr_weight);
6132 else
6133 rChangeCurrRing(VMrDefault(curr_weight));
6134*/
6135 rChangeCurrRing(VMrRefine(target_weight,curr_weight));
6136
6137 newRing = currRing;
6138 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
6139
6140#ifdef ENDWALKS
6141 if(endwalks==TRUE)
6142 {
6143 if(printout > 0)
6144 {
6145 Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6146 //idElements(Gomega1, "Gw");
6147 //headidString(Gomega1, "headGw");
6148 PrintS("\n// compute a rGB of Gw:\n");
6149 }
6150#ifndef BUCHBERGER_ALG
6151 ivString(hilb_func, "w");
6152#endif
6153 }
6154#endif
6155#ifdef TIME_TEST
6156 tim = clock();
6157 to = clock();
6158#endif
6159 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
6160#ifdef BUCHBERGER_ALG
6161 M = MstdhomCC(Gomega1);
6162#else
6163 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
6164 delete hilb_func;
6165#endif
6166
6167 if(endwalks == TRUE)
6168 {
6169#ifdef TIME_TEST
6170 xtstd = xtstd+clock()-to;
6171#endif
6172#ifdef ENDWALKS
6173#ifdef TIME_TEST
6174 if(printout > 1)
6175 {
6176 Print("\n// time for the last std(Gw) = %.2f sec\n",
6177 ((double) clock())/1000000 -((double)tim) /1000000);
6178 }
6179#endif
6180#endif
6181 }
6182 else
6183 {
6184#ifdef TIME_TEST
6185 tstd=tstd+clock()-to;
6186#endif
6187 }
6188#ifdef CHECK_IDEAL_MWALK
6189 if(printout > 2)
6190 {
6191 idString(M,"//** Mpwalk: M");
6192 }
6193#endif
6194 // change the ring to oldRing
6195 rChangeCurrRing(oldRing);
6196 M1 = idrMoveR(M, newRing,currRing);
6197 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
6198#ifdef TIME_TEST
6199 to=clock();
6200#endif
6201 /* compute a representation of the generators of submod (M)
6202 with respect to those of mod (Gomega).
6203 Gomega is a reduced Groebner basis w.r.t. the current ring */
6204 F = MLifttwoIdeal(Gomega2, M1, G);
6205#ifdef TIME_TEST
6206 if(endwalks == FALSE)
6207 tlift = tlift+clock()-to;
6208 else
6209 xtlift=clock()-to;
6210#endif
6211#ifdef CHECK_IDEAL_MWALK
6212 if(printout > 2)
6213 {
6214 idString(F,"//** Mpwalk: F");
6215 }
6216#endif
6217
6218 idDelete(&M1);
6219 idDelete(&Gomega2);
6220 idDelete(&G);
6221
6222 // change the ring to newRing
6223 rChangeCurrRing(newRing);
6224 if(reduction == 0)
6225 {
6226 G = idrMoveR(F,oldRing,currRing);
6227 }
6228 else
6229 {
6230 F1 = idrMoveR(F, oldRing,currRing);
6231 if(printout > 2)
6232 {
6233 PrintS("\n //** Mpwalk: reduce the Groebner basis.\n");
6234 }
6235#ifdef TIME_TEST
6236 to=clock();
6237#endif
6238 G = kInterRedCC(F1, NULL);
6239#ifdef TIME_TEST
6240 if(endwalks == FALSE)
6241 tred = tred+clock()-to;
6242 else
6243 xtred=clock()-to;
6244#endif
6245 idDelete(&F1);
6246 }
6247 if(endwalks == TRUE)
6248 break;
6249
6250 NEXT_VECTOR:
6251#ifdef TIME_TEST
6252 to=clock();
6253#endif
6254 // compute a next weight vector
6255 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
6256#ifdef TIME_TEST
6257 tnw=tnw+clock()-to;
6258#endif
6259#ifdef PRINT_VECTORS
6260 if(printout > 0)
6261 {
6262 MivString(curr_weight, target_weight, next_weight);
6263 }
6264#endif
6265
6266 if(Overflow_Error == TRUE)
6267 {
6268 ntwC = 0;
6269 //ntestomega = 1;
6270 //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6271 //idElements(G, "G");
6272 delete next_weight;
6273 goto FINISH_160302;
6274 }
6275 if(MivComp(next_weight, ivNull) == 1){
6276 newRing = currRing;
6277 delete next_weight;
6278 //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6279 break;
6280 }
6281 if(MivComp(next_weight, target_weight) == 1)
6282 endwalks = TRUE;
6283
6284 for(i=nV-1; i>=0; i--)
6285 (*curr_weight)[i] = (*next_weight)[i];
6286
6287 delete next_weight;
6288 }//end of while-loop
6289
6290 if(tp_deg != 1)
6291 {
6292 FINISH_160302:
6293 if(MivSame(orig_target, exivlp) == 1) {
6294 /* if (rParameter(currRing) != NULL)
6295 DefRingParlp();
6296 else
6297 VMrDefaultlp();
6298 else
6299 if (rParameter(currRing) != NULL)
6300 DefRingPar(orig_target);
6301 else*/
6302 rChangeCurrRing(VMrDefault(orig_target));
6303 }
6304 TargetRing=currRing;
6305 F1 = idrMoveR(G, newRing,currRing);
6306/*
6307#ifdef CHECK_IDEAL_MWALK
6308 headidString(G, "G");
6309#endif
6310*/
6311
6312 // check whether the pertubed target vector stays in the correct cone
6313 if(ntwC != 0){
6314 ntestw = test_w_in_ConeCC(F1, pert_target_vector);
6315 }
6316
6317 if( ntestw != 1 || ntwC == 0)
6318 {
6319 if(ntestw != 1 && printout >2)
6320 {
6321 ivString(pert_target_vector, "tau");
6322 PrintS("\n// ** perturbed target vector doesn't stay in cone!!");
6323 Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
6324 //idElements(F1, "G");
6325 }
6326 // LastGB is "better" than the kStd subroutine
6327#ifdef TIME_TEST
6328 to=clock();
6329#endif
6330 ideal eF1;
6331 if(nP == 0 || tp_deg == 1 || MivSame(orig_target, exivlp) != 1){
6332 // PrintS("\n// ** calls \"std\" to compute a GB");
6333 eF1 = MstdCC(F1);
6334 idDelete(&F1);
6335 }
6336 else {
6337 // PrintS("\n// ** calls \"LastGB\" to compute a GB");
6338 rChangeCurrRing(newRing);
6339 ideal F2 = idrMoveR(F1, TargetRing,currRing);
6340 eF1 = LastGB(F2, curr_weight, tp_deg-1);
6341 F2=NULL;
6342 }
6343#ifdef TIME_TEST
6344 xtextra=clock()-to;
6345#endif
6346 ring exTargetRing = currRing;
6347
6348 rChangeCurrRing(XXRing);
6349 Eresult = idrMoveR(eF1, exTargetRing,currRing);
6350 }
6351 else{
6352 rChangeCurrRing(XXRing);
6353 Eresult = idrMoveR(F1, TargetRing,currRing);
6354 }
6355 }
6356 else {
6357 rChangeCurrRing(XXRing);
6358 Eresult = idrMoveR(G, newRing,currRing);
6359 }
6360 si_opt_1 = save1; //set original options, e. g. option(RedSB)
6361 delete ivNull;
6362 if(tp_deg != 1)
6363 delete target_weight;
6364
6365 if(op_deg != 1 )
6366 delete curr_weight;
6367
6368 delete exivlp;
6369 delete last_omega;
6370
6371#ifdef TIME_TEST
6372 TimeStringFractal(tinput, tostd, tif+xtif, tstd+xtstd,0, tlift+xtlift, tred+xtred,
6373 tnw+xtnw);
6374
6375 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
6376 //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep, Overflow_Error);
6377#endif
6378 if(printout > 0)
6379 {
6380 Print("\n//** Mpwalk: Perturbation Walk took %d steps.\n", nstep);
6381 }
6382 return(Eresult);
6383}

◆ Mpwalk_MAltwalk1()

static ideal Mpwalk_MAltwalk1 ( ideal  Go,
intvec curr_weight,
int  tp_deg 
)
static

Definition at line 9377 of file walk.cc.

9378{
9380 // BOOLEAN nOverflow_Error = FALSE;
9381#ifdef TIME_TEST
9382 clock_t tproc=0;
9383 clock_t tinput=clock();
9384#endif
9385 int i, nV = currRing->N;
9386
9387 //check that perturbation degree is valid
9388 if(tp_deg < 1 || tp_deg > nV)
9389 {
9390 WerrorS("Invalid perturbation degree.\n");
9391 return NULL;
9392 }
9393
9394 int nwalk=0, endwalks=0, ntestwinC=1;
9395 int tp_deg_tmp = tp_deg;
9396 ideal Gomega, M, F, G, M1, F1, Gomega1, Gomega2, G1;
9397 ring newRing, oldRing, TargetRing;
9398 intvec* next_weight;
9399 intvec* ivNull = new intvec(nV);
9400
9401 ring YXXRing = currRing;
9402
9403 intvec* iv_M_dpp = MivMatrixOrderlp(nV);
9404 intvec* target_weight;// = Mivlp(nV);
9405 ideal ssG;
9406
9407 // perturb the target vector
9408 while(1)
9409 {
9410 if(Overflow_Error == FALSE)
9411 {
9412 if (rParameter(currRing) != NULL)
9413 {
9414 DefRingParlp();
9415 }
9416 else
9417 {
9418 VMrDefaultlp();
9419 }
9420 TargetRing = currRing;
9421 ssG = idrMoveR(Go,YXXRing,currRing);
9422 }
9424 if(tp_deg != 1)
9425 {
9426 target_weight = MPertVectors(ssG, iv_M_dpp, tp_deg);
9427 }
9428 else
9429 {
9430 target_weight = Mivlp(nV);
9431 break;
9432 }
9433 if(Overflow_Error == FALSE)
9434 {
9435 break;
9436 }
9438 tp_deg --;
9439 }
9440 if(tp_deg != tp_deg_tmp)
9441 {
9443 //nOverflow_Error = TRUE;
9444 }
9445
9446 // Print("\n// tp_deg = %d", tp_deg);
9447 // ivString(target_weight, "pert target");
9448
9449 delete iv_M_dpp;
9450#ifndef BUCHBERGER_ALG
9451 intvec* hilb_func;
9452#endif
9453 // to avoid (1,0,...,0) as the target vector
9454 intvec* last_omega = new intvec(nV);
9455 for(i=nV-1; i>0; i--)
9456 {
9457 (*last_omega)[i] = 1;
9458 }
9459 (*last_omega)[0] = 10000;
9460
9461 rChangeCurrRing(YXXRing);
9462 G = idrMoveR(ssG, TargetRing,currRing);
9463
9464 while(1)
9465 {
9466 nwalk ++;
9467 nstep ++;
9468
9469 if(nwalk==1)
9470 {
9471 goto FIRST_STEP;
9472 }
9473#ifdef TIME_TEST
9474 to=clock();
9475#endif
9476 // compute an initial form ideal of <G> w.r.t. "curr_vector"
9477 Gomega = MwalkInitialForm(G, curr_weight);
9478#ifdef TIME_TEST
9479 xtif=xtif+clock()-to;
9480#endif
9481
9482#ifndef BUCHBERGER_ALG
9483 if(isNolVector(curr_weight) == 0)
9484 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
9485 else
9486 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
9487#endif
9488
9489 oldRing = currRing;
9490
9491 // define a new ring that its ordering is "(a(curr_weight),lp)
9492 if (rParameter(currRing) != NULL)
9493 {
9494 DefRingPar(curr_weight);
9495 }
9496 else
9497 {
9498 rChangeCurrRing(VMrDefault(curr_weight));
9499 }
9500 newRing = currRing;
9501 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
9502/*
9503#ifdef ENDWALKS
9504 if(endwalks == 1)
9505 {
9506 Print("\n// it is %d-th step!!", nwalk);
9507 idString(Gomega1, "Gw");
9508 PrintS("\n// compute a rGB of Gw:");
9509 }
9510#endif
9511*/
9512#ifdef TIME_TEST
9513 to=clock();
9514#endif
9515 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
9516#ifdef BUCHBERGER_ALG
9517 M = MstdhomCC(Gomega1);
9518#else
9519 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
9520 delete hilb_func;
9521#endif // BUCHBERGER_ALG
9522#ifdef TIME_TEST
9523 xtstd=xtstd+clock()-to;
9524#endif
9525
9526 // change the ring to oldRing
9527 rChangeCurrRing(oldRing);
9528 M1 = idrMoveR(M, newRing,currRing);
9529 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
9530#ifdef TIME_TEST
9531 to=clock();
9532#endif
9533
9534 // if(endwalks == 1){PrintS("\n// Lifting is still working:");}
9535
9536 // compute a reduced Groebner basis of <G> w.r.t. "newRing" by the lifting process
9537 F = MLifttwoIdeal(Gomega2, M1, G);
9538#ifdef TIME_TEST
9539 xtlift=xtlift+clock()-to;
9540#endif
9541
9542 idDelete(&M1);
9543 idDelete(&Gomega2);
9544 idDelete(&G);
9545
9546 // change the ring to newRing
9547 rChangeCurrRing(newRing);
9548 F1 = idrMoveR(F, oldRing,currRing);
9549#ifdef TIME_TEST
9550 to=clock();
9551#endif
9552 //if(endwalks == 1){ PrintS("\n// InterRed is still working:");}
9553 // reduce the Groebner basis <G> w.r.t. the new ring
9554 G = kInterRedCC(F1, NULL);
9555#ifdef TIME_TEST
9556 xtred=xtred+clock()-to;
9557#endif
9558 idDelete(&F1);
9559
9560 if(endwalks == 1)
9561 break;
9562
9563 FIRST_STEP:
9565#ifdef TIME_TEST
9566 to=clock();
9567#endif
9568 // compute a next weight vector
9569 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
9570#ifdef TIME_TEST
9571 xtnw=xtnw+clock()-to;
9572#endif
9573#ifdef PRINT_VECTORS
9574 MivString(curr_weight, target_weight, next_weight);
9575#endif
9576
9577 if(Overflow_Error == TRUE)
9578 {
9579 delete next_weight;
9580 if(tp_deg > 1){
9581 //nOverflow_Error = Overflow_Error;
9582#ifdef TIME_TEST
9583 tproc = tproc+clock()-tinput;
9584#endif
9585 //Print("\n// A subroutine takes %d steps and calls \"Mpwalk\" (1,%d):", nwalk, tp_deg-1);
9586 G1 = Mpwalk_MAltwalk1(G, curr_weight, tp_deg-1);
9587 goto MPW_Finish;
9588 }
9589 else {
9590 newRing = currRing;
9591 ntestwinC = 0;
9592 break;
9593 }
9594 }
9595
9596 if(MivComp(next_weight, ivNull) == 1)
9597 {
9598 newRing = currRing;
9599 delete next_weight;
9600 break;
9601 }
9602 if(MivComp(next_weight, target_weight) == 1)
9603 {
9604 endwalks = 1;
9605 }
9606 for(i=nV-1; i>=0; i--)
9607 {
9608 //(*extra_curr_weight)[i] = (*curr_weight)[i];
9609 (*curr_weight)[i] = (*next_weight)[i];
9610 }
9611 delete next_weight;
9612 }//while
9613
9614 // check whether the pertubed target vector is correct
9615
9616 //define and execute ring with lex. order
9617 if (rParameter(currRing) != NULL)
9618 {
9619 DefRingParlp();
9620 }
9621 else
9622 {
9623 VMrDefaultlp();
9624 }
9625 G1 = idrMoveR(G, newRing,currRing);
9626
9627 if( test_w_in_ConeCC(G1, target_weight) != 1 || ntestwinC == 0)
9628 {
9629 //PrintS("\n// The perturbed target vector doesn't STAY in the correct cone!!");
9630 if(tp_deg == 1)
9631 {
9632 //Print("\n// subroutine takes %d steps and applys \"std\"", nwalk);
9633#ifdef TIME_TEST
9634 to=clock();
9635#endif
9636 ideal G2 = MstdCC(G1);
9637#ifdef TIME_TEST
9638 xtextra=xtextra+clock()-to;
9639#endif
9640 idDelete(&G1);
9641 G1 = G2;
9642 G2 = NULL;
9643 }
9644 else
9645 {
9646 //nOverflow_Error = Overflow_Error;
9647#ifdef TIME_TEST
9648 tproc = tproc+clock()-tinput;
9649#endif
9650 // Print("\n// B subroutine takes %d steps and calls \"Mpwalk\" (1,%d) :", nwalk, tp_deg-1);
9651 G1 = Mpwalk_MAltwalk1(G1, curr_weight, tp_deg-1);
9652 }
9653 }
9654
9655 MPW_Finish:
9656 newRing = currRing;
9657 rChangeCurrRing(YXXRing);
9658 ideal result = idrMoveR(G1, newRing,currRing);
9659
9660 delete ivNull;
9661 delete target_weight;
9662
9663 //Print("\n// \"Mpwalk\" (1,%d) took %d steps and %.2f sec. Overflow_Error (%d)", tp_deg, nwalk, ((double) clock()-tinput)/1000000, nOverflow_Error);
9664 //Print("\n// Mprwalk took %d steps. Ring= %s;\n", nwalk, rString(currRing));
9665 return(result);
9666}

◆ Mrwalk()

ideal Mrwalk ( ideal  Go,
intvec orig_M,
intvec target_M,
int  weight_rad,
int  pert_deg,
int  reduction,
int  printout 
)

Definition at line 5603 of file walk.cc.

5605{
5606 BITSET save1 = si_opt_1; // save current options
5607 if(reduction == 0)
5608 {
5609 si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
5610 si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
5611 }
5612
5615#ifdef TIME_TEST
5616 clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
5617 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
5618 tinput = clock();
5619 clock_t tim;
5620#endif
5621 nstep=0;
5622 int i,nwalk;//polylength;
5623 int nV = currRing->N;
5624
5625 //check that weight radius is valid
5626 if(weight_rad < 0)
5627 {
5628 WerrorS("Invalid radius.\n");
5629 return NULL;
5630 }
5631
5632 //check that perturbation degree is valid
5633 if(pert_deg > nV || pert_deg < 1)
5634 {
5635 WerrorS("Invalid perturbation degree.\n");
5636 return NULL;
5637 }
5638
5639 ideal Gomega, M, F,FF, Gomega1, Gomega2, M1;
5640 ring newRing;
5641 ring targetRing;
5642 ring baseRing = currRing;
5643 ring XXRing = currRing;
5644 intvec* iv_M;
5645 intvec* ivNull = new intvec(nV);
5646 intvec* curr_weight = new intvec(nV);
5647 intvec* target_weight = new intvec(nV);
5648 intvec* next_weight= new intvec(nV);
5649
5650 for(i=0; i<nV; i++)
5651 {
5652 (*curr_weight)[i] = (*orig_M)[i];
5653 (*target_weight)[i] = (*target_M)[i];
5654 }
5655
5656#ifndef BUCHBERGER_ALG
5657 intvec* hilb_func;
5658 // to avoid (1,0,...,0) as the target vector
5659 intvec* last_omega = new intvec(nV);
5660 for(i=nV-1; i>0; i--)
5661 {
5662 (*last_omega)[i] = 1;
5663 }
5664 (*last_omega)[0] = 10000;
5665#endif
5667
5668 if(target_M->length() == nV)
5669 {
5670 targetRing = VMrDefault(target_weight); // define the target ring
5671 }
5672 else
5673 {
5674 targetRing = VMatrDefault(target_M);
5675 }
5676 if(orig_M->length() == nV)
5677 {
5678 //newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
5679 newRing=VMrRefine(target_weight, curr_weight);
5680 }
5681 else
5682 {
5683 newRing = VMatrRefine(target_M,curr_weight);//newRing = VMatrDefault(orig_M);
5684 }
5685 rChangeCurrRing(newRing);
5686#ifdef TIME_TEST
5687 to = clock();
5688#endif
5689 ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
5690#ifdef TIME_TEST
5691 tostd = clock()-to;
5692#endif
5693 baseRing = currRing;
5694 nwalk = 0;
5695
5696#ifdef TIME_TEST
5697 to = clock();
5698#endif
5699 Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
5700#ifdef TIME_TEST
5701 tif = tif + clock()-to; //time for computing initial form ideal
5702#endif
5703
5704 while(1)
5705 {
5706 nwalk ++;
5707 nstep ++;
5708#ifdef CHECK_IDEAL_MWALK
5709 if(printout > 1)
5710 {
5711 idString(Gomega,"//** Mrwalk: Gomega");
5712 }
5713#endif
5714 if(reduction == 0)
5715 {
5716 FF = middleOfCone(G,Gomega);
5717 if(FF != NULL)
5718 {
5719 idDelete(&G);
5720 G = idCopy(FF);
5721 idDelete(&FF);
5722 goto NEXT_VECTOR;
5723 }
5724 }
5725#ifndef BUCHBERGER_ALG
5726 if(isNolVector(curr_weight) == 0)
5727 {
5728 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
5729 }
5730 else
5731 {
5732 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
5733 }
5734#endif
5735 if(nwalk == 1)
5736 {
5737 if(orig_M->length() == nV)
5738 {
5739 /*newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)*/
5740 newRing=VMrRefine(target_weight, curr_weight);
5741 }
5742 else
5743 {
5744 newRing = VMatrRefine(target_M,curr_weight);//newRing = VMatrDefault(orig_M);
5745 }
5746 }
5747 else
5748 {
5749 if(target_M->length() == nV)
5750 {
5751 /*newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)*/
5752 newRing=VMrRefine(target_weight, curr_weight);
5753 }
5754 else
5755 {
5756 newRing = VMatrRefine(target_M,curr_weight);
5757 }
5758 }
5759 rChangeCurrRing(newRing);
5760 Gomega1 = idrMoveR(Gomega, baseRing,currRing);
5761 idDelete(&Gomega);
5762 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
5763#ifdef TIME_TEST
5764 to = clock();
5765#endif
5766#ifndef BUCHBERGER_ALG
5767 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
5768 delete hilb_func;
5769#else
5770 M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
5771#endif
5772#ifdef TIME_TEST
5773 tstd = tstd + clock() - to;
5774#endif
5775 idSkipZeroes(M);
5776#ifdef CHECK_IDEAL_MWALK
5777 if(printout > 2)
5778 {
5779 idString(M, "//** Mrwalk: M");
5780 }
5781#endif
5782 //change the ring to baseRing
5783 rChangeCurrRing(baseRing);
5784 M1 = idrMoveR(M, newRing,currRing);
5785 idDelete(&M);
5786 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
5787 idDelete(&Gomega1);
5788#ifdef TIME_TEST
5789 to = clock();
5790#endif
5791 // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
5792 // where Gomega is a reduced Groebner basis w.r.t. the current ring
5793 F = MLifttwoIdeal(Gomega2, M1, G);
5794#ifdef TIME_TEST
5795 tlift = tlift + clock() - to;
5796#endif
5797#ifdef CHECK_IDEAL_MWALK
5798 if(printout > 2)
5799 {
5800 idString(F,"//** Mrwalk: F");
5801 }
5802#endif
5803 idDelete(&Gomega2);
5804 idDelete(&M1);
5805 rChangeCurrRing(newRing); // change the ring to newRing
5806 G = idrMoveR(F,baseRing,currRing);
5807 idDelete(&F);
5808 baseRing = currRing;
5809#ifdef TIME_TEST
5810 to = clock();
5811 tstd = tstd + clock() - to;
5812#endif
5813 idSkipZeroes(G);
5814#ifdef CHECK_IDEAL_MWALK
5815 if(printout > 2)
5816 {
5817 idString(G,"//** Mrwalk: G");
5818 }
5819#endif
5820
5821 rChangeCurrRing(targetRing);
5822 G = idrMoveR(G,newRing,currRing);
5823
5824 // test whether target cone is reached
5825 if(reduction !=0 && test_w_in_ConeCC(G,curr_weight) == 1)
5826 {
5827 baseRing = currRing;
5828 break;
5829 }
5830
5831 rChangeCurrRing(newRing);
5832 G = idrMoveR(G,targetRing,currRing);
5833 baseRing = currRing;
5834
5835 NEXT_VECTOR:
5836#ifdef TIME_TEST
5837 to = clock();
5838#endif
5839 next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
5840#ifdef TIME_TEST
5841 tnw = tnw + clock() - to;
5842#endif
5843
5844#ifdef TIME_TEST
5845 to = clock();
5846#endif
5847 Gomega = MwalkInitialForm(G, next_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
5848#ifdef TIME_TEST
5849 tif = tif + clock()-to; //time for computing initial form ideal
5850#endif
5851
5852 //lengthpoly(Gomega) = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
5853 //polylength = lengthpoly(Gomega);
5854 if(lengthpoly(Gomega) > 0)
5855 {
5856 //there is a polynomial in Gomega with at least 3 monomials,
5857 //low-dimensional facet of the cone
5858 delete next_weight;
5859 if(target_M->length() == nV)
5860 {
5861 //iv_M = MivMatrixOrder(curr_weight);
5862 iv_M = MivMatrixOrderRefine(curr_weight,target_M);
5863 }
5864 else
5865 {
5866 iv_M = MivMatrixOrderRefine(curr_weight,target_M);
5867 }
5868#ifdef TIME_TEST
5869 to = clock();
5870#endif
5871 next_weight = MWalkRandomNextWeight(G, iv_M, target_weight, weight_rad, pert_deg);
5872#ifdef TIME_TEST
5873 tnw = tnw + clock() - to;
5874#endif
5875 idDelete(&Gomega);
5876#ifdef TIME_TEST
5877 to = clock();
5878#endif
5879 Gomega = MwalkInitialForm(G, next_weight);
5880#ifdef TIME_TEST
5881 tif = tif + clock()-to; //time for computing initial form ideal
5882#endif
5883 delete iv_M;
5884 }
5885
5886 // test whether target weight vector is reached
5887 if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)
5888 {
5889 baseRing = currRing;
5890 delete next_weight;
5891 break;
5892 }
5893 if(reduction ==0)
5894 {
5895 if(MivComp(curr_weight,next_weight)==1)
5896 {
5897 break;
5898 }
5899 }
5900#ifdef PRINT_VECTORS
5901 if(printout > 0)
5902 {
5903 MivString(curr_weight, target_weight, next_weight);
5904 }
5905#endif
5906
5907 for(i=nV-1; i>=0; i--)
5908 {
5909 (*curr_weight)[i] = (*next_weight)[i];
5910 }
5911 delete next_weight;
5912 }
5913 baseRing = currRing;
5914 rChangeCurrRing(XXRing);
5915 ideal result = idrMoveR(G,baseRing,currRing);
5916 idDelete(&G);
5917 delete ivNull;
5918#ifndef BUCHBERGER_ALG
5919 delete last_omega;
5920#endif
5921 if(printout > 0)
5922 {
5923 Print("\n//** Mrwalk: Groebner Walk took %d steps.\n", nstep);
5924 }
5925#ifdef TIME_TEST
5926 TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
5927 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
5928 //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
5929#endif
5930 si_opt_1 = save1; //set original options
5931 return(result);
5932}
@ testHomog
Definition: structs.h:38

◆ MstdCC()

static ideal MstdCC ( ideal  G)
static

Definition at line 932 of file walk.cc.

933{
934 BITSET save1,save2;
935 SI_SAVE_OPT(save1,save2);
937 ideal G1 = kStd(G, NULL, testHomog, NULL);
938 SI_RESTORE_OPT(save1,save2);
939
940 idSkipZeroes(G1);
941 return G1;
942}
#define SI_SAVE_OPT(A, B)
Definition: options.h:20
#define Sy_bit(x)
Definition: options.h:31
#define SI_RESTORE_OPT(A, B)
Definition: options.h:23

◆ MstdhomCC()

static ideal MstdhomCC ( ideal  G)
static

Definition at line 947 of file walk.cc.

948{
949 BITSET save1,save2;
950 SI_SAVE_OPT(save1,save2);
952 ideal G1 = kStd(G, NULL, isHomog, NULL);
953 SI_RESTORE_OPT(save1,save2);
954
955 idSkipZeroes(G1);
956 return G1;
957}

◆ Mwalk()

ideal Mwalk ( ideal  Go,
intvec orig_M,
intvec target_M,
ring  baseRing,
int  reduction,
int  printout 
)

Definition at line 5302 of file walk.cc.

5304{
5305 // save current options
5306 BITSET save1 = si_opt_1;
5307 if(reduction == 0)
5308 {
5309 si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
5310 si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
5311 }
5314 //BOOLEAN endwalks = FALSE;
5315#ifdef TIME_TEST
5316 clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
5317 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
5318 tinput = clock();
5319 clock_t tim;
5320#endif
5321 nstep=0;
5322 int i,nwalk;
5323 int nV = baseRing->N;
5324
5325 ideal Gomega, M, F, FF, Gomega1, Gomega2, M1;
5326 ring newRing;
5327 ring XXRing = baseRing;
5328 ring targetRing;
5329 intvec* ivNull = new intvec(nV);
5330 intvec* curr_weight = new intvec(nV);
5331 intvec* target_weight = new intvec(nV);
5332 intvec* exivlp = Mivlp(nV);
5333/*
5334 intvec* tmp_weight = new intvec(nV);
5335 for(i=0; i<nV; i++)
5336 {
5337 (*tmp_weight)[i] = (*orig_M)[i];
5338 }
5339*/
5340 for(i=0; i<nV; i++)
5341 {
5342 (*curr_weight)[i] = (*orig_M)[i];
5343 (*target_weight)[i] = (*target_M)[i];
5344 }
5345#ifndef BUCHBERGER_ALG
5346 intvec* hilb_func;
5347 // to avoid (1,0,...,0) as the target vector
5348 intvec* last_omega = new intvec(nV);
5349 for(i=nV-1; i>0; i--)
5350 {
5351 (*last_omega)[i] = 1;
5352 }
5353 (*last_omega)[0] = 10000;
5354#endif
5356#ifdef CHECK_IDEAL_MWALK
5357 if(printout > 2)
5358 {
5359 idString(Go,"//** Mwalk: Go");
5360 }
5361#endif
5362
5363 if(target_M->length() == nV)
5364 {
5365 // define the target ring
5366 targetRing = VMrDefault(target_weight);
5367 }
5368 else
5369 {
5370 targetRing = VMatrDefault(target_M);
5371 }
5372 if(orig_M->length() == nV)
5373 {
5374 // define a new ring with ordering "(a(curr_weight),lp)
5375 //newRing = VMrDefault(curr_weight);
5376 newRing=VMrRefine(target_weight, curr_weight);
5377 }
5378 else
5379 {
5380 newRing = VMatrRefine(target_M,curr_weight); //newRing = VMatrDefault(orig_M);
5381 }
5382 rChangeCurrRing(newRing);
5383 if(printout > 2)
5384 {
5385 Print("\n//** Mrwalk: Current ring r = %s;\n", rString(currRing));
5386 }
5387#ifdef TIME_TEST
5388 to = clock();
5389#endif
5390 ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
5391#ifdef TIME_TEST
5392 tostd = clock()-to;
5393#endif
5394
5395 baseRing = currRing;
5396 nwalk = 0;
5397
5398 while(1)
5399 {
5400 nwalk ++;
5401 nstep ++;
5402 //compute an initial form ideal of <G> w.r.t. "curr_vector"
5403#ifdef TIME_TEST
5404 to = clock();
5405#endif
5406 Gomega = MwalkInitialForm(G, curr_weight);
5407#ifdef TIME_TEST
5408 tif = tif + clock()-to;
5409#endif
5410
5411#ifdef CHECK_IDEAL_MWALK
5412 if(printout > 1)
5413 {
5414 idString(Gomega,"//** Mwalk: Gomega");
5415 }
5416#endif
5417
5418 if(reduction == 0)
5419 {
5420 FF = middleOfCone(G,Gomega);
5421 if(FF != NULL)
5422 {
5423 PrintS("middle of Cone");
5424 idDelete(&G);
5425 G = idCopy(FF);
5426 idDelete(&FF);
5427 goto NEXT_VECTOR;
5428 }
5429 }
5430
5431#ifndef BUCHBERGER_ALG
5432 if(isNolVector(curr_weight) == 0)
5433 {
5434 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
5435 }
5436 else
5437 {
5438 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
5439 }
5440#endif
5441
5442 if(nwalk == 1)
5443 {
5444 if(orig_M->length() == nV)
5445 {
5446 // define a new ring with ordering "(a(curr_weight),lp)
5447 //newRing = VMrDefault(curr_weight);
5448 newRing=VMrRefine(target_weight, curr_weight);
5449 }
5450 else
5451 {
5452 newRing = VMatrRefine(target_M,curr_weight);//newRing = VMatrDefault(orig_M);
5453 }
5454 }
5455 else
5456 {
5457 if(target_M->length() == nV)
5458 {
5459 //define a new ring with ordering "(a(curr_weight),lp)"
5460 //newRing = VMrDefault(curr_weight);
5461 newRing=VMrRefine(target_weight, curr_weight);
5462 }
5463 else
5464 {
5465 //define a new ring with matrix ordering
5466 newRing = VMatrRefine(target_M,curr_weight);
5467 }
5468 }
5469 rChangeCurrRing(newRing);
5470 if(printout > 2)
5471 {
5472 Print("\n// Current ring r = %s;\n", rString(currRing));
5473 }
5474 Gomega1 = idrMoveR(Gomega, baseRing,currRing);
5475 idDelete(&Gomega);
5476 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
5477#ifdef TIME_TEST
5478 to = clock();
5479#endif
5480#ifndef BUCHBERGER_ALG
5481 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
5482 delete hilb_func;
5483#else
5484 M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
5485#endif
5486#ifdef TIME_TEST
5487 tstd = tstd + clock() - to;
5488#endif
5489 idSkipZeroes(M);
5490#ifdef CHECK_IDEAL_MWALK
5491 if(printout > 2)
5492 {
5493 idString(M, "//** Mwalk: M");
5494 }
5495#endif
5496 //change the ring to baseRing
5497 rChangeCurrRing(baseRing);
5498 M1 = idrMoveR(M, newRing,currRing);
5499 idDelete(&M);
5500 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
5501 idDelete(&Gomega1);
5502#ifdef TIME_TEST
5503 to = clock();
5504#endif
5505 // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
5506 // where Gomega is a reduced Groebner basis w.r.t. the current ring
5507 F = MLifttwoIdeal(Gomega2, M1, G);
5508#ifdef TIME_TEST
5509 tlift = tlift + clock() - to;
5510#endif
5511#ifdef CHECK_IDEAL_MWALK
5512 if(printout > 2)
5513 {
5514 idString(F, "//** Mwalk: F");
5515 }
5516#endif
5517 idDelete(&Gomega2);
5518 idDelete(&M1);
5519
5520 rChangeCurrRing(newRing); // change the ring to newRing
5521 G = idrMoveR(F,baseRing,currRing);
5522 idDelete(&F);
5523 idSkipZeroes(G);
5524
5525#ifdef CHECK_IDEAL_MWALK
5526 if(printout > 2)
5527 {
5528 idString(G, "//** Mwalk: G");
5529 }
5530#endif
5531
5532 rChangeCurrRing(targetRing);
5533 G = idrMoveR(G,newRing,currRing);
5534 // test whether target cone is reached
5535 if(reduction !=0 && test_w_in_ConeCC(G,curr_weight) == 1)
5536 {
5537 baseRing = currRing;
5538 break;
5539 //endwalks = TRUE;
5540 }
5541
5542 rChangeCurrRing(newRing);
5543 G = idrMoveR(G,targetRing,currRing);
5544 baseRing = currRing;
5545
5546 NEXT_VECTOR:
5547#ifdef TIME_TEST
5548 to = clock();
5549#endif
5550 intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
5551#ifdef TIME_TEST
5552 tnw = tnw + clock() - to;
5553#endif
5554#ifdef PRINT_VECTORS
5555 if(printout > 0)
5556 {
5557 MivString(curr_weight, target_weight, next_weight);
5558 }
5559#endif
5560 if(reduction ==0)
5561 {
5562 if(MivComp(curr_weight,next_weight)==1)
5563 {
5564 break;
5565 }
5566 }
5567 if(MivComp(target_weight,curr_weight) == 1)
5568 {
5569 break;
5570 }
5571
5572 for(i=nV-1; i>=0; i--)
5573 {
5574 //(*tmp_weight)[i] = (*curr_weight)[i];
5575 (*curr_weight)[i] = (*next_weight)[i];
5576 }
5577 delete next_weight;
5578 }
5579 rChangeCurrRing(XXRing);
5580 ideal result = idrMoveR(G,baseRing,currRing);
5581 idDelete(&Go);
5582 idDelete(&G);
5583 //delete tmp_weight;
5584 delete ivNull;
5585 delete exivlp;
5586#ifndef BUCHBERGER_ALG
5587 delete last_omega;
5588#endif
5589#ifdef TIME_TEST
5590 TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
5591 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
5592 //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
5593#endif
5594 if(printout > 0)
5595 {
5596 Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
5597 }
5598 si_opt_1 = save1; //set original options
5599 return(result);
5600}

◆ MwalkAlt()

ideal MwalkAlt ( ideal  Go,
intvec curr_weight,
intvec target_weight 
)

Definition at line 5027 of file walk.cc.

5028{
5031 //Print("// pSetm_Error = (%d)", ErrorCheck());
5032
5033#ifdef TIME_TEST
5034 clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
5035 tinput = clock();
5036 clock_t tim;
5037 xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
5038#endif
5039 nstep=0;
5040 int i;
5041 int nV = currRing->N;
5042 int nwalk=0;
5043 int endwalks=0;
5044
5045 ideal Gomega, M, F, Gomega1, Gomega2, M1, F1, G;
5046
5047 ring newRing, oldRing;
5048 intvec* ivNull = new intvec(nV);
5049 intvec* exivlp = Mivlp(nV);
5050#ifndef BUCHBERGER_ALG
5051 intvec* hilb_func;
5052#endif
5053 intvec* tmp_weight = new intvec(nV);
5054 for(i=nV-1; i>=0; i--)
5055 (*tmp_weight)[i] = (*curr_weight)[i];
5056
5057 // to avoid (1,0,...,0) as the target vector
5058 intvec* last_omega = new intvec(nV);
5059 for(i=nV-1; i>0; i--)
5060 (*last_omega)[i] = 1;
5061 (*last_omega)[0] = 10000;
5062
5063 ring XXRing = currRing;
5064
5065#ifdef TIME_TEST
5066 to = clock();
5067#endif
5068 // the monomial ordering of this current ring would be "dp"
5069 G = MstdCC(Go);
5070#ifdef TIME_TEST
5071 tostd = clock()-to;
5072#endif
5073
5074 if(currRing->order[0] == ringorder_a)
5075 goto NEXT_VECTOR;
5076
5077 while(1)
5078 {
5079 nwalk ++;
5080 nstep ++;
5081#ifdef TIME_TEST
5082 to = clock();
5083#endif
5084 // compute an initial form ideal of <G> w.r.t. "curr_vector"
5085 Gomega = MwalkInitialForm(G, curr_weight);
5086#ifdef TIME_TEST
5087 tif = tif + clock()-to;
5088#endif
5089 oldRing = currRing;
5090
5091 if(endwalks == 1)
5092 {
5093 /* compute a reduced Groebner basis of Gomega w.r.t. >>_cw by
5094 the recursive changed perturbation walk alg. */
5095#ifdef TIME_TEST
5096 tim = clock();
5097#endif
5098#ifdef CHECK_IDEAL_MWALK
5099 Print("\n// **** Groebnerwalk took %d steps and ", nwalk);
5100 PrintS("\n// **** call the rec. Pert. Walk to compute a red GB of:");
5101 idString(Gomega, "Gomega");
5102#endif
5103
5104 if(MivSame(exivlp, target_weight)==1)
5105 M = REC_GB_Mwalk(idCopy(Gomega), tmp_weight, curr_weight, 2,1);
5106 else
5107 goto NORMAL_GW;
5108#ifdef TIME_TEST
5109 Print("\n// time for the last std(Gw) = %.2f sec",
5110 ((double) (clock()-tim)/1000000));
5111#endif
5112/*
5113#ifdef CHECK_IDEAL_MWALK
5114 idElements(Gomega, "G_omega");
5115 headidString(Gomega, "Gw");
5116 idElements(M, "M");
5117 //headidString(M, "M");
5118#endif
5119*/
5120#ifdef TIME_TEST
5121 to = clock();
5122#endif
5123 F = MLifttwoIdeal(Gomega, M, G);
5124#ifdef TIME_TEST
5125 xtlift = xtlift + clock() - to;
5126#endif
5127
5128 idDelete(&Gomega);
5129 idDelete(&M);
5130 idDelete(&G);
5131
5132 oldRing = currRing;
5133
5134 // create a new ring newRing
5135 if (rParameter(currRing) != NULL)
5136 {
5137 DefRingPar(curr_weight);
5138 }
5139 else
5140 {
5141 rChangeCurrRing(VMrDefault(curr_weight));
5142 }
5143 newRing = currRing;
5144 F1 = idrMoveR(F, oldRing,currRing);
5145 }
5146 else
5147 {
5148 NORMAL_GW:
5149#ifndef BUCHBERGER_ALG
5150 if(isNolVector(curr_weight) == 0)
5151 {
5152 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
5153 }
5154 else
5155 {
5156 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
5157 }
5158#endif // BUCHBERGER_ALG
5159
5160 // define a new ring that its ordering is "(a(curr_weight),lp)
5161 if (rParameter(currRing) != NULL)
5162 {
5163 DefRingPar(curr_weight);
5164 }
5165 else
5166 {
5167 rChangeCurrRing(VMrDefault(curr_weight));
5168 }
5169 newRing = currRing;
5170 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
5171
5172#ifdef TIME_TEST
5173 to = clock();
5174#endif
5175 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
5176#ifdef BUCHBERGER_ALG
5177 M = MstdhomCC(Gomega1);
5178#else
5179 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
5180 delete hilb_func;
5181#endif
5182#ifdef TIME_TEST
5183 tstd = tstd + clock() - to;
5184#endif
5185
5186 // change the ring to oldRing
5187 rChangeCurrRing(oldRing);
5188 M1 = idrMoveR(M, newRing,currRing);
5189 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
5190
5191#ifdef TIME_TEST
5192 to = clock();
5193#endif
5194 // compute a representation of the generators of submod (M) with respect
5195 // to those of mod (Gomega).
5196 // Gomega is a reduced Groebner basis w.r.t. the current ring.
5197 F = MLifttwoIdeal(Gomega2, M1, G);
5198#ifdef TIME_TEST
5199 tlift = tlift + clock() - to;
5200#endif
5201
5202 idDelete(&M1);
5203 idDelete(&Gomega2);
5204 idDelete(&G);
5205
5206 // change the ring to newRing
5207 rChangeCurrRing(newRing);
5208 F1 = idrMoveR(F, oldRing,currRing);
5209 }
5210
5211#ifdef TIME_TEST
5212 to = clock();
5213#endif
5214 // reduce the Groebner basis <G> w.r.t. new ring
5215 G = kInterRedCC(F1, NULL);
5216#ifdef TIME_TEST
5217 if(endwalks != 1)
5218 {
5219 tred = tred + clock() - to;
5220 }
5221 else
5222 {
5223 xtred = xtred + clock() - to;
5224 }
5225#endif
5226 idDelete(&F1);
5227 if(endwalks == 1)
5228 {
5229 break;
5230 }
5231 NEXT_VECTOR:
5232#ifdef TIME_TEST
5233 to = clock();
5234#endif
5235 // compute a next weight vector
5236 intvec* next_weight = MkInterRedNextWeight(curr_weight,target_weight,G);
5237#ifdef TIME_TEST
5238 tnw = tnw + clock() - to;
5239#endif
5240#ifdef PRINT_VECTORS
5241 MivString(curr_weight, target_weight, next_weight);
5242#endif
5243
5244 //if(test_w_in_ConeCC(G, next_weight) != 1)
5245 if(Overflow_Error == TRUE)
5246 {
5247 newRing = currRing;
5248 PrintS("\n// ** The computed vector does NOT stay in Cone!!\n");
5249
5250 if (rParameter(currRing) != NULL)
5251 {
5252 DefRingPar(target_weight);
5253 }
5254 else
5255 {
5256 rChangeCurrRing(VMrDefault(target_weight));
5257 }
5258 F1 = idrMoveR(G, newRing,currRing);
5259 G = MstdCC(F1);
5260 idDelete(&F1);
5261
5262 newRing = currRing;
5263 break;
5264 }
5265
5266 if(MivComp(next_weight, ivNull) == 1)
5267 {
5268 newRing = currRing;
5269 delete next_weight;
5270 break;
5271 }
5272 if(MivComp(next_weight, target_weight) == 1)
5273 {
5274 endwalks = 1;
5275 }
5276 for(i=nV-1; i>=0; i--)
5277 {
5278 (*tmp_weight)[i] = (*curr_weight)[i];
5279 (*curr_weight)[i] = (*next_weight)[i];
5280 }
5281 delete next_weight;
5282 }
5283 rChangeCurrRing(XXRing);
5284 G = idrMoveR(G, newRing,currRing);
5285
5286 delete tmp_weight;
5287 delete ivNull;
5288 delete exivlp;
5289
5290#ifdef TIME_TEST
5291 TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
5292
5293 //Print("\n// pSetm_Error = (%d)", ErrorCheck());
5294 Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
5295#endif
5296 return(G);
5297}
static ideal REC_GB_Mwalk(ideal G, intvec *curr_weight, intvec *orig_target_weight, int tp_deg, int npwinc)
Definition: walk.cc:4719

◆ MwalkInitialForm()

ideal MwalkInitialForm ( ideal  G,
intvec ivw 
)

Definition at line 761 of file walk.cc.

762{
763 BOOLEAN nError = Overflow_Error;
765
766 int i, nG = IDELEMS(G);
767 ideal Gomega = idInit(nG, 1);
768
769 for(i=nG-1; i>=0; i--)
770 {
771 Gomega->m[i] = MpolyInitialForm(G->m[i], ivw);
772 }
773 if(Overflow_Error == FALSE)
774 {
775 Overflow_Error = nError;
776 }
777 return Gomega;
778}
static poly MpolyInitialForm(poly g, intvec *curr_weight)
Definition: walk.cc:722

◆ MwalkNextWeightCC()

static intvec * MwalkNextWeightCC ( intvec curr_weight,
intvec target_weight,
ideal  G 
)
static

Definition at line 2228 of file walk.cc.

2230{
2231 BOOLEAN nError = Overflow_Error;
2233
2234 assume(currRing != NULL && curr_weight != NULL &&
2235 target_weight != NULL && G != NULL);
2236
2237 int nRing = currRing->N;
2238 int j, nG = IDELEMS(G);
2239 intvec* ivtemp;
2240
2241 mpz_t t_zaehler, t_nenner;
2242 mpz_init(t_zaehler);
2243 mpz_init(t_nenner);
2244
2245 mpz_t s_zaehler, s_nenner, temp, MwWd;
2246 mpz_init(s_zaehler);
2247 mpz_init(s_nenner);
2248 mpz_init(temp);
2249 mpz_init(MwWd);
2250
2251 mpz_t sing_int;
2252 mpz_init(sing_int);
2253 mpz_set_ui(sing_int, 2147483647);
2254
2255 mpz_t sing_int_half;
2256 mpz_init(sing_int_half);
2257 mpz_set_ui(sing_int_half, 3*(1073741824/2));
2258
2259 mpz_t deg_w0_p1, deg_d0_p1;
2260 mpz_init(deg_w0_p1);
2261 mpz_init(deg_d0_p1);
2262
2263 mpz_t sztn, sntz;
2264 mpz_init(sztn);
2265 mpz_init(sntz);
2266
2267 mpz_t t_null;
2268 mpz_init(t_null);
2269
2270 mpz_t ggt;
2271 mpz_init(ggt);
2272
2273 mpz_t dcw;
2274 mpz_init(dcw);
2275
2276 int gcd_tmp;
2277 //intvec* diff_weight = MivSub(target_weight, curr_weight);
2278
2279 intvec* diff_weight1 = new intvec(nRing); //MivSub(target_weight, curr_weight);
2280 poly g;
2281
2282 // reduce the size of the entries of the current weight vector
2283 if(TEST_OPT_REDSB)
2284 {
2285 for (j=0; j<nRing; j++)
2286 {
2287 (*diff_weight1)[j] = (*curr_weight)[j];
2288 }
2289 while(MivAbsMax(diff_weight1)>10000 && test_w_in_ConeCC(G,diff_weight1)==1)
2290 {
2291 for(j=0; j<nRing; j++)
2292 {
2293 (*curr_weight)[j] = (*diff_weight1)[j];
2294 }
2295 for(j=0; j<nRing; j++)
2296 {
2297 (*diff_weight1)[j] = ((*diff_weight1)[j] + 5) / 10;
2298 }
2299 }
2300
2301 if(MivAbsMax(curr_weight)>100000)
2302 {
2303 for(j=0; j<nRing; j++)
2304 {
2305 (*diff_weight1)[j] = (*curr_weight)[j];
2306 }
2307 j = 0;
2308 while(test_w_in_ConeCC(G,diff_weight1)==1 && MivAbsMax(diff_weight1)>1000)
2309 {
2310 (*curr_weight)[j] = (*diff_weight1)[j];
2311 j = MivAbsMaxArg(diff_weight1);
2312 (*diff_weight1)[j] = ((*diff_weight1)[j] + 5) / 10;
2313 }
2314 }
2315
2316 }
2317 intvec* diff_weight = MivSub(target_weight, curr_weight);
2318
2319 // compute a suitable next weight vector
2320 for (j=0; j<nG; j++)
2321 {
2322 g = G->m[j];
2323 if (g != NULL)
2324 {
2325 ivtemp = MExpPol(g);
2326 mpz_set_si(deg_w0_p1, MivDotProduct(ivtemp, curr_weight));
2327 mpz_set_si(deg_d0_p1, MivDotProduct(ivtemp, diff_weight));
2328 delete ivtemp;
2329
2330 pIter(g);
2331 while (g != NULL)
2332 {
2333 ivtemp = MExpPol(g);
2334 mpz_set_si(MwWd, MivDotProduct(ivtemp, curr_weight));
2335 mpz_sub(s_zaehler, deg_w0_p1, MwWd);
2336 if(mpz_cmp(s_zaehler, t_null) != 0)
2337 {
2338 mpz_set_si(MwWd, MivDotProduct(ivtemp, diff_weight));
2339 mpz_sub(s_nenner, MwWd, deg_d0_p1);
2340 // check for 0 < s <= 1
2341 if( (mpz_cmp(s_zaehler,t_null) > 0 &&
2342 mpz_cmp(s_nenner, s_zaehler)>=0) ||
2343 (mpz_cmp(s_zaehler, t_null) < 0 &&
2344 mpz_cmp(s_nenner, s_zaehler)<=0))
2345 {
2346 // make both positive
2347 if (mpz_cmp(s_zaehler, t_null) < 0)
2348 {
2349 mpz_neg(s_zaehler, s_zaehler);
2350 mpz_neg(s_nenner, s_nenner);
2351 }
2352
2353 //compute a simple fraction of s
2354 cancel(s_zaehler, s_nenner);
2355
2356 if(mpz_cmp(t_nenner, t_null) != 0)
2357 {
2358 mpz_mul(sztn, s_zaehler, t_nenner);
2359 mpz_mul(sntz, s_nenner, t_zaehler);
2360
2361 if(mpz_cmp(sztn,sntz) < 0)
2362 {
2363 mpz_add(t_nenner, t_null, s_nenner);
2364 mpz_add(t_zaehler,t_null, s_zaehler);
2365 }
2366 }
2367 else
2368 {
2369 mpz_add(t_nenner, t_null, s_nenner);
2370 mpz_add(t_zaehler,t_null, s_zaehler);
2371 }
2372 }
2373 }
2374 pIter(g);
2375 delete ivtemp;
2376 }
2377 }
2378 }
2379 //Print("\n// Alloc Size = %d \n", nRing*sizeof(mpz_t));
2380 mpz_t *vec=(mpz_t*)omAlloc(nRing*sizeof(mpz_t));
2381
2382
2383 // there is no 0<t<1 and define the next weight vector that is equal
2384 // to the current weight vector
2385 if(mpz_cmp(t_nenner, t_null) == 0)
2386 {
2387#ifndef SING_NDEBUG
2388 PrintS("\n//MwalkNextWeightCC: t_nenner=0\n");
2389#endif
2390 delete diff_weight;
2391 diff_weight = ivCopy(curr_weight);//take memory
2392 goto FINISH;
2393 }
2394
2395 // define the target vector as the next weight vector, if t = 1
2396 if(mpz_cmp_si(t_nenner, 1)==0 && mpz_cmp_si(t_zaehler,1)==0)
2397 {
2398 delete diff_weight;
2399 diff_weight = ivCopy(target_weight); //this takes memory
2400 goto FINISH;
2401 }
2402
2403 //SIMPLIFY_GCD:
2404
2405 // simplify the vectors curr_weight and diff_weight (C-int)
2406 gcd_tmp = (*curr_weight)[0];
2407
2408 for (j=1; j<nRing; j++)
2409 {
2410 gcd_tmp = gcd(gcd_tmp, (*curr_weight)[j]);
2411 if(gcd_tmp == 1)
2412 {
2413 break;
2414 }
2415 }
2416 if(gcd_tmp != 1)
2417 {
2418 for (j=0; j<nRing; j++)
2419 {
2420 gcd_tmp = gcd(gcd_tmp, (*diff_weight)[j]);
2421 if(gcd_tmp == 1)
2422 {
2423 break;
2424 }
2425 }
2426 }
2427 if(gcd_tmp != 1)
2428 {
2429 for (j=0; j<nRing; j++)
2430 {
2431 (*curr_weight)[j] = (*curr_weight)[j]/gcd_tmp;
2432 (*diff_weight)[j] = (*diff_weight)[j]/gcd_tmp;
2433 }
2434 }
2435
2436#ifdef NEXT_VECTORS_CC
2437 Print("\n// gcd of the weight vectors (current and target) = %d", gcd_tmp);
2438 ivString(curr_weight, "new cw");
2439 ivString(diff_weight, "new dw");
2440
2441 PrintS("\n// t_zaehler: "); mpz_out_str( stdout, 10, t_zaehler);
2442 PrintS(", t_nenner: "); mpz_out_str( stdout, 10, t_nenner);
2443#endif
2444
2445// construct a new weight vector and check whether vec[j] is overflow, i.e. vec[j] > 2^31.
2446// If vec[j] doesn't overflow, define a weight vector. Otherwise, report that overflow
2447// appears. In the second case, test whether the the correctness of the new vector plays
2448// an important role
2449
2450 for (j=0; j<nRing; j++)
2451 {
2452 mpz_set_si(dcw, (*curr_weight)[j]);
2453 mpz_mul(s_nenner, t_nenner, dcw);
2454
2455 if( (*diff_weight)[j]>0)
2456 {
2457 mpz_mul_ui(s_zaehler, t_zaehler, (*diff_weight)[j]);
2458 }
2459 else
2460 {
2461 mpz_mul_ui(s_zaehler, t_zaehler, -(*diff_weight)[j]);
2462 mpz_neg(s_zaehler, s_zaehler);
2463 }
2464 mpz_add(sntz, s_nenner, s_zaehler);
2465 mpz_init_set(vec[j], sntz);
2466
2467#ifdef NEXT_VECTORS_CC
2468 Print("\n// j = %d ==> ", j);
2469 PrintS("(");
2470 mpz_out_str( stdout, 10, t_nenner);
2471 Print(" * %d)", (*curr_weight)[j]);
2472 PrintS(" + ("); mpz_out_str( stdout, 10, t_zaehler);
2473 Print(" * %d) = ", (*diff_weight)[j]);
2474 mpz_out_str( stdout, 10, s_nenner);
2475 PrintS(" + ");
2476 mpz_out_str( stdout, 10, s_zaehler);
2477 PrintS(" = "); mpz_out_str( stdout, 10, sntz);
2478 Print(" ==> vector[%d]: ", j); mpz_out_str(stdout, 10, vec[j]);
2479#endif
2480
2481 if(j==0)
2482 {
2483 mpz_set(ggt, sntz);
2484 }
2485 else
2486 {
2487 if(mpz_cmp_si(ggt,1) != 0)
2488 {
2489 mpz_gcd(ggt, ggt, sntz);
2490 }
2491 }
2492 }
2493 // reduce the vector with the gcd
2494 if(mpz_cmp_si(ggt,1) != 0)
2495 {
2496 for (j=0; j<nRing; j++)
2497 {
2498 mpz_divexact(vec[j], vec[j], ggt);
2499 }
2500 }
2501#ifdef NEXT_VECTORS_CC
2502 PrintS("\n// gcd of elements of the vector: ");
2503 mpz_out_str( stdout, 10, ggt);
2504#endif
2505
2506 for (j=0; j<nRing; j++)
2507 {
2508 (*diff_weight)[j] = mpz_get_si(vec[j]);
2509 }
2510
2511 //TEST_OVERFLOW:
2512
2513 for (j=0; j<nRing; j++)
2514 {
2515 if(mpz_cmp(vec[j], sing_int)>=0)
2516 {
2517 if(Overflow_Error == FALSE)
2518 {
2520 PrintS("\n// ** OVERFLOW in \"MwalkNextWeightCC\": ");
2521 mpz_out_str( stdout, 10, vec[j]);
2522 PrintS(" is greater than 2147483647 (max. integer representation)\n");
2523 //Print("// So vector[%d] := %d is wrong!!\n",j+1, vec[j]);// vec[j] is mpz_t
2524 }
2525 }
2526 }
2527
2528 FINISH:
2529 delete diff_weight1;
2530 mpz_clear(t_zaehler);
2531 mpz_clear(t_nenner);
2532 mpz_clear(s_zaehler);
2533 mpz_clear(s_nenner);
2534 mpz_clear(sntz);
2535 mpz_clear(sztn);
2536 mpz_clear(temp);
2537 mpz_clear(MwWd);
2538 mpz_clear(deg_w0_p1);
2539 mpz_clear(deg_d0_p1);
2540 mpz_clear(ggt);
2541 omFree(vec);
2542 mpz_clear(sing_int_half);
2543 mpz_clear(sing_int);
2544 mpz_clear(dcw);
2545 mpz_clear(t_null);
2546
2547 if(Overflow_Error == FALSE)
2548 {
2549 Overflow_Error = nError;
2550 }
2552 for(j=0; j<IDELEMS(G); j++)
2553 {
2554 poly p=G->m[j];
2555 while(p!=NULL)
2556 {
2557 p_Setm(p,currRing);
2558 pIter(p);
2559 }
2560 }
2561return diff_weight;
2562}
intvec * ivCopy(const intvec *o)
Definition: intvec.h:145
static int MivAbsMaxArg(intvec *vec)
Definition: walk.cc:1850
static void cancel(mpz_t zaehler, mpz_t nenner)
Definition: walk.cc:588
static intvec * MExpPol(poly f)
Definition: walk.cc:877
static intvec * MivSub(intvec *a, intvec *b)
Definition: walk.cc:861
static long MivDotProduct(intvec *a, intvec *b)
Definition: walk.cc:845

◆ MWalkRandomNextWeight()

static intvec * MWalkRandomNextWeight ( ideal  G,
intvec orig_M,
intvec target_weight,
int  weight_rad,
int  pert_deg 
)
static

Definition at line 4516 of file walk.cc.

4518{
4519 assume(currRing != NULL && orig_M != NULL &&
4520 target_weight != NULL && G->m[0] != NULL);
4521
4522 //BOOLEAN nError = Overflow_Error;
4524
4525 BOOLEAN found_random_weight = FALSE;
4526 int i,nV = currRing->N;
4527 intvec* curr_weight = new intvec(nV);
4528
4529 for(i=0; i<nV; i++)
4530 {
4531 (*curr_weight)[i] = (*orig_M)[i];
4532 }
4533
4534 int k=0,weight_norm;
4535 intvec* next_weight;
4536 intvec* next_weight1 = MkInterRedNextWeight(curr_weight,target_weight,G);
4537 intvec* next_weight2 = new intvec(nV);
4538 intvec* result = new intvec(nV);
4539 intvec* curr_weight1;
4540 ideal G_test, G_test1, G_test2;
4541
4542 //try to find a random next weight vector "next_weight2"
4543 if(weight_rad > 0)
4544 {
4545 while(k<10)
4546 {
4547 weight_norm = 0;
4548 while(weight_norm == 0)
4549 {
4550 for(i=0; i<nV; i++)
4551 {
4552 (*next_weight2)[i] = rand() % 60000 - 30000;
4553 weight_norm = weight_norm + (*next_weight2)[i]*(*next_weight2)[i];
4554 }
4555 weight_norm = 1 + static_cast<int>(sqrt(double(weight_norm)));
4556 }
4557 for(i=0; i<nV; i++)
4558 {
4559 if((*next_weight2)[i] < 0)
4560 {
4561 (*next_weight2)[i] = 1 + (*curr_weight)[i] + weight_rad*(*next_weight2)[i]/weight_norm;
4562 }
4563 else
4564 {
4565 (*next_weight2)[i] = (*curr_weight)[i] + weight_rad*(*next_weight2)[i]/weight_norm;
4566 }
4567 }
4568 if(test_w_in_ConeCC(G,next_weight2) == 1)
4569 {
4570 if(maxlengthpoly(MwalkInitialForm(G,next_weight2))<2)
4571 {
4572 next_weight2 = MkInterRedNextWeight(next_weight2,target_weight,G);
4573 }
4574 G_test2 = MwalkInitialForm(G, next_weight2);
4575 found_random_weight = TRUE;
4576 break;
4577 }
4578 k++;
4579 }
4580 }
4581
4582 // compute "perturbed" next weight vector
4583 if(pert_deg > 1)
4584 {
4585 curr_weight1 = MPertVectors(G,orig_M,pert_deg);
4586 next_weight = MkInterRedNextWeight(curr_weight1,target_weight,G);
4587 delete curr_weight1;
4588 }
4589 else
4590 {
4591 next_weight = MkInterRedNextWeight(curr_weight,target_weight,G);
4592 }
4593 if(MivSame(curr_weight,next_weight)==1 || Overflow_Error == TRUE)
4594 {
4596 delete next_weight;
4597 next_weight = MkInterRedNextWeight(curr_weight,target_weight,G);
4598 }
4599 G_test=MwalkInitialForm(G,next_weight);
4600 G_test1=MwalkInitialForm(G,next_weight1);
4601
4602 // compare next weights
4603 if(Overflow_Error == FALSE)
4604 {
4605 if(found_random_weight == TRUE)
4606 {
4607 // random next weight vector found
4608 if(G_test1->m[0] != NULL && maxlengthpoly(G_test1) < maxlengthpoly(G_test))
4609 {
4610 if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test1))
4611 {
4612 for(i=0; i<nV; i++)
4613 {
4614 (*result)[i] = (*next_weight2)[i];
4615 }
4616 }
4617 else
4618 {
4619 for(i=0; i<nV; i++)
4620 {
4621 (*result)[i] = (*next_weight1)[i];
4622 }
4623 }
4624 }
4625 else
4626 {
4627 if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))
4628 {
4629 for(i=0; i<nV; i++)
4630 {
4631 (*result)[i] = (*next_weight2)[i];
4632 }
4633 }
4634 else
4635 {
4636 for(i=0; i<nV; i++)
4637 {
4638 (*result)[i] = (*next_weight)[i];
4639 }
4640 }
4641 }
4642 }
4643 else
4644 {
4645 // no random next weight vector found
4646 if(G_test1->m[0] != NULL && maxlengthpoly(G_test1) < maxlengthpoly(G_test))
4647 {
4648 for(i=0; i<nV; i++)
4649 {
4650 (*result)[i] = (*next_weight1)[i];
4651 }
4652 }
4653 else
4654 {
4655 for(i=0; i<nV; i++)
4656 {
4657 (*result)[i] = (*next_weight)[i];
4658 }
4659 }
4660 }
4661 }
4662 else
4663 {
4665 if(found_random_weight == TRUE)
4666 {
4667 if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))
4668 {
4669 for(i=1; i<nV; i++)
4670 {
4671 (*result)[i] = (*next_weight2)[i];
4672 }
4673 }
4674 else
4675 {
4676 for(i=0; i<nV; i++)
4677 {
4678 (*result)[i] = (*next_weight)[i];
4679 }
4680 }
4681 }
4682 else
4683 {
4684 for(i=0; i<nV; i++)
4685 {
4686 (*result)[i] = (*next_weight)[i];
4687 }
4688 }
4689 }
4690
4691 delete next_weight;
4692 delete next_weight2;
4693 idDelete(&G_test);
4694 idDelete(&G_test1);
4695 if(found_random_weight == TRUE)
4696 {
4697 idDelete(&G_test2);
4698 }
4699 if(test_w_in_ConeCC(G, result) == 1 && MivSame(curr_weight,result)==0)
4700 {
4701 delete curr_weight;
4702 delete next_weight1;
4703 return result;
4704 }
4705 else
4706 {
4707 delete curr_weight;
4708 delete result;
4709 return next_weight1;
4710 }
4711}
gmp_float sqrt(const gmp_float &a)
Definition: mpr_complex.cc:327
static int maxlengthpoly(ideal G)
Definition: walk.cc:3460

◆ MwalkWeightDegree()

static int MwalkWeightDegree ( poly  p,
intvec weight_vector 
)
inlinestatic

Definition at line 668 of file walk.cc.

669{
670 assume(weight_vector->length() >= currRing->N);
671 int max = 0, maxtemp;
672
673 while(p != NULL)
674 {
675 maxtemp = MLmWeightedDegree(p, weight_vector);
676 pIter(p);
677
678 if (maxtemp > max)
679 {
680 max = maxtemp;
681 }
682 }
683 return max;
684}
static int MLmWeightedDegree(const poly p, intvec *weight)
Definition: walk.cc:621

◆ NewVectorlp()

static intvec * NewVectorlp ( ideal  I)
static

Definition at line 4496 of file walk.cc.

4497{
4498 int nV = currRing->N;
4499 intvec* iv_wlp = MivMatrixOrderlp(nV);
4500 intvec* result = Mfpertvector(I, iv_wlp);
4501 delete iv_wlp;
4502 return result;
4503}

◆ rec_fractal_call()

static ideal rec_fractal_call ( ideal  G,
int  nlev,
intvec ivtarget,
int  reduction,
int  printout 
)
static

Definition at line 6951 of file walk.cc.

6953{
6955 if(printout >0)
6956 {
6957 Print("\n\n// Entering the %d-th recursion:", nlev);
6958 }
6959 int i, nV = currRing->N;
6960 ring new_ring, testring;
6961 //ring extoRing;
6962 ideal Gomega, Gomega1, Gomega2, FF, F, Gresult, Gresult1, G1, Gt;
6963 int nwalks = 0;
6964 intvec* Mwlp;
6965#ifndef BUCHBERGER_ALG
6966 intvec* hilb_func;
6967#endif
6968 //intvec* extXtau;
6969 intvec* next_vect;
6970 intvec* omega2 = new intvec(nV);
6971 intvec* omtmp = new intvec(nV);
6972 //intvec* altomega = new intvec(nV);
6973
6974 for(i = nV -1; i>=0; i--)//Aenderung!!
6975 {
6976 (*omtmp)[i] = (*ivtarget)[i];
6977 }
6978 //BOOLEAN isnewtarget = FALSE;
6979
6980 // to avoid (1,0,...,0) as the target vector (Hans)
6981 intvec* last_omega = new intvec(nV);
6982 for(i=nV-1; i>0; i--)
6983 (*last_omega)[i] = 1;
6984 (*last_omega)[0] = 10000;
6985
6986 intvec* omega = new intvec(nV);
6987 for(i=0; i<nV; i++) {
6988 if(Xsigma->length() == nV)
6989 (*omega)[i] = (*Xsigma)[i];
6990 else
6991 (*omega)[i] = (*Xsigma)[(nV*(nlev-1))+i];
6992
6993 (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
6994 }
6995
6996 if(nlev == 1) Xcall = 1;
6997 else Xcall = 0;
6998
6999 ring oRing = currRing;
7000
7001 while(1)
7002 {
7003#ifdef FIRST_STEP_FRACTAL
7004 // perturb the current weight vector only on the top level or
7005 // after perturbation of the both vectors, nlev = 2 as the top level
7006 if((nlev == 1 && Xcall == 0) || (nlev == 2 && Xngleich == 1))
7007 if(islengthpoly2(G) == 1)
7008 {
7009 Mwlp = MivWeightOrderlp(omega);
7010 Xsigma = Mfpertvector(G, Mwlp);
7011 delete Mwlp;
7013 }
7014#endif
7015 nwalks ++;
7016 NEXT_VECTOR_FRACTAL:
7017#ifdef TIME_TEST
7018 to=clock();
7019#endif
7020 // determine the next border
7021 next_vect = MkInterRedNextWeight(omega,omega2,G);
7022#ifdef TIME_TEST
7023 xtnw=xtnw+clock()-to;
7024#endif
7025 oRing = currRing;
7026
7027 // We only perturb the current target vector at the recursion level 1
7028 if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
7029 if (MivComp(next_vect, omega2) == 1)
7030 {
7031 // to dispense with taking initial (and lifting/interreducing
7032 // after the call of recursion
7033 if(printout > 0)
7034 {
7035 Print("\n//** rec_fractal_call: Perturb the both vectors with degree %d.",nlev);
7036 //idElements(G, "G");
7037 }
7038
7039 Xngleich = 1;
7040 nlev +=1;
7041
7042 if(ivtarget->length() == nV)
7043 {
7044/*
7045 if (rParameter(currRing) != NULL)
7046 DefRingPar(omtmp);
7047 else
7048 rChangeCurrRing(VMrDefault(omtmp));
7049*/
7050 rChangeCurrRing(VMrRefine(ivtarget,omtmp));
7051 }
7052 else
7053 {
7054 //rChangeCurrRing(VMatrDefault(ivtarget));
7055 rChangeCurrRing(VMatrRefine(ivtarget,omtmp));
7056 }
7057 testring = currRing;
7058 Gt = idrMoveR(G, oRing,currRing);
7059
7060 // perturb the original target vector w.r.t. the current GB
7061 if(ivtarget->length() == nV)
7062 {
7063 delete Xtau;
7064 Xtau = NewVectorlp(Gt);
7065 }
7066 else
7067 {
7068 delete Xtau;
7069 Xtau = Mfpertvector(Gt,ivtarget);
7070 }
7071
7072 rChangeCurrRing(oRing);
7073 G = idrMoveR(Gt, testring,currRing);
7074
7075 // perturb the current vector w.r.t. the current GB
7076 Mwlp = MivWeightOrderlp(omega);
7077 Xsigma = Mfpertvector(G, Mwlp);
7078 delete Mwlp;
7079
7080 for(i=nV-1; i>=0; i--) {
7081 (*omega2)[i] = (*Xtau)[nV+i];
7082 (*omega)[i] = (*Xsigma)[nV+i];
7083 }
7084
7085 delete next_vect;
7086#ifdef TIME_TEST
7087 to=clock();
7088#endif
7089 // to avoid the value of Overflow_Error that occur in Mfpertvector
7091 next_vect = MkInterRedNextWeight(omega,omega2,G);
7092#ifdef TIME_TEST
7093 xtnw=xtnw+clock()-to;
7094#endif
7095 }// end of (if MivComp(next_vect, omega2) == 1)
7096
7097#ifdef PRINT_VECTORS
7098 if(printout > 0)
7099 {
7100 MivString(omega, omega2, next_vect);
7101 }
7102#endif
7103
7104 // check whether the the computed vector is in the correct cone.
7105 // If no, compute the reduced Groebner basis of an omega-homogeneous
7106 // ideal with Buchberger's algorithm and stop this recursion step
7107 if(Overflow_Error == TRUE || test_w_in_ConeCC(G, next_vect) != 1) //e.g. Example s7, cyc6
7108 {
7109 delete next_vect;
7110 if(ivtarget->length() == nV)
7111 {
7112/*
7113 if (rParameter(currRing) != NULL)
7114 DefRingPar(omtmp);
7115 else
7116 rChangeCurrRing(VMrDefault(omtmp));
7117*/
7118 rChangeCurrRing(VMrRefine(ivtarget,omtmp));
7119 }
7120 else
7121 {
7122 //rChangeCurrRing(VMatrDefault(ivtarget));
7123 rChangeCurrRing(VMatrRefine(ivtarget,omtmp));
7124 }
7125#ifdef TEST_OVERFLOW
7126 Gt = idrMoveR(G, oRing,currRing);
7127 Gt = NULL; return(Gt);
7128#endif
7129 if(printout > 0)
7130 {
7131 Print("\n//** rec_fractal_call: Applying Buchberger's algorithm in ring r = %s;",
7132 rString(currRing));
7133 }
7134#ifdef TIME_TEST
7135 to=clock();
7136#endif
7137 Gt = idrMoveR(G, oRing,currRing);
7138 G1 = MstdCC(Gt);
7139#ifdef TIME_TEST
7140 xtextra=xtextra+clock()-to;
7141#endif
7142 Gt = NULL;
7143
7144 delete omega2;
7145 //delete altomega;
7146 if(printout > 0)
7147 {
7148 Print("\n//** rec_fractal_call: Overflow. (4) Leaving the %d-th recursion with %d steps.\n",
7149 nlev, nwalks);
7150 //Print(" ** Overflow_Error? (%d)", Overflow_Error);
7151 }
7152
7153 nnflow ++;
7155 return (G1);
7156 }
7157
7158 /* If the perturbed target vector stays in the correct cone,
7159 return the current GB,
7160 otherwise, return the computed GB by the Buchberger-algorithm.
7161 Then we update the perturbed target vectors w.r.t. this GB. */
7162
7163 /* the computed vector is equal to the origin vector, since
7164 t is not defined */
7165
7166 if (MivComp(next_vect, XivNull) == 1)
7167 {
7168 if(ivtarget->length() == nV)
7169 {
7170/*
7171 if (rParameter(currRing) != NULL)
7172 DefRingPar(omtmp);
7173 else
7174 rChangeCurrRing(VMrDefault(omtmp));
7175*/
7176 rChangeCurrRing(VMrRefine(ivtarget,omtmp));
7177 }
7178 else
7179 {
7180 //rChangeCurrRing(VMatrDefault(ivtarget));
7181 rChangeCurrRing(VMatrRefine(ivtarget,omtmp));
7182 }
7183
7184 testring = currRing;
7185 Gt = idrMoveR(G, oRing,currRing);
7186 if(test_w_in_ConeCC(Gt, omega2) == 1)
7187 {
7188 delete omega2;
7189 delete next_vect;
7190 //delete altomega;
7191 if(printout > 0)
7192 {
7193 Print("\n//** rec_fractal_call: Correct cone. (5) Leaving the %d-th recursion with %d steps.\n",
7194 nlev, nwalks);
7195 }
7196 if(printout>2)
7197 {
7198 idString(Gt,"//** rec_fractal_call: Gt");
7199 }
7200 return (Gt);
7201 }
7202 else
7203 {
7204 if(printout > 0)
7205 {
7206 PrintS("\n//** rec_fractal_call: Wrong cone. Tau doesn't stay in the correct cone.\n");
7207 }
7208
7209#ifndef MSTDCC_FRACTAL
7210 intvec* Xtautmp;
7211 if(ivtarget->length() == nV)
7212 {
7213 Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
7214 }
7215 else
7216 {
7217 Xtautmp = Mfpertvector(Gt, ivtarget);
7218 }
7219#ifdef TEST_OVERFLOW
7220 if(Overflow_Error == TRUE)
7221 Gt = NULL; return(Gt);
7222#endif
7223
7224 if(MivSame(Xtau, Xtautmp) == 1)
7225 {
7226 if(printout > 0)
7227 {
7228 PrintS("\n//** rec_fractal_call: Updated vectors are equal to the old vectors.\n");
7229 }
7230 delete Xtautmp;
7231 goto FRACTAL_MSTDCC;
7232 }
7233
7234 Xtau = Xtautmp;
7235 Xtautmp = NULL;
7236
7237 for(i=nV-1; i>=0; i--)
7238 (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
7239
7240 rChangeCurrRing(oRing);
7241 G = idrMoveR(Gt, testring,currRing);
7242
7243 goto NEXT_VECTOR_FRACTAL;
7244#endif
7245
7246 //FRACTAL_MSTDCC:
7247 if(printout > 0)
7248 {
7249 Print("\n//** rec_fractal_call: Wrong cone. Applying Buchberger's algorithm in ring = %s.\n",
7250 rString(currRing));
7251 }
7252#ifdef TIME_TEST
7253 to=clock();
7254#endif
7255 G = MstdCC(Gt);
7256#ifdef TIME_TEST
7257 xtextra=xtextra+clock()-to;
7258#endif
7259 oRing = currRing;
7260
7261 // update the original target vector w.r.t. the current GB
7262 if(ivtarget->length() == nV)
7263 {
7264/*
7265 if(MivSame(Xivinput, Xivlp) == 1)
7266 if (rParameter(currRing) != NULL)
7267 DefRingParlp();
7268 else
7269 VMrDefaultlp();
7270 else
7271 if (rParameter(currRing) != NULL)
7272 DefRingPar(Xivinput);
7273 else
7274 rChangeCurrRing(VMrDefault(Xivinput));
7275*/
7277 }
7278 else
7279 {
7281 }
7282 testring = currRing;
7283 Gt = idrMoveR(G, oRing,currRing);
7284
7285 // perturb the original target vector w.r.t. the current GB
7286 if(ivtarget->length() == nV)
7287 {
7288 delete Xtau;
7289 Xtau = NewVectorlp(Gt);
7290 }
7291 else
7292 {
7293 delete Xtau;
7294 Xtau = Mfpertvector(Gt,ivtarget);
7295 }
7296
7297 rChangeCurrRing(oRing);
7298 G = idrMoveR(Gt, testring,currRing);
7299
7300 delete omega2;
7301 delete next_vect;
7302 //delete altomega;
7303 if(printout > 0)
7304 {
7305 Print("\n//** rec_fractal_call: Vectors updated. (6) Leaving the %d-th recursion with %d steps.\n",
7306 nlev, nwalks);
7307 //Print(" ** Overflow_Error? (%d)", Overflow_Error);
7308 }
7309 if(Overflow_Error == TRUE)
7310 nnflow ++;
7311
7313 return(G);
7314 }
7315 }// end of (if next_vect==nullvector)
7316
7317 for(i=nV-1; i>=0; i--) {
7318 //(*altomega)[i] = (*omega)[i];
7319 (*omega)[i] = (*next_vect)[i];
7320 }
7321 delete next_vect;
7322#ifdef TIME_TEST
7323 to=clock();
7324#endif
7325 // Take the initial form of <G> w.r.t. omega
7326 Gomega = MwalkInitialForm(G, omega);
7327#ifdef TIME_TEST
7328 xtif=xtif+clock()-to;
7329#endif
7330#ifdef CHECK_IDEAL_MWALK
7331 if(printout > 1)
7332 {
7333 idString(Gomega,"//** rec_fractal_call: Gomega");
7334 }
7335#endif
7336 if(reduction == 0)
7337 {
7338 // Check whether the intermediate weight vector lies in the interior of the cone.
7339 // If so, only perform reductions. Otherwise apply Buchberger's algorithm.
7340 FF = middleOfCone(G,Gomega);
7341 if( FF != NULL)
7342 {
7343 idDelete(&G);
7344 G = idCopy(FF);
7345 idDelete(&FF);
7346 // Compue next vector.
7347 goto NEXT_VECTOR_FRACTAL;
7348 }
7349 }
7350
7351#ifndef BUCHBERGER_ALG
7352 if(isNolVector(omega) == 0)
7353 hilb_func = hFirstSeries(Gomega,NULL,NULL,omega,currRing);
7354 else
7355 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
7356#endif
7357
7358 if(ivtarget->length() == nV)
7359 {
7360/*
7361 if (rParameter(currRing) != NULL)
7362 DefRingPar(omega);
7363 else
7364 rChangeCurrRing(VMrDefault(omega));
7365*/
7366 rChangeCurrRing(VMrRefine(ivtarget,omega));
7367 }
7368 else
7369 {
7370 rChangeCurrRing(VMatrRefine(ivtarget,omega));
7371 }
7372 Gomega1 = idrMoveR(Gomega, oRing,currRing);
7373
7374 // Maximal recursion depth, to compute a red. GB
7375 // Fractal walk with the alternative recursion
7376 // alternative recursion
7377 if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
7378 {
7379 if(printout > 1)
7380 {
7381 PrintS("\n//** rec_fractal_call: Maximal recursion depth.\n");
7382 }
7383#ifdef TIME_TEST
7384 to=clock();
7385#endif
7386#ifdef BUCHBERGER_ALG
7387 Gresult = MstdhomCC(Gomega1);
7388#else
7389 Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
7390 delete hilb_func;
7391#endif
7392#ifdef TIME_TEST
7393 xtstd=xtstd+clock()-to;
7394#endif
7395 }
7396 else
7397 {
7398 rChangeCurrRing(oRing);
7399 Gomega1 = idrMoveR(Gomega1, oRing,currRing);
7400 Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,reduction,printout);
7401 }
7402#ifdef CHECK_IDEAL_MWALK
7403 if(printout > 2)
7404 {
7405 idString(Gresult,"//** rec_fractal_call: M");
7406 }
7407#endif
7408 //convert a Groebner basis from a ring to another ring
7409 new_ring = currRing;
7410
7411 rChangeCurrRing(oRing);
7412 Gresult1 = idrMoveR(Gresult, new_ring,currRing);
7413 Gomega2 = idrMoveR(Gomega1, new_ring,currRing);
7414#ifdef TIME_TEST
7415 to=clock();
7416#endif
7417 // Lifting process
7418 F = MLifttwoIdeal(Gomega2, Gresult1, G);
7419#ifdef TIME_TEST
7420 xtlift=xtlift+clock()-to;
7421#endif
7422#ifdef CHECK_IDEAL_MWALK
7423 if(printout > 2)
7424 {
7425 idString(F,"//** rec_fractal_call: F");
7426 }
7427#endif
7429 idDelete(&Gresult1);
7430 idDelete(&Gomega2);
7431 idDelete(&G);
7432
7433 rChangeCurrRing(new_ring);
7434 G = idrMoveR(F,oRing,currRing);
7435/*
7436 ideal F1 = idrMoveR(F, oRing,currRing);
7437#ifdef TIME_TEST
7438 to=clock();
7439#endif
7440 // Interreduce G
7441 G = kInterRedCC(F1, NULL);
7442#ifdef TIME_TEST
7443 xtred=xtred+clock()-to;
7444#endif
7445 idDelete(&F1);
7446*/
7447 }
7448}
void id_Normalize(ideal I, const ring r)
normialize all polys in id
static int islengthpoly2(ideal G)
Definition: walk.cc:3477
static intvec * NewVectorlp(ideal I)
Definition: walk.cc:4496

◆ REC_GB_Mwalk()

static ideal REC_GB_Mwalk ( ideal  G,
intvec curr_weight,
intvec orig_target_weight,
int  tp_deg,
int  npwinc 
)
static

Definition at line 4719 of file walk.cc.

4721{
4722 BOOLEAN nError = Overflow_Error;
4724
4725 int i, nV = currRing->N;
4726 int nwalk=0, endwalks=0, nnwinC=1, nlast = 0;
4727 ideal Gomega, M, F, Gomega1, Gomega2, M1,F1,result,ssG;
4728 ring newRing, oldRing, TargetRing;
4729 intvec* target_weight;
4730 intvec* ivNull = new intvec(nV);
4731#ifndef BUCHBERGER_ALG
4732 intvec* hilb_func;
4733 // to avoid (1,0,...,0) as the target vector
4734 intvec* last_omega = new intvec(nV);
4735 for(i=nV-1; i>0; i--)
4736 {
4737 (*last_omega)[i] = 1;
4738 }
4739 (*last_omega)[0] = 10000;
4740#endif
4741 BOOLEAN isGB = FALSE;
4742
4743 ring EXXRing = currRing;
4744
4745 // compute a pertubed weight vector of the target weight vector
4746 if(tp_deg > 1 && tp_deg <= nV)
4747 {
4748 ideal H0 = idHeadCC(G);
4749 if (rParameter(currRing) != NULL)
4750 {
4751 DefRingPar(orig_target_weight);
4752 }
4753 else
4754 {
4755 rChangeCurrRing(VMrDefault(orig_target_weight));
4756 }
4757 TargetRing = currRing;
4758 ssG = idrMoveR(G,EXXRing,currRing);
4759
4760 ideal H0_tmp = idrMoveR(H0,EXXRing,currRing);
4761 ideal H1 = idHeadCC(ssG);
4762 id_Delete(&H0,EXXRing);
4763
4764 if(test_G_GB_walk(H0_tmp,H1)==1)
4765 {
4766 //Print("\n//REC_GB_Mwalk: input in %d-th recursive is a GB!\n",tp_deg);
4767 idDelete(&H0_tmp);
4768 idDelete(&H1);
4769 G = ssG;
4770 ssG = NULL;
4771 newRing = currRing;
4772 delete ivNull;
4773 if(npwinc == 0)
4774 {
4775 isGB = TRUE;
4776 goto KSTD_Finish;
4777 }
4778 else
4779 {
4780 goto LastGB_Finish;
4781 }
4782 }
4783 idDelete(&H0_tmp);
4784 idDelete(&H1);
4785
4786 target_weight = MPertVectors(ssG, MivMatrixOrder(orig_target_weight), tp_deg);
4787
4788 rChangeCurrRing(EXXRing);
4789 G = idrMoveR(ssG, TargetRing,currRing);
4790 }
4791
4792 while(1)
4793 {
4794 nwalk ++;
4795 nstep++;
4796 if(nwalk == 1)
4797 {
4798 goto NEXT_STEP;
4799 }
4800 //Print("\n//REC_GB_Mwalk: Entering the %d-th step in the %d-th recursive:\n",nwalk,tp_deg);
4801#ifdef TIME_TEST
4802 to = clock();
4803#endif
4804 // compute an initial form ideal of <G> w.r.t. "curr_vector"
4805 Gomega = MwalkInitialForm(G, curr_weight);
4806#ifdef TIME_TEST
4807 xtif = xtif + clock()-to;
4808#endif
4809
4810#ifndef BUCHBERGER_ALG
4811 if(isNolVector(curr_weight) == 0)
4812 {
4813 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
4814 }
4815 else
4816 {
4817 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
4818 }
4819#endif
4820
4821 oldRing = currRing;
4822
4823 // define a new ring with ordering "(a(curr_weight),lp)
4824 if (rParameter(currRing) != NULL)
4825 {
4826 DefRingPar(curr_weight);
4827 }
4828 else
4829 {
4830 rChangeCurrRing(VMrDefault(curr_weight));
4831 }
4832 newRing = currRing;
4833 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
4834
4835#ifdef TIME_TEST
4836 to = clock();
4837#endif
4838 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
4839#ifdef BUCHBERGER_ALG
4840 M = MstdhomCC(Gomega1);
4841#else
4842 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
4843 delete hilb_func;
4844#endif
4845#ifdef TIME_TEST
4846 xtstd = xtstd + clock() - to;
4847#endif
4848
4849 // change the ring to oldRing
4850 rChangeCurrRing(oldRing);
4851
4852 M1 = idrMoveR(M, newRing,currRing);
4853 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
4854
4855#ifdef TIME_TEST
4856 to = clock();
4857#endif
4858 F = MLifttwoIdeal(Gomega2, M1, G);
4859#ifdef TIME_TEST
4860 xtlift = xtlift + clock() -to;
4861#endif
4862
4863 idDelete(&M1);
4864 idDelete(&Gomega2);
4865 idDelete(&G);
4866
4867
4868 // change the ring to newRing
4869 rChangeCurrRing(newRing);
4870 F1 = idrMoveR(F, oldRing,currRing);
4871
4872#ifdef TIME_TEST
4873 to = clock();
4874#endif
4875 // reduce the Groebner basis <G> w.r.t. new ring
4876 G = kInterRedCC(F1, NULL);
4877#ifdef TIME_TEST
4878 xtred = xtred + clock() -to;
4879#endif
4880
4881 idDelete(&F1);
4882
4883 if(endwalks == 1)
4884 {
4885 break;
4886 }
4887 NEXT_STEP:
4888#ifdef TIME_TEST
4889 to = clock();
4890#endif
4891 // compute a next weight vector
4892 intvec* next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
4893
4894
4895#ifdef TIME_TEST
4896 xtnw = xtnw + clock() - to;
4897#endif
4898
4899#ifdef PRINT_VECTORS
4900 MivString(curr_weight, target_weight, next_weight);
4901#endif
4902
4903 if(Overflow_Error == TRUE)
4904 {
4905 //PrintS("\n//REC_GB_Mwalk: The computed vector does NOT stay in the correct cone!!\n");
4906 nnwinC = 0;
4907 if(tp_deg == nV)
4908 {
4909 nlast = 1;
4910 }
4911 delete next_weight;
4912 break;
4913 }
4914 if(MivComp(next_weight, ivNull) == 1)
4915 {
4916 newRing = currRing;
4917 delete next_weight;
4918 break;
4919 }
4920
4921 if(MivComp(next_weight, target_weight) == 1)
4922 {
4923 if(tp_deg == nV)
4924 {
4925 endwalks = 1;
4926 }
4927 else
4928 {
4929 G = REC_GB_Mwalk(G,curr_weight, orig_target_weight, tp_deg+1,nnwinC);
4930 newRing = currRing;
4931 delete next_weight;
4932 break;
4933 }
4934 }
4935
4936 for(i=nV-1; i>=0; i--)
4937 {
4938 (*curr_weight)[i] = (*next_weight)[i];
4939 }
4940 delete next_weight;
4941 }
4942
4943 delete ivNull;
4944
4945 if(tp_deg != nV)
4946 {
4947 newRing = currRing;
4948
4949 if (rParameter(currRing) != NULL)
4950 {
4951 DefRingPar(orig_target_weight);
4952 }
4953 else
4954 {
4955 rChangeCurrRing(VMrDefault(orig_target_weight));
4956 }
4957 F1 = idrMoveR(G, newRing,currRing);
4958
4959 if(nnwinC == 0)
4960 {
4961 F1 = REC_GB_Mwalk(F1,curr_weight, orig_target_weight, tp_deg+1,nnwinC);
4962 }
4963 else
4964 {
4965 if(test_w_in_ConeCC(F1, target_weight) != 1)
4966 {
4967 F1 = REC_GB_Mwalk(F1,curr_weight, orig_target_weight,tp_deg+1,nnwinC);
4968 }
4969 }
4970 delete target_weight;
4971
4972 TargetRing = currRing;
4973 rChangeCurrRing(EXXRing);
4974 result = idrMoveR(F1, TargetRing,currRing);
4975 }
4976 else
4977 {
4978 if(nlast == 1)
4979 {
4980 if (rParameter(currRing) != NULL)
4981 {
4982 DefRingPar(orig_target_weight);
4983 }
4984 else
4985 {
4986 rChangeCurrRing(VMrDefault(orig_target_weight));
4987 }
4988 KSTD_Finish:
4989 if(isGB == FALSE)
4990 {
4991 F1 = idrMoveR(G, newRing,currRing);
4992 }
4993 else
4994 {
4995 F1 = G;
4996 }
4997#ifdef TIME_TEST
4998 to=clock();
4999#endif
5000 // apply Buchberger alg to compute a red. GB of F1
5001 G = MstdCC(F1);
5002#ifdef TIME_TEST
5003 xtextra=clock()-to;
5004#endif
5005 idDelete(&F1);
5006 newRing = currRing;
5007 }
5008
5009 LastGB_Finish:
5010 rChangeCurrRing(EXXRing);
5011 result = idrMoveR(G, newRing,currRing);
5012 }
5013
5014 if(Overflow_Error == FALSE)
5015 {
5016 Overflow_Error = nError;
5017 }
5018#ifndef BUCHBERGER_ALG
5019 delete last_omega;
5020#endif
5021 return(result);
5022}
static ideal idHeadCC(ideal h)
Definition: walk.cc:3513
static int test_G_GB_walk(ideal H0, ideal H1)
Definition: walk.cc:3532

◆ Rec_LastGB()

static ideal Rec_LastGB ( ideal  G,
intvec curr_weight,
intvec orig_target_weight,
int  tp_deg,
int  npwinc 
)
static

Definition at line 3933 of file walk.cc.

3935{
3936 BOOLEAN nError = Overflow_Error;
3938 // BOOLEAN nOverflow_Error = FALSE;
3939
3940#ifdef TIME_TEST
3941 clock_t tproc=0;
3942 clock_t tinput = clock();
3943#endif
3944
3945 int i, nV = currRing->N;
3946 int nwalk=0, endwalks=0, nnwinC=1;
3947 int nlast = 0;
3948 ideal Gomega, M, F, Gomega1, Gomega2, M1,F1,result,ssG;
3949 ring newRing, oldRing, TargetRing;
3950 intvec* iv_M_lp;
3951 intvec* target_weight;
3952 intvec* ivNull = new intvec(nV); //define (0,...,0)
3953 ring EXXRing = currRing;
3954 //int NEG=0; //19 juni 03
3955 intvec* next_weight;
3956#ifndef BUCHBERGER_ALG
3957 //08 Juli 03
3958 intvec* hilb_func;
3959#endif
3960 // to avoid (1,0,...,0) as the target vector
3961 intvec* last_omega = new intvec(nV);
3962 for(i=nV-1; i>0; i--)
3963 (*last_omega)[i] = 1;
3964 (*last_omega)[0] = 10000;
3965
3966 BOOLEAN isGB = FALSE;
3967
3968 // compute a pertubed weight vector of the target weight vector
3969 if(tp_deg > 1 && tp_deg <= nV)
3970 {
3971 ideal H0 = idHeadCC(G);
3972
3973 if (rParameter (currRing) != NULL)
3974 {
3975 DefRingParlp();
3976 }
3977 else
3978 {
3979 VMrDefaultlp();
3980 }
3981 TargetRing = currRing;
3982 ssG = idrMoveR(G,EXXRing,currRing);
3983
3984 ideal H0_tmp = idrMoveR(H0,EXXRing,currRing);
3985 ideal H1 = idHeadCC(ssG);
3986
3987 // Apply Lemma 2.2 in Collart et. al (1997) to check whether cone(k-1) is equal to cone(k)
3988 if(test_G_GB_walk(H0_tmp,H1)==1)
3989 {
3990 idDelete(&H0_tmp);
3991 idDelete(&H1);
3992 G = ssG;
3993 ssG = NULL;
3994 newRing = currRing;
3995 delete ivNull;
3996
3997 if(npwinc != 0)
3998 {
3999 goto LastGB_Finish;
4000 }
4001 else
4002 {
4003 isGB = TRUE;
4004 goto KSTD_Finish;
4005 }
4006 }
4007 idDelete(&H0_tmp);
4008 idDelete(&H1);
4009
4010 iv_M_lp = MivMatrixOrderlp(nV);
4011 target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
4012 delete iv_M_lp;
4013 //PrintS("\n// Input is not GB!!");
4014 rChangeCurrRing(EXXRing);
4015 G = idrMoveR(ssG, TargetRing,currRing);
4016
4017 if(Overflow_Error == TRUE)
4018 {
4019 //nOverflow_Error = Overflow_Error;
4020 //NEG = 1;
4021 newRing = currRing;
4022 goto JUNI_STD;
4023 }
4024 }
4025
4026 while(1)
4027 {
4028 nwalk ++;
4029 nstep++;
4030
4031 if(nwalk==1)
4032 {
4033 goto FIRST_STEP;
4034 }
4035#ifdef TIME_TEST
4036 to=clock();
4037#endif
4038 // compute an initial form ideal of <G> w.r.t. "curr_vector"
4039 Gomega = MwalkInitialForm(G, curr_weight);
4040#ifdef TIME_TEST
4041 xtif=xtif+clock()-to;
4042#endif
4043
4044#ifndef BUCHBERGER_ALG
4045 if(isNolVector(curr_weight) == 0)
4046 {
4047 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
4048 }
4049 else
4050 {
4051 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
4052 }
4053#endif // BUCHBERGER_ALG
4054
4055 oldRing = currRing;
4056
4057 // defiNe a new ring that its ordering is "(a(curr_weight),lp)
4058 if (rParameter(currRing) != NULL)
4059 {
4060 DefRingPar(curr_weight);
4061 }
4062 else
4063 {
4064 rChangeCurrRing(VMrDefault(curr_weight));
4065 }
4066 newRing = currRing;
4067 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
4068#ifdef TIME_TEST
4069 to=clock();
4070#endif
4071 // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
4072#ifdef BUCHBERGER_ALG
4073 M = MstdhomCC(Gomega1);
4074#else
4075 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
4076 delete hilb_func;
4077#endif // BUCHBERGER_ALG
4078#ifdef TIME_TEST
4079 xtstd=xtstd+clock()-to;
4080#endif
4081 // change the ring to oldRing
4082 rChangeCurrRing(oldRing);
4083 M1 = idrMoveR(M, newRing,currRing);
4084 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
4085
4086#ifdef TIME_TEST
4087 to=clock();
4088#endif
4089 // compute a reduced Groebner basis of <G> w.r.t. "newRing" by the lifting process
4090 F = MLifttwoIdeal(Gomega2, M1, G);
4091#ifdef TIME_TEST
4092 xtlift=xtlift+clock()-to;
4093#endif
4094 idDelete(&M1);
4095 idDelete(&Gomega2);
4096 idDelete(&G);
4097
4098 // change the ring to newRing
4099 rChangeCurrRing(newRing);
4100 F1 = idrMoveR(F, oldRing,currRing);
4101
4102#ifdef TIME_TEST
4103 to=clock();
4104#endif
4105 // reduce the Groebner basis <G> w.r.t. new ring
4106 G = kInterRedCC(F1, NULL);
4107#ifdef TIME_TEST
4108 xtred=xtred+clock()-to;
4109#endif
4110 idDelete(&F1);
4111
4112 if(endwalks == 1)
4113 {
4114 break;
4115 }
4116 FIRST_STEP:
4117#ifdef TIME_TEST
4118 to=clock();
4119#endif
4121 // compute a next weight vector
4122 next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
4123#ifdef TIME_TEST
4124 xtnw=xtnw+clock()-to;
4125#endif
4126#ifdef PRINT_VECTORS
4127 MivString(curr_weight, target_weight, next_weight);
4128#endif
4129 if(Overflow_Error == TRUE)
4130 {
4131 //PrintS("\n// ** The next vector does NOT stay in Cone!!\n");
4132#ifdef TEST_OVERFLOW
4133 goto LastGB_Finish;
4134#endif
4135
4136 nnwinC = 0;
4137 if(tp_deg == nV)
4138 {
4139 nlast = 1;
4140 }
4141 delete next_weight;
4142 break;
4143 }
4144
4145 if(MivComp(next_weight, ivNull) == 1)
4146 {
4147 //newRing = currRing;
4148 delete next_weight;
4149 break;
4150 }
4151
4152 if(MivComp(next_weight, target_weight) == 1)
4153 {
4154 if(tp_deg == nV)
4155 {
4156 endwalks = 1;
4157 }
4158 else
4159 {
4160 // REC_LAST_GB_ALT2:
4161 //nOverflow_Error = Overflow_Error;
4162#ifdef TIME_TEST
4163 tproc=tproc+clock()-tinput;
4164#endif
4165
4166 /*Print("\n// takes %d steps and calls \"Rec_LastGB\" (%d):",
4167 nwalk, tp_deg+1);
4168 */
4169 G = Rec_LastGB(G,curr_weight, orig_target_weight, tp_deg+1,nnwinC);
4170 newRing = currRing;
4171 delete next_weight;
4172 break;
4173 }
4174 }
4175
4176 for(i=nV-1; i>=0; i--)
4177 {
4178 (*curr_weight)[i] = (*next_weight)[i];
4179 }
4180 delete next_weight;
4181 }//while
4182
4183 delete ivNull;
4184
4185 if(tp_deg != nV)
4186 {
4187 newRing = currRing;
4188
4189 if (rParameter(currRing) != NULL)
4190 {
4191 DefRingParlp();
4192 }
4193 else
4194 {
4195 VMrDefaultlp();
4196 }
4197 F1 = idrMoveR(G, newRing,currRing);
4198
4199 if(nnwinC == 0 || test_w_in_ConeCC(F1, target_weight) != 1 )
4200 {
4201 // nOverflow_Error = Overflow_Error;
4202 //Print("\n// takes %d steps and calls \"Rec_LastGB (%d):", tp_deg+1);
4203#ifdef TIME_TEST
4204 tproc=tproc+clock()-tinput;
4205#endif
4206 F1 = Rec_LastGB(F1,curr_weight, orig_target_weight, tp_deg+1,nnwinC);
4207 }
4208 delete target_weight;
4209
4210 TargetRing = currRing;
4211 rChangeCurrRing(EXXRing);
4212 result = idrMoveR(F1, TargetRing,currRing);
4213 }
4214 else
4215 {
4216 if(nlast == 1)
4217 {
4218 JUNI_STD:
4219
4220 newRing = currRing;
4221 if (rParameter(currRing) != NULL)
4222 {
4223 DefRingParlp();
4224 }
4225 else
4226 {
4227 VMrDefaultlp();
4228 }
4229 KSTD_Finish:
4230 if(isGB == FALSE)
4231 {
4232 F1 = idrMoveR(G, newRing,currRing);
4233 }
4234 else
4235 {
4236 F1 = G;
4237 }
4238#ifdef TIME_TEST
4239 to=clock();
4240#endif
4241 // Print("\n// apply the Buchberger's alg in ring = %s",rString(currRing));
4242 // idElements(F1, "F1");
4243 G = MstdCC(F1);
4244#ifdef TIME_TEST
4245 xtextra=xtextra+clock()-to;
4246#endif
4247
4248
4249 idDelete(&F1);
4250 newRing = currRing;
4251 }
4252
4253 LastGB_Finish:
4254 rChangeCurrRing(EXXRing);
4255 result = idrMoveR(G, newRing,currRing);
4256 }
4257
4258 if(Overflow_Error == FALSE)
4259 {
4260 Overflow_Error=nError;
4261 }
4262#ifdef TIME_TEST
4263 //Print("\n// \"Rec_LastGB\" (%d) took %d steps and %.2f sec.Overflow_Error (%d)", tp_deg, nwalk, ((double) tproc)/1000000, nOverflow_Error);
4264#endif
4265 return(result);
4266}

◆ rec_r_fractal_call()

static ideal rec_r_fractal_call ( ideal  G,
int  nlev,
intvec ivtarget,
int  weight_rad,
int  reduction,
int  printout 
)
static

Definition at line 7453 of file walk.cc.

7455{
7457 //Print("\n\n// Entering the %d-th recursion:", nlev);
7458
7459 int nwalks = 0,i,nV=currRing->N;//polylength
7460 ring new_ring, testring;
7461 //ring extoRing;
7462 ideal Gomega, Gomega1, Gomega2, F, FF, Gresult, Gresult1, G1, Gt;
7463#ifdef TIME_TEST
7464 ideal F1;
7465#endif
7466 intvec* Mwlp;
7467#ifndef BUCHBERGER_ALG
7468 intvec* hilb_func;
7469#endif
7470// intvec* extXtau;
7471 intvec* next_vect;
7472 intvec* iv_M;
7473 intvec* omega2 = new intvec(nV);
7474 intvec* omtmp = new intvec(nV);
7475 intvec* altomega = new intvec(nV);
7476
7477 //BOOLEAN isnewtarget = FALSE;
7478
7479 for(i = nV -1; i>=0; i--)
7480 {
7481 (*omtmp)[i] = (*ivtarget)[i];
7482 }
7483 // to avoid (1,0,...,0) as the target vector (Hans)
7484 intvec* last_omega = new intvec(nV);
7485 for(i=nV-1; i>0; i--)
7486 (*last_omega)[i] = 1;
7487 (*last_omega)[0] = 10000;
7488
7489 intvec* omega = new intvec(nV);
7490 for(i=0; i<nV; i++) {
7491 if(Xsigma->length() == nV)
7492 (*omega)[i] = (*Xsigma)[i];
7493 else
7494 (*omega)[i] = (*Xsigma)[(nV*(nlev-1))+i];
7495
7496 (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
7497 }
7498
7499 if(nlev == 1) Xcall = 1;
7500 else Xcall = 0;
7501
7502 ring oRing = currRing;
7503
7504 while(1)
7505 {
7506#ifdef FIRST_STEP_FRACTAL
7507 /*
7508 perturb the current weight vector only on the top level or
7509 after perturbation of the both vectors, nlev = 2 as the top level
7510 */
7511 if((nlev == 1 && Xcall == 0) || (nlev == 2 && Xngleich == 1))
7512 if(islengthpoly2(G) == 1)
7513 {
7514 Mwlp = MivWeightOrderlp(omega);
7515 Xsigma = Mfpertvector(G, Mwlp);
7516 delete Mwlp;
7518 }
7519#endif
7520 nwalks ++;
7521 NEXT_VECTOR_FRACTAL:
7522#ifdef TIME_TEST
7523 to=clock();
7524#endif
7525 /* determine the next border */
7526 next_vect = MkInterRedNextWeight(omega,omega2,G);
7527#ifdef TIME_TEST
7528 xtnw=xtnw+clock()-to;
7529#endif
7530 if(lengthpoly(MwalkInitialForm(G, next_vect)) > 0 && G->m[0] != NULL)
7531 {
7532 if(printout > 0)
7533 {
7534 PrintS("\n**// rec_r_fractal_call: there is a polynomial in Gomega with at least 3 monomials.\n");
7535 }
7536 delete next_vect;
7537 iv_M = MivMatrixOrder(omega);
7538#ifdef TIME_TEST
7539 to=clock();
7540#endif
7541 next_vect = MWalkRandomNextWeight(G,iv_M,omega2,weight_rad,nlev);
7542#ifdef TIME_TEST
7543 xtnw=xtnw+clock()-to;
7544#endif
7545 if(isNegNolVector(next_vect) == 1)
7546 {
7547 delete next_vect;
7548#ifdef TIME_TEST
7549 to=clock();
7550#endif
7551 next_vect = MkInterRedNextWeight(omega,omega2,G);
7552#ifdef TIME_TEST
7553 xtnw=xtnw+clock()-to;
7554#endif
7555 }
7556 }
7557 oRing = currRing;
7558
7559 // We only perturb the current target vector at the recursion level 1
7560 if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
7561 if (MivComp(next_vect, omega2) == 1)
7562 {
7563 // to dispense with taking initials and lifting/interreducing
7564 // after the call of recursion.
7565 if(printout > 0)
7566 {
7567 Print("\n//** rec_r_fractal_call: Perturb both vectors with degree %d.",nlev);
7568 //idElements(G, "G");
7569 }
7570 Xngleich = 1;
7571 nlev +=1;
7572 if(ivtarget->length() == nV)
7573 {
7574/*
7575 if (rParameter(currRing) != NULL)
7576 DefRingPar(omtmp);
7577 else
7578 rChangeCurrRing(VMrDefault(omtmp));
7579*/
7580 rChangeCurrRing(VMrRefine(ivtarget,omtmp));
7581 }
7582 else
7583 {
7584 //rChangeCurrRing(VMatrDefault(ivtarget));
7585 rChangeCurrRing(VMatrRefine(ivtarget,omtmp));
7586 }
7587 testring = currRing;
7588 Gt = idrMoveR(G, oRing,currRing);
7589
7590 // perturb the original target vector w.r.t. the current GB
7591 if(ivtarget->length() == nV)
7592 {
7593 delete Xtau;
7594 Xtau = NewVectorlp(Gt);
7595 }
7596 else
7597 {
7598 delete Xtau;
7599 Xtau = Mfpertvector(Gt,ivtarget);
7600 }
7601
7602 rChangeCurrRing(oRing);
7603 G = idrMoveR(Gt,testring,currRing);
7604
7605 // perturb the current vector w.r.t. the current GB
7606 Mwlp = MivWeightOrderlp(omega);
7607 if(ivtarget->length() > nV)
7608 {
7609 delete Mwlp;
7610 Mwlp = MivMatrixOrderRefine(omega,ivtarget);
7611 }
7612 Xsigma = Mfpertvector(G, Mwlp);
7613 delete Mwlp;
7614
7615 for(i=nV-1; i>=0; i--)
7616 {
7617 (*omega2)[i] = (*Xtau)[nV+i];
7618 (*omega)[i] = (*Xsigma)[nV+i];
7619 }
7620
7621 delete next_vect;
7622
7623 //to avoid the value of Overflow_Error that occur in Mfpertvector
7625#ifdef TIME_TEST
7626 to=clock();
7627#endif
7628 next_vect = MkInterRedNextWeight(omega,omega2,G);
7629#ifdef TIME_TEST
7630 xtnw=xtnw+clock()-to;
7631#endif
7632 if(lengthpoly(MwalkInitialForm(G, next_vect)) > 0 && G->m[0] != NULL)
7633 {
7634 // there is a polynomial in Gomega with at least 3 monomials
7635 iv_M = MivMatrixOrder(omega);
7636 delete next_vect;
7637#ifdef TIME_TEST
7638 to=clock();
7639#endif
7640 next_vect = MWalkRandomNextWeight(G,iv_M,omega2,weight_rad,nlev);
7641#ifdef TIME_TEST
7642 xtnw=xtnw+clock()-to;
7643#endif
7644 delete iv_M;
7645 if(isNegNolVector(next_vect) == 1)
7646 {
7647 delete next_vect;
7648#ifdef TIME_TEST
7649 to=clock();
7650#endif
7651 next_vect = MkInterRedNextWeight(omega,omega2,G);
7652#ifdef TIME_TEST
7653 xtnw=xtnw+clock()-to;
7654#endif
7655 }
7656 }
7657 }
7658#ifdef PRINT_VECTORS
7659 if(printout > 0)
7660 {
7661 MivString(omega, omega2, next_vect);
7662 }
7663#endif
7664
7665/* check whether the the computed vector is in the correct cone
7666 If no, the reduced GB of an omega-homogeneous ideal will be
7667 computed by Buchberger algorithm and stop this recursion step
7668*/
7669 if(Overflow_Error == TRUE || test_w_in_ConeCC(G,next_vect) != 1)//e.g. Example s7, cyc6
7670 {
7671 delete next_vect;
7672 if(ivtarget->length() == nV)
7673 {
7674/*
7675 if (rParameter(currRing) != NULL)
7676 {
7677 DefRingPar(omtmp);
7678 }
7679 else
7680 {
7681 rChangeCurrRing(VMrDefault(omtmp));
7682 }
7683*/
7684 rChangeCurrRing(VMrRefine(ivtarget,omtmp));
7685 }
7686 else
7687 {
7688 //rChangeCurrRing(VMatrDefault(ivtarget));
7689 rChangeCurrRing(VMatrRefine(ivtarget,omtmp));
7690 }
7691#ifdef TEST_OVERFLOW
7692 Gt = idrMoveR(G, oRing,currRing);
7693 Gt = NULL;
7694 return(Gt);
7695#endif
7696 if(printout > 0)
7697 {
7698 Print("\n//** rec_r_fractal_call: applying Buchberger's algorithm in ring r = %s;",
7699 rString(currRing));
7700 }
7701 Gt = idrMoveR(G, oRing,currRing);
7702#ifdef TIME_TEST
7703 to=clock();
7704#endif
7705 G1 = MstdCC(Gt);
7706#ifdef TIME_TEST
7707 xtextra=xtextra+clock()-to;
7708#endif
7709 Gt = NULL;
7710
7711 delete omega2;
7712 delete altomega;
7713 if(printout > 0)
7714 {
7715 Print("\n//** rec_r_fractal_call: (1) Leaving the %d-th recursion with %d steps.\n",
7716 nlev, nwalks);
7717 //Print(" ** Overflow_Error? (%d)", Overflow_Error);
7718 }
7719 nnflow ++;
7721 return (G1);
7722 }
7723 /*
7724 If the perturbed target vector stays in the correct cone,
7725 return the current Groebner basis.
7726 Otherwise, return the Groebner basis computed with Buchberger's
7727 algorithm.
7728 Then we update the perturbed target vectors w.r.t. this GB.
7729 */
7730 if (MivComp(next_vect, XivNull) == 1)
7731 {
7732 // The computed vector is equal to the origin vector,
7733 // because t is not defined
7734 if(ivtarget->length() == nV)
7735 {
7736/*
7737 if (rParameter(currRing) != NULL)
7738 DefRingPar(omtmp);
7739 else
7740 rChangeCurrRing(VMrDefault(omtmp));
7741*/
7742 rChangeCurrRing(VMrRefine(ivtarget,omtmp));
7743 }
7744 else
7745 {
7746 //rChangeCurrRing(VMatrDefault(ivtarget));
7747 rChangeCurrRing(VMatrRefine(ivtarget,omtmp));
7748 }
7749 testring = currRing;
7750 Gt = idrMoveR(G, oRing,currRing);
7751
7752 if(test_w_in_ConeCC(Gt, omega2) == 1)
7753 {
7754 delete omega2;
7755 delete next_vect;
7756 delete altomega;
7757 if(printout > 0)
7758 {
7759 Print("\n//** rec_r_fractal_call: (2) Leaving the %d-th recursion with %d steps.\n",
7760 nlev, nwalks);
7761 //Print(" ** Overflow_Error? (%d)", Overflow_Error);
7762 }
7763 return (Gt);
7764 }
7765 else
7766 {
7767 if(printout > 0)
7768 {
7769 Print("\n//** rec_r_fractal_call: target weight doesn't stay in the correct cone.\n");
7770 }
7771
7772#ifndef MSTDCC_FRACTAL
7773#ifdef PRINT_VECTORS
7774 if(printout > 0)
7775 {
7776 ivString(Xtau, "old Xtau");
7777 }
7778#endif
7779 intvec* Xtautmp;
7780 if(ivtarget->length() == nV)
7781 {
7782 Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
7783 }
7784 else
7785 {
7786 Xtautmp = Mfpertvector(Gt, ivtarget);
7787 }
7788#ifdef TEST_OVERFLOW
7789 if(Overflow_Error == TRUE)
7790 Gt = NULL; return(Gt);
7791#endif
7792
7793 if(MivSame(Xtau, Xtautmp) == 1)
7794 {
7795 //PrintS("\n// Update vectors are equal to the old vectors!!");
7796 delete Xtautmp;
7797 goto FRACTAL_MSTDCC;
7798 }
7799
7800 Xtau = Xtautmp;
7801 Xtautmp = NULL;
7802#ifdef PRINT_VECTORS
7803 if(printout > 0)
7804 {
7805 ivString(Xtau, "new Xtau");
7806 }
7807#endif
7808
7809 for(i=nV-1; i>=0; i--)
7810 (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
7811
7812 //Print("\n// ring tau = %s;", rString(currRing));
7813 rChangeCurrRing(oRing);
7814 G = idrMoveR(Gt, testring,currRing);
7815
7816 goto NEXT_VECTOR_FRACTAL;
7817#endif
7818
7819 //FRACTAL_MSTDCC:
7820 if(printout > 0)
7821 {
7822 Print("\n//** rec_r_fractal_call: apply Buchberger's algorithm in ring = %s.\n",
7823 rString(currRing));
7824 }
7825#ifdef TIME_TEST
7826 to=clock();
7827#endif
7828 G = MstdCC(Gt);
7829#ifdef TIME_TEST
7830 xtextra=xtextra+clock()-to;
7831#endif
7832 oRing = currRing;
7833
7834 // update the original target vector w.r.t. the current GB
7835 if(ivtarget->length() == nV)
7836 {
7837/*
7838 if(MivSame(Xivinput, Xivlp) == 1)
7839 if (rParameter(currRing) != NULL)
7840 DefRingParlp();
7841 else
7842 VMrDefaultlp();
7843 else
7844 if (rParameter(currRing) != NULL)
7845 DefRingPar(Xivinput);
7846 else
7847 rChangeCurrRing(VMrDefault(Xivinput));
7848*/
7850 }
7851 else
7852 {
7854 }
7855 testring = currRing;
7856 Gt = idrMoveR(G, oRing,currRing);
7857
7858 // perturb the original target vector w.r.t. the current GB
7859 if(ivtarget->length() == nV)
7860 {
7861 delete Xtau;
7862 Xtau = NewVectorlp(Gt);
7863 }
7864 else
7865 {
7866 delete Xtau;
7867 Xtau = Mfpertvector(Gt,ivtarget);
7868 }
7869
7870 rChangeCurrRing(oRing);
7871 G = idrMoveR(Gt, testring,currRing);
7872
7873 delete omega2;
7874 delete next_vect;
7875 delete altomega;
7876 if(printout > 0)
7877 {
7878 Print("\n//** rec_r_fractal_call: (3) Leaving the %d-th recursion with %d steps.\n",
7879 nlev,nwalks);
7880 //Print(" ** Overflow_Error? (%d)", Overflow_Error);
7881 }
7882 if(Overflow_Error == TRUE)
7883 nnflow ++;
7884
7886 return(G);
7887 }
7888 } //end of if(MivComp(next_vect, XivNull) == 1)
7889
7890 for(i=nV-1; i>=0; i--)
7891 {
7892 (*altomega)[i] = (*omega)[i];
7893 (*omega)[i] = (*next_vect)[i];
7894 }
7895 delete next_vect;
7896#ifdef TIME_TEST
7897 to=clock();
7898#endif
7899 // Take the initial form of <G> w.r.t. omega
7900 Gomega = MwalkInitialForm(G, omega);
7901#ifdef TIME_TEST
7902 xtif=xtif+clock()-to;
7903#endif
7904 //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
7905 //polylength = lengthpoly(Gomega);
7906#ifdef CHECK_IDEAL_MWALK
7907 if(printout > 1)
7908 {
7909 idString(Gomega,"//** rec_r_fractal_call: Gomega");
7910 }
7911#endif
7912 if(reduction == 0)
7913 {
7914 /* Check whether the intermediate weight vector lies in the interior of the cone.
7915 * If so, only perform reductions. Otherwise apply Buchberger's algorithm. */
7916 FF = middleOfCone(G,Gomega);
7917 if( FF != NULL)
7918 {
7919 idDelete(&G);
7920 G = idCopy(FF);
7921 idDelete(&FF);
7922 /* Compue next vector. */
7923 goto NEXT_VECTOR_FRACTAL;
7924 }
7925 }
7926
7927#ifndef BUCHBERGER_ALG
7928 if(isNolVector(omega) == 0)
7929 hilb_func = hFirstSeries(Gomega,NULL,NULL,omega,currRing);
7930 else
7931 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
7932#endif
7933 if(ivtarget->length() == nV)
7934 {
7935/*
7936 if (rParameter(currRing) != NULL)
7937 DefRingPar(omega);
7938 else
7939 rChangeCurrRing(VMrDefault(omega));
7940*/
7941 rChangeCurrRing(VMrRefine(ivtarget,omega));
7942 }
7943 else
7944 {
7945 rChangeCurrRing(VMatrRefine(ivtarget,omega));
7946 }
7947 Gomega1 = idrMoveR(Gomega, oRing,currRing);
7948
7949 // Maximal recursion depth, to compute a red. GB
7950 // Fractal walk with the alternative recursion
7951 // alternative recursion
7952 if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
7953 {
7954#ifdef TIME_TEST
7955 to=clock();
7956#endif
7957#ifdef BUCHBERGER_ALG
7958 Gresult = MstdhomCC(Gomega1);
7959#else
7960 Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
7961 delete hilb_func;
7962#endif
7963#ifdef TIME_TEST
7964 xtstd=xtstd+clock()-to;
7965#endif
7966 }
7967 else
7968 {
7969 rChangeCurrRing(oRing);
7970 Gomega1 = idrMoveR(Gomega1, oRing,currRing);
7971 Gresult = rec_r_fractal_call(idCopy(Gomega1),nlev+1,omega,weight_rad,reduction,printout);
7972 }
7973#ifdef CHECK_IDEAL_MWALK
7974 if(printout > 2)
7975 {
7976 idString(Gresult,"//** rec_r_fractal_call: M");
7977 }
7978#endif
7979 //convert a Groebner basis from a ring to another ring
7980 new_ring = currRing;
7981
7982 rChangeCurrRing(oRing);
7983 Gresult1 = idrMoveR(Gresult, new_ring,currRing);
7984 Gomega2 = idrMoveR(Gomega1, new_ring,currRing);
7985#ifdef TIME_TEST
7986 to=clock();
7987#endif
7988 // Lifting process
7989 F = MLifttwoIdeal(Gomega2, Gresult1, G);
7990#ifdef TIME_TEST
7991 xtlift=xtlift+clock()-to;
7992#endif
7993#ifdef CHECK_IDEAL_MWALK
7994 if(printout > 2)
7995 {
7996 idString(F,"//** rec_r_fractal_call: F");
7997 }
7998#endif
8000 idDelete(&Gresult1);
8001 idDelete(&Gomega2);
8002 idDelete(&G);
8003
8004 rChangeCurrRing(new_ring);
8005 //F1 = idrMoveR(F, oRing,currRing);
8006 G = idrMoveR(F,oRing,currRing);
8007/*
8008#ifdef TIME_TEST
8009 to=clock();
8010#endif
8011 // Interreduce G
8012 G = kInterRedCC(F1, NULL);
8013#ifdef TIME_TEST
8014 xtred=xtred+clock()-to;
8015#endif
8016 idDelete(&F1);
8017*/
8018 }
8019}
static int isNegNolVector(intvec *hilb)
Definition: walk.cc:3061

◆ Set_Error()

void Set_Error ( BOOLEAN  f)

Definition at line 86 of file walk.cc.

86{ pSetm_error=f; }
EXTERN_VAR BOOLEAN pSetm_error
Definition: walk.cc:84

◆ test_G_GB_walk()

static int test_G_GB_walk ( ideal  H0,
ideal  H1 
)
inlinestatic

Definition at line 3532 of file walk.cc.

3533{
3534 int i, nG = IDELEMS(H0);
3535
3536 if(nG != IDELEMS(H1))
3537 {
3538 return 0;
3539 }
3540 for(i=nG-1; i>=0; i--)
3541 {
3542/*
3543 poly t;
3544 if((t=pSub(pCopy(H0->m[i]), pCopy(H1->m[i]))) != NULL)
3545 {
3546 pDelete(&t);
3547 return 0;
3548 }
3549 pDelete(&t);
3550*/
3551 if(!pEqualPolys(H0->m[i],H1->m[i]))
3552 {
3553 return 0;
3554 }
3555 }
3556 return 1;
3557}
#define pEqualPolys(p1, p2)
Definition: polys.h:399

◆ test_w_in_ConeCC()

static int test_w_in_ConeCC ( ideal  G,
intvec iv 
)
static

Definition at line 785 of file walk.cc.

786{
787 if(G->m[0] == NULL)
788 {
789 PrintS("//** the result may be WRONG, i.e. 0!!\n");
790 return 0;
791 }
792
793 BOOLEAN nError = Overflow_Error;
795
796 int i, nG = IDELEMS(G);
797 poly mi, gi;
798
799 for(i=nG-1; i>=0; i--)
800 {
801 mi = MpolyInitialForm(G->m[i], iv);
802 //Print("\n **// test_w_in_ConeCC: lm(initial)= %s \n",pString(mi));
803 gi = G->m[i];
804 //Print("\n **// test_w_in_ConeCC: lm(ideal)= %s \n",pString(gi));
805 if(mi == NULL)
806 {
807 if(Overflow_Error == FALSE)
808 {
809 Overflow_Error = nError;
810 }
811 return 0;
812 }
813 if(!pLmEqual(mi, gi))
814 {
815 pDelete(&mi);
816 if(Overflow_Error == FALSE)
817 {
818 Overflow_Error = nError;
819 }
820 return 0;
821 }
822 pDelete(&mi);
823 }
824
825 if(Overflow_Error == FALSE)
826 {
827 Overflow_Error = nError;
828 }
829 return 1;
830}
#define pLmEqual(p1, p2)
Definition: polys.h:111

◆ TranMImprovwalk()

ideal TranMImprovwalk ( ideal  G,
intvec curr_weight,
intvec target_tmp,
int  nP 
)

Definition at line 8396 of file walk.cc.

8397{
8398#ifdef TIME_TEST
8399 clock_t mtim = clock();
8400#endif
8401 Set_Error(FALSE );
8403 //Print("// pSetm_Error = (%d)", ErrorCheck());
8404 //Print("\n// ring ro = %s;", rString(currRing));
8405
8406#ifdef TIME_TEST
8407 clock_t tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0, textra=0;
8408 clock_t tinput = clock();
8409#endif
8410 int nsteppert=0, i, nV = currRing->N, nwalk=0, npert_tmp=0;
8411 int *npert=(int*)omAlloc(2*nV*sizeof(int));
8412 ideal Gomega, M,F, G1, Gomega1, Gomega2, M1, F1;
8413 //ring endRing;
8414 ring newRing, oldRing, lpRing;
8415 intvec* next_weight;
8416 intvec* ivNull = new intvec(nV); //define (0,...,0)
8417 intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
8418 intvec* iv_lp = Mivlp(nV); //define (1,0,...,0)
8419 ideal H0;
8420 //ideal H1;
8421 ideal H2, Glp;
8422 int nGB, endwalks = 0, nwalkpert=0;
8423 intvec* Mlp = MivMatrixOrderlp(nV);
8424 intvec* vector_tmp = new intvec(nV);
8425#ifndef BUCHBERGER_ALG
8426 intvec* hilb_func;
8427#endif
8428 // to avoid (1,0,...,0) as the target vector
8429 intvec* last_omega = new intvec(nV);
8430 for(i=nV-1; i>0; i--)
8431 (*last_omega)[i] = 1;
8432 (*last_omega)[0] = 10000;
8433
8434 // intvec* extra_curr_weight = new intvec(nV);
8435 intvec* target_weight = new intvec(nV);
8436 for(i=nV-1; i>=0; i--)
8437 (*target_weight)[i] = (*target_tmp)[i];
8438
8439 ring XXRing = currRing;
8440 newRing = currRing;
8441
8442#ifdef TIME_TEST
8443 to=clock();
8444#endif
8445 // compute a red. GB w.r.t. the help ring
8446 if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) = "dp"
8447 G = MstdCC(G);
8448 else
8449 {
8450 //rOrdStr(currRing) = (a(.c_w..),lp,C)
8451 if (rParameter(currRing) != NULL)
8452 DefRingPar(curr_weight);
8453 else
8454 rChangeCurrRing(VMrDefault(curr_weight));
8455 G = idrMoveR(G, XXRing,currRing);
8456 G = MstdCC(G);
8457 }
8458#ifdef TIME_TEST
8459 tostd=clock()-to;
8460#endif
8461
8462#ifdef REPRESENTATION_OF_SIGMA
8463 ideal Gw = MwalkInitialForm(G, curr_weight);
8464
8465 if(islengthpoly2(Gw)==1)
8466 {
8467 intvec* MDp;
8468 if(MivComp(curr_weight, iv_dp) == 1)
8469 MDp = MatrixOrderdp(nV); //MivWeightOrderlp(iv_dp);
8470 else
8471 MDp = MivWeightOrderlp(curr_weight);
8472
8473 curr_weight = RepresentationMatrix_Dp(G, MDp);
8474
8475 delete MDp;
8476
8477 ring exring = currRing;
8478
8479 if (rParameter(currRing) != NULL)
8480 DefRingPar(curr_weight);
8481 else
8482 rChangeCurrRing(VMrDefault(curr_weight));
8483#ifdef TIME_TEST
8484 to=clock();
8485#endif
8486 Gw = idrMoveR(G, exring,currRing);
8487 G = MstdCC(Gw);
8488 Gw = NULL;
8489#ifdef TIME_TEST
8490 tostd=tostd+clock()-to;
8491#endif
8492 //ivString(curr_weight,"rep. sigma");
8493 goto COMPUTE_NEW_VECTOR;
8494 }
8495
8496 idDelete(&Gw);
8497 delete iv_dp;
8498#endif
8499
8500
8501 while(1)
8502 {
8503#ifdef TIME_TEST
8504 to=clock();
8505#endif
8506 /* compute an initial form ideal of <G> w.r.t. "curr_vector" */
8507 Gomega = MwalkInitialForm(G, curr_weight);
8508#ifdef TIME_TEST
8509 tif=tif+clock()-to;
8510#endif
8511
8512#ifndef BUCHBERGER_ALG
8513 if(isNolVector(curr_weight) == 0)
8514 hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
8515 else
8516 hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
8517#endif // BUCHBERGER_ALG
8518
8519 oldRing = currRing;
8520
8521 /* define a new ring that its ordering is "(a(curr_weight),lp) */
8522 if (rParameter(currRing) != NULL)
8523 DefRingPar(curr_weight);
8524 else
8525 rChangeCurrRing(VMrDefault(curr_weight));
8526
8527 newRing = currRing;
8528 Gomega1 = idrMoveR(Gomega, oldRing,currRing);
8529
8530#ifdef TIME_TEST
8531 to=clock();
8532#endif
8533 /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
8534#ifdef BUCHBERGER_ALG
8535 M = MstdhomCC(Gomega1);
8536#else
8537 M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
8538 delete hilb_func;
8539#endif // BUCHBERGER_ALG
8540#ifdef TIME_TEST
8541 tstd=tstd+clock()-to;
8542#endif
8543
8544 /* change the ring to oldRing */
8545 rChangeCurrRing(oldRing);
8546 M1 = idrMoveR(M, newRing,currRing);
8547 Gomega2 = idrMoveR(Gomega1, newRing,currRing);
8548
8549#ifdef TIME_TEST
8550 to=clock();
8551#endif
8552 /* compute a representation of the generators of submod (M)
8553 with respect to those of mod (Gomega).
8554 Gomega is a reduced Groebner basis w.r.t. the current ring */
8555 F = MLifttwoIdeal(Gomega2, M1, G);
8556#ifdef TIME_TEST
8557 tlift=tlift+clock()-to;
8558#endif
8559
8560 idDelete(&M1);
8561 idDelete(&Gomega2);
8562 idDelete(&G);
8563
8564 /* change the ring to newRing */
8565 rChangeCurrRing(newRing);
8566 F1 = idrMoveR(F, oldRing,currRing);
8567
8568#ifdef TIME_TEST
8569 to=clock();
8570#endif
8571 /* reduce the Groebner basis <G> w.r.t. new ring */
8572 G = kInterRedCC(F1, NULL);
8573#ifdef TIME_TEST
8574 tred=tred+clock()-to;
8575#endif
8576 idDelete(&F1);
8577
8578
8579 COMPUTE_NEW_VECTOR:
8580 newRing = currRing;
8581 nwalk++;
8582 nwalkpert++;
8583#ifdef TIME_TEST
8584 to=clock();
8585#endif
8586 // compute a next weight vector
8587 next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
8588#ifdef TIME_TEST
8589 tnw=tnw+clock()-to;
8590#endif
8591#ifdef PRINT_VECTORS
8592 MivString(curr_weight, target_weight, next_weight);
8593#endif
8594
8595 /* check whether the computed intermediate weight vector is in
8596 the correct cone; sometimes it is very big e.g. s7, cyc7.
8597 If it is NOT in the correct cone, then compute directly
8598 a reduced Groebner basis with respect to the lexicographic ordering
8599 for the known Groebner basis that it is computed in the last step.
8600 */
8601 //if(test_w_in_ConeCC(G, next_weight) != 1)
8602 if(Overflow_Error == TRUE)
8603 {
8604 OMEGA_OVERFLOW_TRAN_NEW:
8605 //Print("\n// takes %d steps!", nwalk-1);
8606 //Print("\n//ring lastRing = %s;", rString(currRing));
8607#ifdef TEST_OVERFLOW
8608 goto BE_FINISH;
8609#endif
8610/*
8611#ifdef CHECK_IDEAL_MWALK
8612 idElements(G, "G");
8613 //headidString(G, "G");
8614#endif
8615*/
8616 if(MivSame(target_tmp, iv_lp) == 1)
8617 if (rParameter(currRing) != NULL)
8618 DefRingParlp();
8619 else
8620 VMrDefaultlp();
8621 else
8622 if (rParameter(currRing) != NULL)
8623 DefRingPar(target_tmp);
8624 else
8625 rChangeCurrRing(VMrDefault(target_tmp));
8626
8627 lpRing = currRing;
8628 G1 = idrMoveR(G, newRing,currRing);
8629
8630#ifdef TIME_TEST
8631 to=clock();
8632#endif
8633 /*apply kStd or LastGB to compute a lex. red. Groebner basis of <G>*/
8634 if(nP == 0 || MivSame(target_tmp, iv_lp) == 0){
8635 //Print("\n\n// calls \"std in ring r_%d = %s;", nwalk, rString(currRing));
8636 G = MstdCC(G1);//no result for qnt1
8637 }
8638 else {
8639 rChangeCurrRing(newRing);
8640 G1 = idrMoveR(G1, lpRing,currRing);
8641
8642 //Print("\n\n// calls \"LastGB\" (%d) to compute a GB", nV-1);
8643 G = LastGB(G1, curr_weight, nV-1); //no result for kats7
8644
8645 rChangeCurrRing(lpRing);
8646 G = idrMoveR(G, newRing,currRing);
8647 }
8648#ifdef TIME_TEST
8649 textra=clock()-to;
8650#endif
8651 npert[endwalks]=nwalk-npert_tmp;
8652 npert_tmp = nwalk;
8653 endwalks ++;
8654 break;
8655 }
8656
8657 /* check whether the computed Groebner basis is really a Groebner basis.
8658 If not, we perturb the target vector with the maximal "perturbation"
8659 degree.*/
8660 if(MivComp(next_weight, target_weight) == 1 ||
8661 MivComp(next_weight, curr_weight) == 1 )
8662 {
8663 //Print("\n//ring r_%d = %s;", nwalk, rString(currRing));
8664
8665
8666 //compute the number of perturbations and its step
8667 npert[endwalks]=nwalk-npert_tmp;
8668 npert_tmp = nwalk;
8669
8670 endwalks ++;
8671
8672 /*it is very important if the walk only uses one step, e.g. Fate, liu*/
8673 if(endwalks == 1 && MivComp(next_weight, curr_weight) == 1){
8674 rChangeCurrRing(XXRing);
8675 G = idrMoveR(G, newRing,currRing);
8676 goto FINISH;
8677 }
8678 H0 = id_Head(G,currRing);
8679
8680 if(MivSame(target_tmp, iv_lp) == 1)
8681 if (rParameter(currRing) != NULL)
8682 DefRingParlp();
8683 else
8684 VMrDefaultlp();
8685 else
8686 if (rParameter(currRing) != NULL)
8687 DefRingPar(target_tmp);
8688 else
8689 rChangeCurrRing(VMrDefault(target_tmp));
8690
8691 lpRing = currRing;
8692 Glp = idrMoveR(G, newRing,currRing);
8693 H2 = idrMoveR(H0, newRing,currRing);
8694
8695 /* Apply Lemma 2.2 in Collart et. al (1997) to check whether
8696 cone(k-1) is equal to cone(k) */
8697 nGB = 1;
8698 for(i=IDELEMS(Glp)-1; i>=0; i--)
8699 {
8700 poly t;
8701 if((t=pSub(pHead(Glp->m[i]), pCopy(H2->m[i]))) != NULL)
8702 {
8703 pDelete(&t);
8704 idDelete(&H2);//5.5.02
8705 nGB = 0; //i.e. Glp is no reduced Groebner basis
8706 break;
8707 }
8708 pDelete(&t);
8709 }
8710
8711 idDelete(&H2);//5.5.02
8712
8713 if(nGB == 1)
8714 {
8715 G = Glp;
8716 Glp = NULL;
8717 break;
8718 }
8719
8720 /* perturb the target weight vector, if the vector target_tmp
8721 stays in many cones */
8722 poly p;
8723 BOOLEAN plength3 = FALSE;
8724 for(i=IDELEMS(Glp)-1; i>=0; i--)
8725 {
8726 p = MpolyInitialForm(Glp->m[i], target_tmp);
8727 if(p->next != NULL &&
8728 p->next->next != NULL &&
8729 p->next->next->next != NULL)
8730 {
8732
8733 for(i=0; i<nV; i++)
8734 (*vector_tmp)[i] = (*target_weight)[i];
8735
8736 delete target_weight;
8737 target_weight = MPertVectors(Glp, Mlp, nV);
8738
8739 if(MivComp(vector_tmp, target_weight)==1)
8740 {
8741 //PrintS("\n// The old and new representaion vector are the same!!");
8742 G = Glp;
8743 newRing = currRing;
8744 goto OMEGA_OVERFLOW_TRAN_NEW;
8745 }
8746
8747 if(Overflow_Error == TRUE)
8748 {
8749 rChangeCurrRing(newRing);
8750 G = idrMoveR(Glp, lpRing,currRing);
8751 goto OMEGA_OVERFLOW_TRAN_NEW;
8752 }
8753
8754 plength3 = TRUE;
8755 pDelete(&p);
8756 break;
8757 }
8758 pDelete(&p);
8759 }
8760
8761 if(plength3 == FALSE)
8762 {
8763 rChangeCurrRing(newRing);
8764 G = idrMoveR(Glp, lpRing,currRing);
8765 goto TRAN_LIFTING;
8766 }
8767
8768
8769 nwalkpert = 1;
8770 nsteppert ++;
8771
8772 /*
8773 Print("\n// Subroutine needs (%d) steps.", nwalk);
8774 idElements(Glp, "last G in walk:");
8775 PrintS("\n// ****************************************");
8776 Print("\n// Perturb the original target vector (%d): ", nsteppert);
8777 ivString(target_weight, "new target");
8778 PrintS("\n// ****************************************\n");
8779 */
8780 rChangeCurrRing(newRing);
8781 G = idrMoveR(Glp, lpRing,currRing);
8782
8783 delete next_weight;
8784
8785 //Print("\n// ring rNEW = %s;", rString(currRing));
8786 goto COMPUTE_NEW_VECTOR;
8787 }
8788
8789 TRAN_LIFTING:
8790 for(i=nV-1; i>=0; i--)
8791 (*curr_weight)[i] = (*next_weight)[i];
8792
8793 delete next_weight;
8794 }//while
8795#ifdef TEST_OVERFLOW
8796 BE_FINISH:
8797#endif
8798 rChangeCurrRing(XXRing);
8799 G = idrMoveR(G, lpRing,currRing);
8800
8801 FINISH:
8802 delete ivNull;
8803 delete next_weight;
8804 delete iv_lp;
8805 omFree(npert);
8806/*
8807#ifdef TIME_TEST
8808 Print("\n// Computation took %d steps and %.2f sec",
8809 nwalk, ((double) (clock()-mtim)/1000000));
8810
8811 TimeStringFractal(tinput, tostd, tif, tstd, textra, tlift, tred, tnw);
8812
8813 // Print("\n// pSetm_Error = (%d)", ErrorCheck());
8814 Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
8815#endif
8816*/
8817 return(G);
8818}
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms

◆ VMatrDefault()

static ring VMatrDefault ( intvec va)
static

Definition at line 2790 of file walk.cc.

2791{
2792
2793 ring r = rCopy0(currRing,FALSE,FALSE);
2794 int i, nv = currRing->N;
2795
2796 int nb = 4;
2797
2798 /*weights: entries for 3 blocks: NULL Made:???*/
2799 r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2800 r->wvhdl[0] = (int*) omAlloc(nv*nv*sizeof(int));
2801 r->wvhdl[1] =NULL; // (int*) omAlloc(nv*sizeof(int));
2802 r->wvhdl[2]=NULL;
2803 r->wvhdl[3]=NULL;
2804 for(i=0; i<nv*nv; i++)
2805 r->wvhdl[0][i] = (*va)[i];
2806
2807 /* order: a,lp,C,0 */
2808 r->order = (rRingOrder_t*) omAlloc(nb * sizeof(rRingOrder_t*));
2809 r->block0 = (int *)omAlloc0(nb * sizeof(int *));
2810 r->block1 = (int *)omAlloc0(nb * sizeof(int *));
2811
2812 // ringorder a for the first block: var 1..nv
2813 r->order[0] = ringorder_M;
2814 r->block0[0] = 1;
2815 r->block1[0] = nv;
2816
2817 // ringorder C for the second block
2818 r->order[1] = ringorder_C;
2819 r->block0[1] = 1;
2820 r->block1[1] = nv;
2821
2822// ringorder C for the third block: var 1..nv
2823 r->order[2] = ringorder_C;
2824 r->block0[2] = 1;
2825 r->block1[2] = nv;
2826
2827 // the last block: everything is 0
2828 r->order[3] = (rRingOrder_t)0;
2829
2830 // complete ring intializations
2831
2832 rComplete(r);
2833
2834 //rChangeCurrRing(r);
2835 return r;
2836}
@ ringorder_M
Definition: ring.h:74

◆ VMatrRefine()

static ring VMatrRefine ( intvec va,
intvec vb 
)
static

Definition at line 2841 of file walk.cc.

2842{
2843
2844 ring r = rCopy0(currRing,FALSE,FALSE);
2845 int i, nv = currRing->N;
2846 int nvs = nv*nv;
2847
2848 int nb = 4;
2849
2850 /*weights: entries for 3 blocks: NULL Made:???*/
2851 r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2852 r->wvhdl[0] = (int*) omAlloc(nv*sizeof(int));
2853 r->wvhdl[1] = (int*) omAlloc(nvs*sizeof(int));
2854 r->wvhdl[2]=NULL;
2855 r->wvhdl[3]=NULL;
2856 for(i=0; i<nvs; i++)
2857 {
2858 r->wvhdl[1][i] = (*va)[i];
2859 }
2860 for(i=0; i<nv; i++)
2861 {
2862 r->wvhdl[0][i] = (*vb)[i];
2863 }
2864 /* order: a,lp,C,0 */
2865 r->order = (rRingOrder_t *) omAlloc(nb * sizeof(rRingOrder_t *));
2866 r->block0 = (int *)omAlloc0(nb * sizeof(int *));
2867 r->block1 = (int *)omAlloc0(nb * sizeof(int *));
2868
2869 // ringorder a for the first block: var 1..nv
2870 r->order[0] = ringorder_a;
2871 r->block0[0] = 1;
2872 r->block1[0] = nv;
2873
2874 // ringorder M for the second block: var 1..nv
2875 r->order[1] = ringorder_M;
2876 r->block0[1] = 1;
2877 r->block1[1] = nv;
2878
2879 // ringorder C for the third block: var 1..nv
2880 r->order[2] = ringorder_C;
2881 r->block0[2] = 1;
2882 r->block1[2] = nv;
2883
2884 // the last block: everything is 0
2885 r->order[3] = (rRingOrder_t)0;
2886
2887 // complete ring intializations
2888
2889 rComplete(r);
2890
2891 //rChangeCurrRing(r);
2892 return r;
2893}

◆ VMrDefault()

static ring VMrDefault ( intvec va)
static

Definition at line 2680 of file walk.cc.

2681{
2682
2683 ring r = rCopy0(currRing,FALSE,FALSE);
2684 int i, nv = currRing->N;
2685
2686 int nb = 4;
2687
2688 /*weights: entries for 3 blocks: NULL Made:???*/
2689 r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2690 r->wvhdl[0] = (int*) omAlloc(nv*sizeof(int));
2691 for(i=0; i<nv; i++)
2692 r->wvhdl[0][i] = (*va)[i];
2693
2694 /* order: a,lp,C,0 */
2695 r->order = (rRingOrder_t *) omAlloc(nb * sizeof(rRingOrder_t *));
2696 r->block0 = (int *)omAlloc0(nb * sizeof(int *));
2697 r->block1 = (int *)omAlloc0(nb * sizeof(int *));
2698
2699 // ringorder a for the first block: var 1..nv
2700 r->order[0] = ringorder_a;
2701 r->block0[0] = 1;
2702 r->block1[0] = nv;
2703
2704 // ringorder lp for the second block: var 1..nv
2705 r->order[1] = ringorder_lp;
2706 r->block0[1] = 1;
2707 r->block1[1] = nv;
2708
2709 // ringorder C for the third block
2710 // it is very important within "idLift",
2711 // especially, by ring syz_ring=rCurrRingAssure_SyzComp();
2712 // therefore, nb must be (nBlocks(currRing) + 1)
2713 r->order[2] = ringorder_C;
2714
2715 // the last block: everything is 0
2716 r->order[3] = (rRingOrder_t)0;
2717
2718 // polynomial ring
2719 r->OrdSgn = 1;
2720
2721 // complete ring intializations
2722
2723 rComplete(r);
2724 return r;
2725 //rChangeCurrRing(r);
2726}

◆ VMrDefaultlp()

static void VMrDefaultlp ( void  )
static

Definition at line 2898 of file walk.cc.

2899{
2900 ring r = rCopy0(currRing,FALSE,FALSE);
2901 int nv = currRing->N;
2902
2903 int nb = rBlocks(currRing) + 1;
2904
2905 /*weights: entries for 3 blocks: NULL Made:???*/
2906
2907 r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2908
2909 /* order: lp,C,0 */
2910 r->order = (rRingOrder_t *) omAlloc(nb * sizeof(rRingOrder_t *));
2911 r->block0 = (int *)omAlloc0(nb * sizeof(int *));
2912 r->block1 = (int *)omAlloc0(nb * sizeof(int *));
2913
2914 /* ringorder lp for the first block: var 1..nv */
2915 r->order[0] = ringorder_lp;
2916 r->block0[0] = 1;
2917 r->block1[0] = nv;
2918
2919 /* ringorder C for the second block */
2920 r->order[1] = ringorder_C;
2921
2922 /* the last block: everything is 0 */
2923 r->order[2] = (rRingOrder_t)0;
2924
2925 /*polynomial ring*/
2926 r->OrdSgn = 1;
2927
2928 /* complete ring intializations */
2929
2930 rComplete(r);
2931
2932 rChangeCurrRing(r);
2933}

◆ VMrRefine()

static ring VMrRefine ( intvec va,
intvec vb 
)
static

Definition at line 2731 of file walk.cc.

2732{
2733
2734 ring r = rCopy0(currRing,FALSE,FALSE);
2735 int i, nv = currRing->N;
2736
2737 int nb = 5;
2738
2739 //weights: entries for 3 blocks: NULL Made:???
2740 r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
2741 r->wvhdl[0] = (int*) omAlloc(nv*sizeof(int));
2742 r->wvhdl[1] = (int*) omAlloc(nv*sizeof(int));
2743
2744 for(i=0; i<nv; i++)
2745 {
2746 r->wvhdl[0][i] = (*vb)[i];
2747 r->wvhdl[1][i] = (*va)[i];
2748 }
2749
2750 // order: (1..1),a,lp,C
2751 r->order = (rRingOrder_t *) omAlloc(nb * sizeof(rRingOrder_t *));
2752 r->block0 = (int *)omAlloc0(nb * sizeof(int *));
2753 r->block1 = (int *)omAlloc0(nb * sizeof(int *));
2754
2755 // ringorder a for the first block: var 1..nv
2756 r->order[0] = ringorder_a;
2757 r->block0[0] = 1;
2758 r->block1[0] = nv;
2759
2760 // ringorder Wp for the second block: var 1..nv
2761 r->order[1] = ringorder_a;
2762 r->block0[1] = 1;
2763 r->block1[1] = nv;
2764
2765 // ringorder lp for the third block: var 1..nv
2766 r->order[2] = ringorder_lp;
2767 r->block0[2] = 1;
2768 r->block1[2] = nv;
2769
2770 // ringorder C for the 4th block
2771 // it is very important within "idLift",
2772 // especially, by ring syz_ring=rCurrRingAssure_SyzComp();
2773 // therefore, nb must be (nBlocks(currRing) + 1)
2774 r->order[3] = ringorder_C;
2775
2776 // the last block: everything is 0
2777 r->order[4] = (rRingOrder_t)0;
2778
2779 // complete ring intializations
2780
2781 rComplete(r);
2782
2783 //rChangeCurrRing(r);
2784 return r;
2785}

Variable Documentation

◆ ngleich

VAR int ngleich

Definition at line 4505 of file walk.cc.

◆ nnflow

VAR int nnflow

Definition at line 6944 of file walk.cc.

◆ nstep

VAR int nstep

kstd2.cc

Definition at line 80 of file walk.cc.

◆ Overflow_Error

VAR BOOLEAN Overflow_Error = FALSE

Definition at line 88 of file walk.cc.

◆ pSetm_error

EXTERN_VAR BOOLEAN pSetm_error

Definition at line 84 of file walk.cc.

◆ Xcall

VAR int Xcall

Definition at line 6945 of file walk.cc.

◆ Xivinput

VAR intvec* Xivinput

Definition at line 4509 of file walk.cc.

◆ Xivlp

VAR intvec* Xivlp

Definition at line 4510 of file walk.cc.

◆ XivNull

VAR intvec* XivNull

Definition at line 6927 of file walk.cc.

◆ xn

VAR int xn

Definition at line 4508 of file walk.cc.

◆ Xngleich

VAR int Xngleich

Definition at line 6946 of file walk.cc.

◆ Xnlev

VAR int Xnlev

Definition at line 1511 of file walk.cc.

◆ Xsigma

VAR intvec* Xsigma

Definition at line 4506 of file walk.cc.

◆ Xtau

VAR intvec* Xtau

Definition at line 4507 of file walk.cc.