/**
* Prints a list containing "crashes" to stdout.
* @param only_unreported
* Do not skip entries marked as already reported.
*/
static bool print_crash_list(vector_of_problem_data_t *crash_list, int detailed, int only_not_reported, long since, long until, int text_size)
{
bool output = false;
unsigned i;
for (i = 0; i < crash_list->len; ++i)
{
problem_data_t *crash = get_problem_data(crash_list, i);
if (only_not_reported)
{
if (problem_data_get_content_or_NULL(crash, FILENAME_REPORTED_TO))
continue;
}
if (since || until)
{
char *s = problem_data_get_content_or_NULL(crash, FILENAME_LAST_OCCURRENCE);
long val = s ? atol(s) : 0;
if (since && val < since)
continue;
if (until && val > until)
continue;
}
char hash_str[SHA1_RESULT_LEN*2 + 1];
struct problem_item *item = g_hash_table_lookup(crash, CD_DUMPDIR);
if (item)
printf("id %s\n", str_to_sha1str(hash_str, item->content));
print_crash(crash, detailed, text_size);
if (i != crash_list->len - 1)
printf("\n");
output = true;
}
return output;
}
/** \brief Perform backtraking linesearch.
*
*/
double backtracking_linesearch(problem_data_t *pdat, variables_t *vars,
double t, double *Adw, double *xnew)
{
int i, m, n;
double phi, s;
double *vnew, *wnew, *unew;
dmatrix *matX1, *matX2;
double *g, *h, *z, *expz, *expmz, *ac, *ar, *b, *d1, *d2, *Aw;
double *x, *v, *w, *u, *dx, *dv, *dw, *du, *gv, *gw, *gu, *gx;
double lambda, gdx;
get_problem_data(pdat, &matX1, &matX2, &ac, &ar, &b, &lambda);
m = matX1->m;
n = matX1->n;
get_variables(vars, &x, &v, &w, &u, &dx, &dv, &dw, &du, &gx, &gv,
&gw, &gu, &g, &h, &z, &expz, &expmz, &d1, &d2, &Aw);
vnew = xnew;
wnew = xnew+1;
unew = xnew+1+n;
s = 1.0;
phi = eval_phi(m, n, z, expz, expmz, w, u, lambda, t);
dmat_yAmpqx(matX1, ac, ar, dw, Adw); /* see below */
dmat_waxpby(m, dv[0], b, 1, Adw, Adw); /* Adw := A*dw+b*dv */
dmat_waxpby(m, v[0], b, 1, Aw, Aw); /* Aw := A*w+b*v */
dmat_waxpby(n+n+1, 1, dx, 1, x, xnew); /* xnew:= x + dx */
gdx = dmat_dot(n+n+1, gx, dx);
for (i = 1; i <= MAX_LS_ITER; i++)
{
/* x := x + s*dx */
if (is_indomain(wnew, unew, n) == TRUE)
{
double newphi;
/* z = A*(w+s*dw) + b*(v+s*dw)
= (Aw+bv) + s*(Adw+bdv),
where Aw, Adw+bdv are vectors. */
dmat_waxpby(m, s, Adw, 1, Aw, z);
dmat_yexpx(m, z, expz);
dmat_yinvx(m, expz, expmz);
newphi = eval_phi(m, n, z, expz, expmz, wnew, unew, lambda, t);
if (newphi <= phi + ALPHA * s * gdx) break;
}
s *= BETA;
dmat_waxpby(n+n+1, s, dx, 1, x, xnew);
}
if (i > MAX_LS_ITER) return -1;
dmat_vcopy(n+n+1,xnew,x);
return s;
}
/** \brief Compute search direction using cholesky method (m < n).
*
*/
void compute_searchdir_chol_fat(problem_data_t *pdat, variables_t *vars,
double t, dmatrix *B, dmatrix *BB,
double *tm1, double *bDA,
double *d3inv, double *tmp31, double *tmp32)
{
int i, m, n;
double bDb;
dmatrix *matX1, *matX2;
double lambda, tinv;
double *g, *h, *z, *expz, *expmz, *ac, *ar, *b, *d1, *d2, *Aw;
double *x, *v, *w, *u, *dx, *dv, *dw, *du, *gv, *gw, *gu, *gx;
get_problem_data(pdat, &matX1, &matX2, &ac, &ar, &b, &lambda);
get_variables(vars, &x, &v, &w, &u, &dx, &dv, &dw, &du, &gx, &gv,
&gw, &gu, &g, &h, &z, &expz, &expmz, &d1, &d2, &Aw);
m = matX1->m;
n = matX1->n;
tinv = 1.0 / t;
/* bDb, Db */
bDb = 0.0;
for (i = 0; i < m; i++)
{
tm1[i] = h[i] * b[i]; /* tm1 = Db */
bDb += b[i] * tm1[i];
}
/* bDA, D_inv */
dmat_yATx(matX1, tm1, bDA);
dmat_copy(matX1, B); /* B = A */
dmat_yinvx(m, h, tm1); /* tm1 = D_inv */
for (i = 0; i < n; i++)
{
double ui, wi, q1, q2, q3, gr2;
ui = u[i];
wi = w[i];
q1 = 1.0 / (ui + wi);
q2 = 1.0 / (ui - wi);
q3 = ui * ui + wi * wi;
gw[i] -= (q1 - q2) * tinv; /* A'*g - (q1-q2) */
gu[i] = lambda - (q1 + q2)*tinv; /* lambda - (q1+q2) */
d1[i] = (q1 * q1 + q2 * q2) * tinv;
d2[i] = (q1 * q1 - q2 * q2) * tinv;
gr2 = gw[i] + 2 * gu[i] * ui * wi / q3;
d3inv[i] = t * q3 / 2; /* en = d3^{-1} */
/* temporary use of tmp31 */
tmp31[i] = sqrt(d3inv[i]);
/* store temporary values in dw, du */
dw[i] = d3inv[i] * bDA[i]; /* dw := d3inv.*bDA */
du[i] = d3inv[i] * gr2; /* du := d3inv.*gr2 */
}
/* B = B*D3^{1/2} */
dmat_diagscale(B, NULL, FALSE, tmp31, FALSE);
/* S = BB = ... */
/* BB = A*D3_inv*A^T */
dmat_B_AAT(B, BB); /* BB = B*B^T */
/* BB = D_inv + A*D3_inv*A^T */
dmat_diagadd(BB, tm1);
/* SMW */
dmat_yAx(matX1, dw, tm1);
dmat_posv(BB, tm1);
dmat_yATx(matX1, tm1, tmp31);
dmat_elemprod(n, d3inv, tmp31, tmp31);
dmat_waxpby(n, -1, tmp31, 1, dw, tmp31);
dmat_yAx(matX1, du, tm1);
dmat_potrs(BB, tm1);
dmat_yATx(matX1, tm1, tmp32);
dmat_elemprod(n, d3inv, tmp32, tmp32);
dmat_waxpby(n, -1, tmp32, 1, du, tmp32);
dv[0] = (-gv[0] + dmat_dot(n,bDA,tmp32)) / (bDb - dmat_dot(n,bDA,tmp31));
/* dw = ... */
dmat_waxpby(n, -dv[0], tmp31, -1, tmp32, dw);
/* du = -(gu+d2.*dw)./d1; */
for (i = 0; i < n; i++)
du[i] = -(gu[i] + d2[i] * dw[i]) / d1[i];
}
/** \brief Compute search direction using cholesky method (m > n).
*
*/
void compute_searchdir_chol_thin(problem_data_t *pdat, variables_t *vars,
double t, dmatrix *B, dmatrix *BB,
double *tm1, double *bDA, double *d3)
{
int i, m, n;
double bDb, bDbinv;
dmatrix *matX1, *matX2;
double lambda, tinv;
double *g, *h, *z, *expz, *expmz, *ac, *ar, *b, *d1, *d2, *Aw;
double *x, *v, *w, *u, *dx, *dv, *dw, *du, *gv, *gw, *gu, *gx;
get_problem_data(pdat, &matX1, &matX2, &ac, &ar, &b, &lambda);
get_variables(vars, &x, &v, &w, &u, &dx, &dv, &dw, &du, &gx, &gv,
&gw, &gu, &g, &h, &z, &expz, &expmz, &d1, &d2, &Aw);
m = matX1->m;
n = matX1->n;
tinv = 1.0 / t;
/* bDb, Db */
bDb = 0.0;
for (i = 0; i < m; i++)
{
tm1[i] = h[i] * b[i]; /* tm1 = Db */
bDb += b[i] * tm1[i];
}
bDbinv = 1.0 / bDb;
/* bDA */
dmat_yATx(matX1, tm1, bDA);
dmat_copy(matX1, B); /* B = A */
dmat_ysqrtx(m, h, tm1); /* tm1 = D^{1/2} */
/* B = D^{1/2}*B */
dmat_diagscale(B, tm1, FALSE, NULL, FALSE);
/* BB = A^T*D*A */
dmat_B_ATA(B, BB); /* BB = B^T*B */
for (i = 0; i < n; i++)
{
double q1, q2, q3, ui, wi, gr2;
ui = u[i];
wi = w[i];
q1 = 1.0 / (ui + wi);
q2 = 1.0 / (ui - wi);
q3 = ui * ui + wi * wi;
gw[i] -= (q1 - q2) * tinv; /* A'*g - (q1-q2) */
gu[i] = lambda - (q1 + q2) * tinv; /* lambda - (q1+q2) */
d1[i] = (q1 * q1 + q2 * q2) * tinv;
d2[i] = (q1 * q1 - q2 * q2) * tinv;
d3[i] = 2 / q3 * tinv;
/* dw = (bDA'*gv-bDb*gr2); */
gr2 = gw[i] + 2 * gu[i] * ui * wi / q3;
dw[i] = bDA[i] * gv[0] * bDbinv - gr2;
}
/* dw = (bDb*S-bDA'*bDA)\(bDA'*gv-bDb*gr2);
= (S-1/bDb)*bDA'*bDA)\(bDA'*(gv/bDb)-gr2); */
dmat_diagadd(BB, d3);
dmat_A_axxTpA(-bDbinv, bDA, BB);
dmat_posv(BB, dw);
/* dv = (-bDA*dw-gv)/bDb; */
dv[0] = -(dmat_dot(n, bDA, dw) + gv[0]) / bDb;
/* du = -(gu+d2.*dw)./d1; */
for (i = 0; i < n; i++)
du[i] = -(gu[i] + d2[i] * dw[i]) / d1[i];
}
/** \brief Compute search direction using pcg method.
*
*/
void compute_searchdir_pcg(problem_data_t * pdat, variables_t * vars,
double t, double s, double gap, pcg_status_t * pcgstat,
adata_t * adata, mdata_t * mdata, double *precond,
double *tmp_m1, double *A2h, double *tmp_x1)
{
int i, m, n, nz;
double *p0, *p1, *p2, *p3;
double normg, pcgtol, pcgmaxi, multfact;
dmatrix *matX1, *matX2;
double lambda, tinv;
double *g, *h, *z, *expz, *expmz, *ac, *ar, *b, *d1, *d2, *Aw;
double *x, *v, *w, *u, *dx, *dv, *dw, *du, *gv, *gw, *gu, *gx;
static double pcgtol_factor = 1.0;
get_problem_data(pdat, &matX1, &matX2, &ac, &ar, &b, &lambda);
get_variables(vars, &x, &v, &w, &u, &dx, &dv, &dw, &du, &gx, &gv,
&gw, &gu, &g, &h, &z, &expz, &expmz, &d1, &d2, &Aw);
m = matX1->m;
n = matX1->n;
nz = matX1->nz;
tinv = 1.0 / t;
p0 = &precond[0];
p1 = &precond[1];
p2 = &precond[1+n];
p3 = &precond[1+n+n];
/* dmat_vset(n+n+1, 0, dx); */
dmat_yATx(matX2, h, A2h); /* A2h = A2'*h */
multfact = 0.0;
if (ac != NULL)
{
/* h.*ac */
dmat_elemprod(m, h, ac, tmp_m1);
dmat_vset(n, 0, tmp_x1);
dmat_yAmpqTx(matX1, NULL, NULL, tmp_m1, tmp_x1);
dmat_elemprod(n, ar, tmp_x1, tmp_x1);
for (i = 0; i < m; i++)
{
multfact += h[i] * ac[i] * ac[i];
}
}
p0[0] = 0;
for (i = 0; i < m; i++)
{
p0[0] += b[i] * b[i] * h[i];
}
/* complete forming gradient and d1, d2, precond */
for (i = 0; i < n; i++)
{
double q1, q2, d3, div;
q1 = 1.0 / (u[i] + w[i]);
q2 = 1.0 / (u[i] - w[i]);
gw[i] -= (q1 - q2) * tinv; /* A'*g - (q1-q2) */
gu[i] = lambda - (q1 + q2) * tinv; /* lambda - (q1+q2) */
d1[i] = (q1 * q1 + q2 * q2) * tinv;
d2[i] = (q1 * q1 - q2 * q2) * tinv;
if (ac != NULL)
{
d3 = A2h[i] + d1[i] + multfact*ar[i]*ar[i] - 2*tmp_x1[i];
}
else
{
d3 = A2h[i] + d1[i];
}
div = 1 / (d3 * d1[i] - d2[i] * d2[i]);
p1[i] = d1[i] * div;
p2[i] = d2[i] * div;
p3[i] = d3 * div;
}
normg = dmat_norm2(n+n+1, gx);
pcgtol = min(1e-1, 0.3*gap/min(1.0,normg));
/*
pcgtol = min(1e-1, 0.3*gap/min(1.0,sqrt(normg)));
*/
pcgmaxi = MAX_PCG_ITER;
if (s < 1e-5)
{
pcgtol_factor *= 0.5;
}
else
{
pcgtol_factor = 1.0;
}
pcgtol = pcgtol*pcgtol_factor;
dmat_waxpby(n+n+1, -1, gx, 0, NULL, tmp_x1);
pcg(dx, pcgstat, afun, adata, mfun, mdata, tmp_x1, pcgtol, pcgmaxi, n+n+1);
}
