int fhv_factorize(FHV *fhv, int m, int (*col)(void *info, int j,
int ind[], double val[]), void *info)
{ int ret;
if (m < 1)
xfault("fhv_factorize: m = %d; invalid parameter\n", m);
if (m > M_MAX)
xfault("fhv_factorize: m = %d; matrix too big\n", m);
fhv->m = m;
/* invalidate the factorization */
fhv->valid = 0;
/* allocate/reallocate arrays, if necessary */
if (fhv->hh_ind == NULL)
fhv->hh_ind = xcalloc(1+fhv->hh_max, sizeof(int));
if (fhv->hh_ptr == NULL)
fhv->hh_ptr = xcalloc(1+fhv->hh_max, sizeof(int));
if (fhv->hh_len == NULL)
fhv->hh_len = xcalloc(1+fhv->hh_max, sizeof(int));
if (fhv->m_max < m)
{ if (fhv->p0_row != NULL) xfree(fhv->p0_row);
if (fhv->p0_col != NULL) xfree(fhv->p0_col);
if (fhv->cc_ind != NULL) xfree(fhv->cc_ind);
if (fhv->cc_val != NULL) xfree(fhv->cc_val);
fhv->m_max = m + 100;
fhv->p0_row = xcalloc(1+fhv->m_max, sizeof(int));
fhv->p0_col = xcalloc(1+fhv->m_max, sizeof(int));
fhv->cc_ind = xcalloc(1+fhv->m_max, sizeof(int));
fhv->cc_val = xcalloc(1+fhv->m_max, sizeof(double));
}
/* try to factorize the basis matrix */
switch (luf_factorize(fhv->luf, m, col, info))
{ case 0:
break;
case LUF_ESING:
ret = FHV_ESING;
goto done;
case LUF_ECOND:
ret = FHV_ECOND;
goto done;
default:
xassert(fhv != fhv);
}
/* the basis matrix has been successfully factorized */
fhv->valid = 1;
/* H := I */
fhv->hh_nfs = 0;
/* P0 := P */
memcpy(&fhv->p0_row[1], &fhv->luf->pp_row[1], sizeof(int) * m);
memcpy(&fhv->p0_col[1], &fhv->luf->pp_col[1], sizeof(int) * m);
/* currently H has no factors */
fhv->nnz_h = 0;
ret = 0;
done: /* return to the calling program */
return ret;
}
int lpf_factorize(LPF *lpf, int m, const int bh[], int (*col)
(void *info, int j, int ind[], double val[]), void *info)
{ int k, ret;
#if GLPLPF_DEBUG
int i, j, len, *ind;
double *B, *val;
#endif
xassert(bh == bh);
if (m < 1)
xfault("lpf_factorize: m = %d; invalid parameter\n", m);
if (m > M_MAX)
xfault("lpf_factorize: m = %d; matrix too big\n", m);
lpf->m0 = lpf->m = m;
/* invalidate the factorization */
lpf->valid = 0;
/* allocate/reallocate arrays, if necessary */
if (lpf->R_ptr == NULL)
lpf->R_ptr = xcalloc(1+lpf->n_max, sizeof(int));
if (lpf->R_len == NULL)
lpf->R_len = xcalloc(1+lpf->n_max, sizeof(int));
if (lpf->S_ptr == NULL)
lpf->S_ptr = xcalloc(1+lpf->n_max, sizeof(int));
if (lpf->S_len == NULL)
lpf->S_len = xcalloc(1+lpf->n_max, sizeof(int));
if (lpf->scf == NULL)
lpf->scf = scf_create_it(lpf->n_max);
if (lpf->v_ind == NULL)
lpf->v_ind = xcalloc(1+lpf->v_size, sizeof(int));
if (lpf->v_val == NULL)
lpf->v_val = xcalloc(1+lpf->v_size, sizeof(double));
if (lpf->m0_max < m)
{ if (lpf->P_row != NULL) xfree(lpf->P_row);
if (lpf->P_col != NULL) xfree(lpf->P_col);
if (lpf->Q_row != NULL) xfree(lpf->Q_row);
if (lpf->Q_col != NULL) xfree(lpf->Q_col);
if (lpf->work1 != NULL) xfree(lpf->work1);
if (lpf->work2 != NULL) xfree(lpf->work2);
lpf->m0_max = m + 100;
lpf->P_row = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int));
lpf->P_col = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int));
lpf->Q_row = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int));
lpf->Q_col = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int));
lpf->work1 = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(double));
lpf->work2 = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(double));
}
/* try to factorize the basis matrix */
#if 0 /* 06/VI-2013 */
switch (luf_factorize(lpf->luf, m, col, info))
{ case 0:
break;
case LUF_ESING:
ret = LPF_ESING;
goto done;
case LUF_ECOND:
ret = LPF_ECOND;
goto done;
default:
xassert(lpf != lpf);
}
#else
if (lufint_factorize(lpf->lufint, m, col, info) != 0)
{ ret = LPF_ESING;
goto done;
}
#endif
/* the basis matrix has been successfully factorized */
lpf->valid = 1;
#if GLPLPF_DEBUG
/* store the basis matrix for debugging */
if (lpf->B != NULL) xfree(lpf->B);
xassert(m <= 32767);
lpf->B = B = xcalloc(1+m*m, sizeof(double));
ind = xcalloc(1+m, sizeof(int));
val = xcalloc(1+m, sizeof(double));
for (k = 1; k <= m * m; k++)
B[k] = 0.0;
for (j = 1; j <= m; j++)
{ len = col(info, j, ind, val);
xassert(0 <= len && len <= m);
for (k = 1; k <= len; k++)
{ i = ind[k];
xassert(1 <= i && i <= m);
xassert(B[(i - 1) * m + j] == 0.0);
xassert(val[k] != 0.0);
B[(i - 1) * m + j] = val[k];
}
}
xfree(ind);
xfree(val);
#endif
/* B = B0, so there are no additional rows/columns */
lpf->n = 0;
/* reset the Schur complement factorization */
scf_reset_it(lpf->scf);
/* P := Q := I */
for (k = 1; k <= m; k++)
{ lpf->P_row[k] = lpf->P_col[k] = k;
lpf->Q_row[k] = lpf->Q_col[k] = k;
}
/* make all SVA locations free */
lpf->v_ptr = 1;
ret = 0;
done: /* return to the calling program */
return ret;
}
