int sfa_one(double *x, double *gap, int * activeS, double *z, double * v, double * Av, double lambda, int nn, int maxStep, double *s, double *g, double tol, int tau){ int i, iterStep, m; int tFlag=0; //int n=nn+1; double temp; int* S=(int *) malloc(sizeof(int)*nn); double gapp=-1, gappp=-2; /*gapp denotes the previous gap*/ int numS=-100, numSp=-200, numSpp=-300; /* numS denotes the number of elements in the Support Set S numSp denotes the number of elements in the previous Support Set S */ *gap=-1; /*initialize *gap a value*/ /* The main algorithm by Nesterov's method B is an nn x nn tridiagonal matrix. The nn eigenvalues of B are 2- 2 cos (i * PI/ n), i=1, 2, ..., nn */ /* we first do a gradient step based on z */ /* --------------------------------------------------- A gradient step begins */ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; /* do a gradient step based on z to get the new z */ m=nn%5; if (m!=0){ for(i=0;i<m; i++) z[i]=z[i] - g[i]/4; } for (i=m;i<nn; i+=5){ z[i] = z[i] - g[i] /4; z[i+1] = z[i+1] - g[i+1]/4; z[i+2] = z[i+2] - g[i+2]/4; z[i+3] = z[i+3] - g[i+3]/4; z[i+4] = z[i+4] - g[i+4]/4; } /* project z onto the L_{infty} ball with radius lambda z is the new approximate solution */ for (i=0;i<nn; i++){ if (z[i]>lambda) z[i]=lambda; else if (z[i]<-lambda) z[i]=-lambda; } /* --------------------------------------------------- A gradient descent step ends */ /*compute the gradient at z*/ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; for (iterStep=1; iterStep<=maxStep; iterStep++){ /* --------------------------------------------------- restart the algorithm with x=omega(z) */ numSpp=numSp; numSp=numS; /*record the previous numS*/ numS = supportSet(x, v, z, g, S, lambda, nn); /*With x, we compute z via AA^T z = Av - Ax */ /* compute s= Av -Ax */ for (i=0;i<nn; i++) s[i]=Av[i] - x[i+1] + x[i]; /* Apply Rose Algorithm for solving z */ Thomas(&temp, z, s, nn); /* Rose(&temp, z, s, nn); */ /* project z to [-lambda, lambda] */ for(i=0;i<nn;i++){ if (z[i]>lambda) z[i]=lambda; else if (z[i]<-lambda) z[i]=-lambda; } /* --------------------------------------------------- restart the algorithm with x=omega(z) we have computed a new z, based on the above relationship */ /* --------------------------------------------------- A gradient step begins */ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; /* do a gradient step based on z to get the new z */ m=nn%5; if (m!=0){ for(i=0;i<m; i++) z[i]=z[i] - g[i]/4; } for (i=m;i<nn; i+=5){ z[i] = z[i] - g[i] /4; z[i+1] = z[i+1] - g[i+1]/4; z[i+2] = z[i+2] - g[i+2]/4; z[i+3] = z[i+3] - g[i+3]/4; z[i+4] = z[i+4] - g[i+4]/4; } /* project z onto the L_{infty} ball with radius lambda z is the new approximate solution */ for (i=0;i<nn; i++){ if (z[i]>lambda) z[i]=lambda; else if (z[i]<-lambda) z[i]=-lambda; } /* --------------------------------------------------- A gradient descent step ends */ /*compute the gradient at z*/ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; if (iterStep % tau==0){ gappp=gapp; gapp=*gap; /*record the previous gap*/ dualityGap2(gap, z, g, s, Av, lambda, nn); /*g, the gradient of z should be computed before calling this function*/ /* printf("\n iterStep=%d, numS=%d, gap=%e",iterStep, numS, *gap); */ /* printf("\n %d & %d & %2.0e \\\\ \n \\hline ",iterStep, numS, *gap); */ /* printf("\n %e",*gap); */ /* printf("\n %d",numS); */ if (*gap <=tol){ //tFlag=1; break; } m=1; if (nn > 1000000) m=5; else if (nn > 100000) m=3; if ( abs( numS-numSp) <m ){ /* printf("\n numS=%d, numSp=%d",numS,numSp); */ m=generateSolution(x, z, gap, v, Av, g, s, S, lambda, nn); /*g, the gradient of z should be computed before calling this function*/ if (*gap < tol){ numS=m; tFlag=2; break; } if ( (*gap ==gappp) && (numS==numSpp) ){ tFlag=2; break; } } /*end of if*/ }/*end of if tau*/ } /*end of for*/ if (tFlag!=2){ numS=generateSolution(x, z, gap, v, Av, g, s, S, lambda, nn); /*g, the gradient of z should be computed before calling this function*/ } free(S); *activeS=numS; return(iterStep); }
int sfa(double *x, double *gap, int * activeS, double *z, double *z0, double * v, double * Av, double lambda, int nn, int maxStep, double *s, double *g, double tol, int tau, int flag){ int i, iterStep, m, tFlag=0, n=nn+1; double alphap=0, alpha=1, beta=0, temp; int* S=(int *) malloc(sizeof(int)*nn); double gapp=-1, gappp=-1; /*gapp denotes the previous gap*/ int numS=-1, numSp=-2, numSpp=-3;; /* numS denotes the number of elements in the Support Set S numSp denotes the number of elements in the previous Support Set S */ *gap=-1; /*initial a value -1*/ /* The main algorithm by Nesterov's method B is an nn x nn tridiagonal matrix. The nn eigenvalues of B are 2- 2 cos (i * PI/ n), i=1, 2, ..., nn */ for (iterStep=1; iterStep<=maxStep; iterStep++){ /*------------- Step 1 ---------------------*/ beta=(alphap -1 ) / alpha; /* compute search point s= z + beta * z0 We follow the style of CLAPACK */ m=nn % 5; if (m!=0){ for (i=0;i<m; i++) s[i]=z[i]+ beta* z0[i]; } for (i=m;i<nn;i+=5){ s[i] =z[i] + beta* z0[i]; s[i+1] =z[i+1] + beta* z0[i+1]; s[i+2] =z[i+2] + beta* z0[i+2]; s[i+3] =z[i+3] + beta* z0[i+3]; s[i+4] =z[i+4] + beta* z0[i+4]; } /* s and g are of size nn x 1 compute the gradient at s g= B * s - Av, where B is an nn x nn tridiagonal matrix. and is defined as B= [ 2 -1 0 0; -1 2 -1 0; 0 -1 2 -1; 0 0 -1 2] We assume n>=3, which leads to nn>=2 */ g[0]=s[0] + s[0] - s[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - s[i-1] + s[i] + s[i] - s[i+1] - Av[i]; } g[nn-1]= -s[nn-2] + s[nn-1] + s[nn-1] - Av[nn-1]; /* z0 stores the previous -z */ m=nn%7; if (m!=0){ for (i=0;i<m;i++) z0[i]=-z[i]; } for (i=m; i <nn; i+=7){ z0[i] = - z[i]; z0[i+1] = - z[i+1]; z0[i+2] = - z[i+2]; z0[i+3] = - z[i+3]; z0[i+4] = - z[i+4]; z0[i+5] = - z[i+5]; z0[i+6] = - z[i+6]; } /* do a gradient step based on s to get z */ m=nn%5; if (m!=0){ for(i=0;i<m; i++) z[i]=s[i] - g[i]/4; } for (i=m;i<nn; i+=5){ z[i] = s[i] - g[i] /4; z[i+1] = s[i+1] - g[i+1]/4; z[i+2] = s[i+2] - g[i+2]/4; z[i+3] = s[i+3] - g[i+3]/4; z[i+4] = s[i+4] - g[i+4]/4; } /* project z onto the L_{infty} ball with radius lambda z is the new approximate solution */ for (i=0;i<nn; i++){ if (z[i]>lambda) z[i]=lambda; else if (z[i]<-lambda) z[i]=-lambda; } /* compute the difference between the new solution and the previous solution (stored in z0=-z_p) the difference is written to z0 */ m=nn%5; if (m!=0){ for (i=0;i<m;i++) z0[i]+=z[i]; } for(i=m;i<nn; i+=5){ z0[i] +=z[i]; z0[i+1]+=z[i+1]; z0[i+2]+=z[i+2]; z0[i+3]+=z[i+3]; z0[i+4]+=z[i+4]; } alphap=alpha; alpha=(1+sqrt(4*alpha*alpha+1))/2; /* check the termination condition */ if (iterStep%tau==0){ /* The variables g and s can be modified The variables x, z0 and z can be revised for case 0, but not for the rest */ switch (flag){ case 1: /* terminate the program once the "duality gap" is smaller than tol compute the duality gap: x= v - A^T z Ax = Av - A A^T z = -g, where g = A A^T z - A v the duality gap= lambda * \|Ax\|-1 - <z, Ax> = lambda * \|g\|_1 + <z, g> In fact, gap=0 indicates that, if g_i >0, then z_i=-lambda if g_i <0, then z_i=lambda */ gappp=gapp; gapp=*gap; /*record the previous gap*/ numSpp=numSp; numSp=numS; /*record the previous numS*/ dualityGap(gap, z, g, s, Av, lambda, nn); /*g is computed as the gradient of z in this function*/ /* printf("\n Iteration: %d, gap=%e, numS=%d", iterStep, *gap, numS); */ /* If *gap <=tol, we terminate the iteration Otherwise, we restart the algorithm */ if (*gap <=tol){ tFlag=1; break; } /* end of *gap <=tol */ else{ /* we apply the restarting technique*/ /* we compute the solution by the second way */ numS = supportSet(x, v, z, g, S, lambda, nn); /*g, the gradient of z should be computed before calling this function*/ /*With x, we compute z via AA^T z = Av - Ax */ /* printf("\n iterStep=%d, numS=%d, gap=%e",iterStep, numS, *gap); */ m=1; if (nn > 1000000) m=10; else if (nn > 100000) m=5; if ( abs(numS-numSp) < m){ numS=generateSolution(x, z, gap, v, Av, g, s, S, lambda, nn); /*g, the gradient of z should be computed before calling this function*/ if (*gap <tol){ tFlag=2; /*tFlag =2 shows that the result is already optimal There is no need to call generateSolution for recomputing the best solution */ break; } if ( (*gap ==gappp) && (numS==numSpp) ){ tFlag=2; break; } /*we terminate the program is *gap <1 numS==numSP and gapp==*gap */ } /* compute s= Av -Ax */ for (i=0;i<nn; i++) s[i]=Av[i] - x[i+1] + x[i]; /* apply Rose Algorithm for solving z */ Thomas(&temp, z, s, nn); /* Rose(&temp, z, s, nn); */ /* printf("\n Iteration: %d, %e", iterStep, temp); */ /* project z to [-lambda2, lambda2] */ for(i=0;i<nn;i++){ if (z[i]>lambda) z[i]=lambda; else if (z[i]<-lambda) z[i]=-lambda; } m=nn%7; if (m!=0){ for (i=0;i<m;i++) z0[i]=0; } for (i=m; i<nn; i+=7){ z0[i] = z0[i+1] = z0[i+2] = z0[i+3] = z0[i+4] = z0[i+5] = z0[i+6] =0; } alphap=0; alpha=1; /* we restart the algorithm */ } break; /*break case 1*/ case 2: /* The program is terminated either the summation of the absolution change (denoted by z0) of z (from the previous zp) is less than tol * nn, or the maximal number of iteration (maxStep) is achieved Note: tol indeed measures the averaged per element change. */ temp=0; m=nn%5; if (m!=0){ for(i=0;i<m;i++) temp+=fabs(z0[i]); } for(i=m;i<nn;i+=5) temp=temp + fabs(z0[i]) + fabs(z0[i+1]) + fabs(z0[i+2]) + fabs(z0[i+3]) + fabs(z0[i+4]); *gap=temp / nn; if (*gap <=tol){ tFlag=1; } break; case 3: /* terminate the program once the "duality gap" is smaller than tol compute the duality gap: x= v - A^T z Ax = Av - A A^T z = -g, where g = A A^T z - A v the duality gap= lambda * \|Ax\|-1 - <z, Ax> = lambda * \|g\|_1 + <z, g> In fact, gap=0 indicates that, if g_i >0, then z_i=-lambda if g_i <0, then z_i=lambda */ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; for (i=0;i<nn;i++) if (g[i]>0) s[i]=lambda + z[i]; else s[i]=-lambda + z[i]; temp=0; m=nn%5; if (m!=0){ for(i=0;i<m;i++) temp+=s[i]*g[i]; } for(i=m;i<nn;i+=5) temp=temp + s[i] *g[i] + s[i+1]*g[i+1] + s[i+2]*g[i+2] + s[i+3]*g[i+3] + s[i+4]*g[i+4]; *gap=temp; /* printf("\n %e", *gap); */ if (*gap <=tol) tFlag=1; break; case 4: /* terminate the program once the "relative duality gap" is smaller than tol compute the duality gap: x= v - A^T z Ax = Av - A A^T z = -g, where g = A A^T z - A v the duality gap= lambda * \|Ax\|-1 - <z, Ax> = lambda * \|g\|_1 + <z, g> In fact, gap=0 indicates that, if g_i >0, then z_i=-lambda if g_i <0, then z_i=lambda Here, the "relative duality gap" is defined as: duality gap / - 1/2 \|A^T z\|^2 + < z, Av> We efficiently compute - 1/2 \|A^T z\|^2 + < z, Av> using the following relationship - 1/2 \|A^T z\|^2 + < z, Av> = -1/2 <z, A A^T z - Av -Av> = -1/2 <z, g - Av> */ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; for (i=0;i<nn;i++) if (g[i]>0) s[i]=lambda + z[i]; else s[i]=-lambda + z[i]; temp=0; m=nn%5; if (m!=0){ for(i=0;i<m;i++) temp+=s[i]*g[i]; } for(i=m;i<nn;i+=5) temp=temp + s[i] *g[i] + s[i+1]*g[i+1] + s[i+2]*g[i+2] + s[i+3]*g[i+3] + s[i+4]*g[i+4]; *gap=temp; /* Now, *gap contains the duality gap Next, we compute - 1/2 \|A^T z\|^2 + < z, Av> =-1/2 <z, g - Av> */ temp=0; m=nn%5; if (m!=0){ for(i=0;i<m;i++) temp+=z[i] * (g[i] - Av[i]); } for(i=m;i<nn;i+=5) temp=temp + z[i] * (g[i] - Av[i]) + z[i+1]* (g[i+1]- Av[i+1]) + z[i+2]* (g[i+2]- Av[i+2]) + z[i+3]* (g[i+3]- Av[i+3]) + z[i+4]* (g[i+4]- Av[i+4]); temp=fabs(temp) /2; if (temp <1) temp=1; *gap/=temp; /* *gap now contains the relative gap */ if (*gap <=tol){ tFlag=1; } break; default: /* The program is terminated either the summation of the absolution change (denoted by z0) of z (from the previous zp) is less than tol * nn, or the maximal number of iteration (maxStep) is achieved Note: tol indeed measures the averaged per element change. */ temp=0; m=nn%5; if (m!=0){ for(i=0;i<m;i++) temp+=fabs(z0[i]); } for(i=m;i<nn;i+=5) temp=temp + fabs(z0[i]) + fabs(z0[i+1]) + fabs(z0[i+2]) + fabs(z0[i+3]) + fabs(z0[i+4]); *gap=temp / nn; if (*gap <=tol){ tFlag=1; } break; }/*end of switch*/ if (tFlag) break; }/* end of the if for checking the termination condition */ /*-------------- Step 3 --------------------*/ } /* for the other cases, except flag=1, compute the solution x according the first way (the primal-dual way) */ if ( (flag !=1) || (tFlag==0) ){ x[0]=v[0] + z[0]; for(i=1;i<n-1;i++) x[i]= v[i] - z[i-1] + z[i]; x[n-1]=v[n-1] - z[n-2]; } if ( (flag==1) && (tFlag==1)){ /* We assume that n>=3, and thus nn>=2 We have two ways for recovering x. The first way is x = v - A^T z The second way is x =omega(z) */ /* We first compute the objective function value of the first choice in terms f(x), see our paper */ /* for numerical reason, we do a gradient descent step */ /* --------------------------------------------------- A gradient step begins */ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; /* do a gradient step based on z to get the new z */ m=nn%5; if (m!=0){ for(i=0;i<m; i++) z[i]=z[i] - g[i]/4; } for (i=m;i<nn; i+=5){ z[i] = z[i] - g[i] /4; z[i+1] = z[i+1] - g[i+1]/4; z[i+2] = z[i+2] - g[i+2]/4; z[i+3] = z[i+3] - g[i+3]/4; z[i+4] = z[i+4] - g[i+4]/4; } /* project z onto the L_{infty} ball with radius lambda z is the new approximate solution */ for (i=0;i<nn; i++){ if (z[i]>lambda) z[i]=lambda; else if (z[i]<-lambda) z[i]=-lambda; } /* --------------------------------------------------- A gradient descent step ends */ /*compute the gradient at z*/ g[0]=z[0] + z[0] - z[1] - Av[0]; for (i=1;i<nn-1;i++){ g[i]= - z[i-1] + z[i] + z[i] - z[i+1] - Av[i]; } g[nn-1]= -z[nn-2] + z[nn-1] + z[nn-1] - Av[nn-1]; numS=generateSolution(x, z, gap, v, Av, g, s, S, lambda, nn); /*g, the gradient of z should be computed before calling this function*/ } free (S); /* free the variables S */ *activeS=numS; return (iterStep); }
static void init() { int i, x, y, col; Entity *e, *prev; prev = self; x = self->x; y = self->y + self->h; col = 1; if (self->mental != 2) { for (i=0;i<50;i++) { /* 4 pegs per row, plus 1 score tile and 10 rows */ e = getFreeEntity(); if (e == NULL) { showErrorAndExit("No free slots to add a Mastermind Peg"); } if (col == 5) { loadProperties("item/mastermind_score", e); col = 0; e->mental = 1; } else { loadProperties("item/mastermind_peg", e); e->mental = 0; } setEntityAnimation(e, "STAND"); if (i == 0) { y -= TILE_SIZE; } if (i != 0 && i % 5 == 0) { x = self->x; y -= TILE_SIZE; } else if (i != 0) { x += TILE_SIZE; } e->face = RIGHT; e->x = x; e->y = y; e->action = &pegWait; e->draw = &drawLoopingAnimationToMap; prev->target = e; prev = e; e->target = NULL; col++; } generateSolution(); addCursor(); } self->action = &entityWait; }