/* multilarge_nlinear/common.c
*
* Copyright (C) 2015, 2016 Patrick Alken
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
static double scaled_enorm (const gsl_vector * d, const gsl_vector * f);
static void scaled_addition (const double alpha, const gsl_vector * x,
const double beta, const gsl_vector * y,
gsl_vector * z);
static double quadratic_preduction(const gsl_multilarge_nlinear_trust_state * trust_state,
const gsl_vector * dx, gsl_vector * work);
/* compute || diag(d) f || */
static double
scaled_enorm (const gsl_vector * d, const gsl_vector * f)
{
double e2 = 0;
size_t i, n = f->size;
for (i = 0; i < n; i++)
{
double fi = gsl_vector_get (f, i);
double di = gsl_vector_get (d, i);
double u = di * fi;
e2 += u * u;
}
return sqrt (e2);
}
/* compute z = alpha*x + beta*y */
static void
scaled_addition (const double alpha, const gsl_vector * x,
const double beta, const gsl_vector * y, gsl_vector * z)
{
const size_t N = z->size;
size_t i;
for (i = 0; i < N; i++)
{
double xi = gsl_vector_get (x, i);
double yi = gsl_vector_get (y, i);
gsl_vector_set (z, i, alpha * xi + beta * yi);
}
}
/*
quadratic_preduction()
Calculate predicted reduction based on standard
quadratic model:
m_k(dx) = Phi(x_k) + dx' g + 1/2 dx' B_k dx
predicted_reduction = m_k(0) - m_k(dx)
= -2 g^T dx / ||f||^2 - ( ||J*dx|| / ||f|| )^2
= -2 fhat . beta - ||beta||^2
where: beta = J*dx / ||f||
Inputs: trust_state - trust state
dx - proposed step, size p
work - workspace, size n
Return: predicted reduction
*/
static double
quadratic_preduction(const gsl_multilarge_nlinear_trust_state * trust_state,
const gsl_vector * dx, gsl_vector * work)
{
const gsl_vector * f = trust_state->f;
const gsl_multilarge_nlinear_parameters * params = trust_state->params;
const double normf = gsl_blas_dnrm2(f);
double gTdx; /* g^T dx */
gsl_multilarge_nlinear_fdf * fdf = trust_state->fdf;
double pred_reduction, u;
/* compute g^T dx */
gsl_blas_ddot(trust_state->g, dx, &gTdx);
/* first term: -2 g^T dx / ||f||^2 */
pred_reduction = -2.0 * gTdx / (normf * normf);
if (params->solver == gsl_multilarge_nlinear_solver_cholesky)
{
const size_t p = fdf->p;
gsl_vector_view workp = gsl_vector_subvector(work, 0, p);
/* compute workp = J^T J dx */
gsl_blas_dsymv(CblasLower, 1.0, trust_state->JTJ, dx, 0.0, &workp.vector);
/* compute u = dx^T J^T J dx = ||J dx||^2 */
gsl_blas_ddot(&workp.vector, dx, &u);
pred_reduction -= u / (normf * normf);
}
else
{
int status;
const gsl_vector * x = trust_state->x;
const gsl_vector * swts = trust_state->sqrt_wts;
/* compute work = J*dx */
status = gsl_multilarge_nlinear_eval_df(CblasNoTrans, x, f, dx,
swts, params->h_df, params->fdtype,
fdf, work, NULL, NULL);
if (status)
{
GSL_ERROR_VAL("error computing preduction", status, 0.0);
}
/* compute u = ||J*dx|| / ||f|| */
u = gsl_blas_dnrm2(work) / normf;
pred_reduction -= u * u;
}
return pred_reduction;
}