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