template <class T> double GaussNewton<T>::Fit(DArray &c) {
double sum = 0.;
DArray res(x_.size(), 0.);
DMatrix jac(x_.size(), t_.GetC()), dc(1, t_.GetC());
do {
//break;
ComputeResiduals(res);
ComputeJacobian(jac);
ComputeDeltas(jac, res, dc);
cerr << "Deltas: " << endl;
PrintMatrix(dc);
} while(RoundToZero(UpdateParameters(dc, c)) != 0.);
ComputeResiduals(res);
for(int i = 0; i < res.size(); ++i) {
sum += res[i] * res[i];
}
return sqrt(sum);
}
void CrossHypotheses::InitializeDerivedQualities() {
InitializeResponsibility(); // depends on hypotheses
// in theory don't need to compute any but test flows
SetModPredictions(); // make sure that mod-predictions=predictions
ComputeResiduals(); // predicted and measured
InitializeSigma(); // depends on predicted
my_t.SetV(heavy_tailed);
ComputeBasicLikelihoods(); // depends on residuals and sigma
// compute log-likelihoods
ComputeLogLikelihoods(); // depends on test flow(s)
}
bool PDFullSpaceSolver::Solve(Number alpha,
Number beta,
const IteratesVector& rhs,
IteratesVector& res,
bool allow_inexact,
bool improve_solution /* = false */)
{
DBG_START_METH("PDFullSpaceSolver::Solve",dbg_verbosity);
DBG_ASSERT(!allow_inexact || !improve_solution);
DBG_ASSERT(!improve_solution || beta==0.);
// Timing of PDSystem solver starts here
IpData().TimingStats().PDSystemSolverTotal().Start();
DBG_PRINT_VECTOR(2, "rhs_x", *rhs.x());
DBG_PRINT_VECTOR(2, "rhs_s", *rhs.s());
DBG_PRINT_VECTOR(2, "rhs_c", *rhs.y_c());
DBG_PRINT_VECTOR(2, "rhs_d", *rhs.y_d());
DBG_PRINT_VECTOR(2, "rhs_zL", *rhs.z_L());
DBG_PRINT_VECTOR(2, "rhs_zU", *rhs.z_U());
DBG_PRINT_VECTOR(2, "rhs_vL", *rhs.v_L());
DBG_PRINT_VECTOR(2, "rhs_vU", *rhs.v_U());
DBG_PRINT_VECTOR(2, "res_x in", *res.x());
DBG_PRINT_VECTOR(2, "res_s in", *res.s());
DBG_PRINT_VECTOR(2, "res_c in", *res.y_c());
DBG_PRINT_VECTOR(2, "res_d in", *res.y_d());
DBG_PRINT_VECTOR(2, "res_zL in", *res.z_L());
DBG_PRINT_VECTOR(2, "res_zU in", *res.z_U());
DBG_PRINT_VECTOR(2, "res_vL in", *res.v_L());
DBG_PRINT_VECTOR(2, "res_vU in", *res.v_U());
// if beta is nonzero, keep a copy of the incoming values in res_ */
SmartPtr<IteratesVector> copy_res;
if (beta != 0.) {
copy_res = res.MakeNewIteratesVectorCopy();
}
// Receive data about matrix
SmartPtr<const Vector> x = IpData().curr()->x();
SmartPtr<const Vector> s = IpData().curr()->s();
SmartPtr<const SymMatrix> W = IpData().W();
SmartPtr<const Matrix> J_c = IpCq().curr_jac_c();
SmartPtr<const Matrix> J_d = IpCq().curr_jac_d();
SmartPtr<const Matrix> Px_L = IpNLP().Px_L();
SmartPtr<const Matrix> Px_U = IpNLP().Px_U();
SmartPtr<const Matrix> Pd_L = IpNLP().Pd_L();
SmartPtr<const Matrix> Pd_U = IpNLP().Pd_U();
SmartPtr<const Vector> z_L = IpData().curr()->z_L();
SmartPtr<const Vector> z_U = IpData().curr()->z_U();
SmartPtr<const Vector> v_L = IpData().curr()->v_L();
SmartPtr<const Vector> v_U = IpData().curr()->v_U();
SmartPtr<const Vector> slack_x_L = IpCq().curr_slack_x_L();
SmartPtr<const Vector> slack_x_U = IpCq().curr_slack_x_U();
SmartPtr<const Vector> slack_s_L = IpCq().curr_slack_s_L();
SmartPtr<const Vector> slack_s_U = IpCq().curr_slack_s_U();
SmartPtr<const Vector> sigma_x = IpCq().curr_sigma_x();
SmartPtr<const Vector> sigma_s = IpCq().curr_sigma_s();
DBG_PRINT_VECTOR(2, "Sigma_x", *sigma_x);
DBG_PRINT_VECTOR(2, "Sigma_s", *sigma_s);
bool done = false;
// The following flag is set to true, if we asked the linear
// solver to improve the quality of the solution in
// the next solve
bool resolve_with_better_quality = false;
// the following flag is set to true, if iterative refinement
// failed and we want to try if a modified system is able to
// remedy that problem by pretending the matrix is singular
bool pretend_singular = false;
bool pretend_singular_last_time = false;
// Beginning of loop for solving the system (including all
// modifications for the linear system to ensure good solution
// quality)
while (!done) {
// if improve_solution is true, we are given already a solution
// from the calling function, so we can skip the first solve
bool solve_retval = true;
if (!improve_solution) {
solve_retval =
SolveOnce(resolve_with_better_quality, pretend_singular,
*W, *J_c, *J_d, *Px_L, *Px_U, *Pd_L, *Pd_U, *z_L, *z_U,
*v_L, *v_U, *slack_x_L, *slack_x_U, *slack_s_L, *slack_s_U,
*sigma_x, *sigma_s, 1., 0., rhs, res);
resolve_with_better_quality = false;
pretend_singular = false;
}
improve_solution = false;
if (!solve_retval) {
// If system seems not to be solvable, we return with false
// and let the calling routine deal with it.
IpData().TimingStats().PDSystemSolverTotal().End();
return false;
}
if (allow_inexact) {
// no safety checks required
if (Jnlst().ProduceOutput(J_MOREDETAILED, J_LINEAR_ALGEBRA)) {
SmartPtr<IteratesVector> resid = res.MakeNewIteratesVector(true);
ComputeResiduals(*W, *J_c, *J_d, *Px_L, *Px_U, *Pd_L, *Pd_U,
*z_L, *z_U, *v_L, *v_U, *slack_x_L, *slack_x_U,
*slack_s_L, *slack_s_U, *sigma_x, *sigma_s,
alpha, beta, rhs, res, *resid);
}
break;
}
// Get space for the residual
SmartPtr<IteratesVector> resid = res.MakeNewIteratesVector(true);
// ToDo don't to that after max refinement?
ComputeResiduals(*W, *J_c, *J_d, *Px_L, *Px_U, *Pd_L, *Pd_U,
*z_L, *z_U, *v_L, *v_U, *slack_x_L, *slack_x_U,
*slack_s_L, *slack_s_U, *sigma_x, *sigma_s,
alpha, beta, rhs, res, *resid);
Number residual_ratio =
ComputeResidualRatio(rhs, res, *resid);
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"residual_ratio = %e\n", residual_ratio);
Number residual_ratio_old = residual_ratio;
// Beginning of loop for iterative refinement
Index num_iter_ref = 0;
bool quit_refinement = false;
while (!allow_inexact && !quit_refinement &&
(num_iter_ref < min_refinement_steps_ ||
residual_ratio > residual_ratio_max_) ) {
// To the next back solve
solve_retval =
SolveOnce(resolve_with_better_quality, false,
*W, *J_c, *J_d, *Px_L, *Px_U, *Pd_L, *Pd_U, *z_L, *z_U,
*v_L, *v_U, *slack_x_L, *slack_x_U, *slack_s_L, *slack_s_U,
*sigma_x, *sigma_s, -1., 1., *resid, res);
ASSERT_EXCEPTION(solve_retval, INTERNAL_ABORT,
"SolveOnce returns false during iterative refinement.");
ComputeResiduals(*W, *J_c, *J_d, *Px_L, *Px_U, *Pd_L, *Pd_U,
*z_L, *z_U, *v_L, *v_U, *slack_x_L, *slack_x_U,
*slack_s_L, *slack_s_U, *sigma_x, *sigma_s,
alpha, beta, rhs, res, *resid);
residual_ratio =
ComputeResidualRatio(rhs, res, *resid);
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"residual_ratio = %e\n", residual_ratio);
num_iter_ref++;
// Check if we have to give up on iterative refinement
if (residual_ratio > residual_ratio_max_ &&
num_iter_ref>min_refinement_steps_ &&
(num_iter_ref>max_refinement_steps_ ||
residual_ratio>residual_improvement_factor_*residual_ratio_old)) {
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"Iterative refinement failed with residual_ratio = %e\n", residual_ratio);
quit_refinement = true;
// Pretend singularity only once - if it didn't help, we
// have to live with what we got so far
resolve_with_better_quality = false;
DBG_PRINT((1, "pretend_singular = %d\n", pretend_singular));
if (!pretend_singular_last_time) {
// First try if we can ask the augmented system solver to
// improve the quality of the solution (only if that hasn't
// been done before for this linear system)
if (!augsys_improved_) {
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"Asking augmented system solver to improve quality of its solutions.\n");
augsys_improved_ = augSysSolver_->IncreaseQuality();
if (augsys_improved_) {
IpData().Append_info_string("q");
resolve_with_better_quality = true;
}
else {
// solver said it cannot improve quality, so let
// possibly conclude that the current modification is
// singular
pretend_singular = true;
}
}
else {
// we had already asked the solver before to improve the
// quality of the solution, so let's now pretend that the
// modification is possibly singular
pretend_singular = true;
}
pretend_singular_last_time = pretend_singular;
if (pretend_singular) {
// let's only conclude that the current linear system
// including modifications is singular, if the residual is
// quite bad
if (residual_ratio < residual_ratio_singular_) {
pretend_singular = false;
IpData().Append_info_string("S");
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"Just accept current solution.\n");
}
else {
IpData().Append_info_string("s");
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"Pretend that the current system (including modifications) is singular.\n");
}
}
}
else {
pretend_singular = false;
DBG_PRINT((1,"Resetting pretend_singular to false.\n"));
}
}
residual_ratio_old = residual_ratio;
} // End of loop for iterative refinement
done = !(resolve_with_better_quality) && !(pretend_singular);
} // End of loop for solving the linear system (incl. modifications)
// Finally let's assemble the res result vectors
if (alpha != 0.) {
res.Scal(alpha);
}
if (beta != 0.) {
res.Axpy(beta, *copy_res);
}
DBG_PRINT_VECTOR(2, "res_x", *res.x());
DBG_PRINT_VECTOR(2, "res_s", *res.s());
DBG_PRINT_VECTOR(2, "res_c", *res.y_c());
DBG_PRINT_VECTOR(2, "res_d", *res.y_d());
DBG_PRINT_VECTOR(2, "res_zL", *res.z_L());
DBG_PRINT_VECTOR(2, "res_zU", *res.z_U());
DBG_PRINT_VECTOR(2, "res_vL", *res.v_L());
DBG_PRINT_VECTOR(2, "res_vU", *res.v_U());
IpData().TimingStats().PDSystemSolverTotal().End();
return true;
}
void CrossHypotheses::ResetRelevantResiduals() {
ResetModPredictions();
ComputeResiduals();
}
