bool CGPenaltyLSAcceptor::ArmijoHolds(Number alpha_primal_test) { DBG_START_METH("CGPenaltyLSAcceptor::ArmijoHolds", dbg_verbosity); bool accept = false; Number trial_penalty_function = CGPenCq().trial_penalty_function(); DBG_ASSERT(IsFiniteNumber(trial_penalty_function)); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, "Checking acceptability for trial step size alpha_primal_test=%13.6e:\n", alpha_primal_test); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " New values of penalty function = %23.16e (reference %23.16e):\n", trial_penalty_function, reference_penalty_function_); if (Jnlst().ProduceOutput(J_DETAILED, J_LINE_SEARCH)) { Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, "curr_barr = %23.16e curr_inf = %23.16e\n", IpCq().curr_barrier_obj(), IpCq().curr_constraint_violation()); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, "trial_barr = %23.16e trial_inf = %23.16e\n", IpCq().trial_barrier_obj(), IpCq().trial_constraint_violation()); } // Now check the Armijo condition accept = Compare_le(trial_penalty_function-reference_penalty_function_, eta_penalty_*alpha_primal_test*reference_direct_deriv_penalty_function_, reference_penalty_function_); return accept; }
Number CGPenaltyCq::trial_penalty_function() { DBG_START_METH("CGPenaltyCq::trial_penalty_function()", dbg_verbosity); Number result; SmartPtr<const Vector> x = ip_data_->trial()->x(); SmartPtr<const Vector> s = ip_data_->trial()->s(); std::vector<const TaggedObject*> tdeps(2); tdeps[0] = GetRawPtr(x); tdeps[1] = GetRawPtr(s); Number mu = ip_data_->curr_mu(); Number penalty = CGPenData().curr_penalty(); std::vector<Number> sdeps(2); sdeps[0] = mu; sdeps[1] = penalty; if (!trial_penalty_function_cache_.GetCachedResult(result, tdeps, sdeps)) { if (!curr_penalty_function_cache_.GetCachedResult(result, tdeps, sdeps)) { result = ip_cq_->trial_barrier_obj(); result += penalty*ip_cq_->trial_primal_infeasibility(NORM_2); } trial_penalty_function_cache_.AddCachedResult(result, tdeps, sdeps); } DBG_ASSERT(IsFiniteNumber(result)); return result; }
double DoubleToPrice(double p) { if (IsNumber(p) == false || IsFiniteNumber(p) ==false || p<0) { p = 0; } return p; }
bool DenseSymMatrix::HasValidNumbersImpl() const { DBG_ASSERT(initialized_); Number sum = 0.; const Index dim = Dim(); for (Index j=0; j<dim; j++) { sum += values_[j + j*dim]; for (Index i=j+1; i<dim; i++) { sum += values_[i + j*dim]; } } return IsFiniteNumber(sum); }
void Curve<Real>::SubdivideByLengthTime (int numPoints, std::vector<Real> & times) { assert(numPoints >= 2); times.resize(numPoints); double len = GetTotalLength(); // degenerate curve check if( !IsFiniteNumber(len) ){ for (int i = 0; i < numPoints; ++i) times[i] = double(i) / (numPoints - 1); return; } Real delta = len / (numPoints - 1); for (int i = 0; i < numPoints; ++i) { Real length = delta * i; times[i] = GetTime(length, TIME_ITERATIONS, CURVE_TOLERANCE); } }
bool Mc19TSymScalingMethod::ComputeSymTScalingFactors(Index n, Index nnz, const ipfint* airn, const ipfint* ajcn, const double* a, double* scaling_factors) { DBG_START_METH("Mc19TSymScalingMethod::ComputeSymTScalingFactors", dbg_verbosity); if (DBG_VERBOSITY()>=2) { for (Index i=0; i<nnz; i++) { DBG_PRINT((2, "%5d A[%5d,%5d] = %23.15e\n", i, airn[i], ajcn[i], a[i])); } } // First copy the symmetric matrix into an unsymmetric (MA28) // format matrix ipfint* AIRN2 = new ipfint[2*nnz]; ipfint* AJCN2 = new ipfint[2*nnz]; double* A2 = new double[2*nnz]; ipfint nnz2=0; for (Index i=0; i<nnz; i++) { if (airn[i]==ajcn[i]) { AIRN2[nnz2] = airn[i]; AJCN2[nnz2] = ajcn[i]; /* // ToDo decide if there should be a cut-off for small values in A // probably based on maximal element in A // DELETEME if (fabs(a[i])<1e-10) { A2[nnz2] = 0.; } else { A2[nnz2] = a[i]; } */ A2[nnz2] = a[i]; nnz2++; } else { AIRN2[nnz2] = airn[i]; AJCN2[nnz2] = ajcn[i]; /* // DELETEME if (fabs(a[i])<1e-10) { A2[nnz2] = 0.; } else { A2[nnz2] = a[i]; } */ A2[nnz2] = a[i]; nnz2++; AIRN2[nnz2] = ajcn[i]; AJCN2[nnz2] = airn[i]; /* // DELETEME if (fabs(a[i])<1e-10) { A2[nnz2] = 0.; } else { A2[nnz2] = a[i]; } */ A2[nnz2] = a[i]; nnz2++; } } if (DBG_VERBOSITY()>=3) { for (Index i=0; i<nnz2; i++) { DBG_PRINT((3, "A2[%5d] = %23.15e\n", i, A2[i])); } } // Call MC19 to get the scaling factors (for the matrix in the // general format) float* R = new float[n]; float* C = new float[n]; float* W = new float[5*n]; F77_FUNC(mc19ad,MC19AD)(&n, &nnz2, A2, AIRN2, AJCN2, R, C, W); delete[] W; if (DBG_VERBOSITY()>=3) { for (Index i=0; i<n; i++) { DBG_PRINT((3, "R[%5d] = %23.15e C[%5d] = %23.15e\n", i, R[i], i, C[i])); } } // Get the symmetric scaling factors as mean of the general ones // If some of the entries in A2 are too large, the scaling factors // are NaN. Here, we check for this and return no scaling factors // if that is the case Number sum=0.; for (Index i=0; i<n; i++) { scaling_factors[i] = exp((double)((R[i]+C[i])/2.)); sum += scaling_factors[i]; } if (!IsFiniteNumber(sum)) { Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "Scaling factors are invalid - setting them all to 1.\n"); for (Index i=0; i<n; i++) { scaling_factors[i] = 1.; } } if (DBG_VERBOSITY()>=2) { for (Index i=0; i<n; i++) { DBG_PRINT((2, "scaling_factors[%5d] = %23.15e\n", i, scaling_factors[i])); } } // Clean up delete[] C; delete[] R; delete[] A2; delete[] AIRN2; delete[] AJCN2; return true; }
bool SymTMatrix::HasValidNumbersImpl() const { DBG_ASSERT(initialized_); Number sum = IpBlasDasum(Nonzeros(), values_, 1); return IsFiniteNumber(sum); }
bool DenseGenMatrix::HasValidNumbersImpl() const { DBG_ASSERT(initialized_); Number sum = IpBlasDasum(NRows()*NCols(), values_, 1); return IsFiniteNumber(sum); }
bool InexactLSAcceptor::CheckAcceptabilityOfTrialPoint( Number alpha_primal_test ) { DBG_START_METH("InexactLSAcceptor::CheckAcceptabilityOfTrialPoint", dbg_verbosity); // If we are in termiation test 2 iteration, we skip the line search if( in_tt2_ ) { return true; } // First compute the barrier function and constraint violation at the // current iterate and the trial point Number trial_theta = IpCq().trial_constraint_violation(); Number trial_barr = IpCq().trial_barrier_obj(); DBG_ASSERT(IsFiniteNumber(trial_barr)); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, "Checking acceptability for trial step size alpha_primal_test=%13.6e:\n", alpha_primal_test); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " New values of barrier function = %23.16e (reference %23.16e):\n", trial_barr, reference_barr_); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " New values of constraint violation = %23.16e (reference %23.16e):\n", trial_theta, reference_theta_); Number pred = CalcPred(alpha_primal_test); resto_pred_ = pred; DBG_PRINT((1, "nu_ = %e reference_barr_ + nu_*(reference_theta_)=%e trial_barr + nu_*trial_theta=%e\n", nu_, reference_barr_ + nu_ * (reference_theta_), trial_barr + nu_ * trial_theta)); Number ared = reference_barr_ + nu_ * (reference_theta_) - (trial_barr + nu_ * trial_theta); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " Checking Armijo Condition with pred = %23.16e and ared = %23.16e\n", pred, ared); bool accept = Compare_le(eta_ * pred, ared, reference_barr_ + nu_ * (reference_theta_)); bool accept_low = false; if( flexible_penalty_function_ ) { DBG_PRINT((1, "nu_low = %e reference_barr_ + nu_low*(reference_theta_)=%e trial_barr + nu_low*trial_theta=%e\n", nu_low_, reference_barr_ + nu_low_ * (reference_theta_), trial_barr + nu_low_ * trial_theta)); ared = reference_barr_ + nu_low_ * (reference_theta_) - (trial_barr + nu_low_ * trial_theta); Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " Checking nu_low Armijo Condition with pred = %23.16e and ared = %23.16e\n", pred, ared); accept_low = Compare_le(eta_ * pred, ared, reference_barr_ + nu_low_ * (reference_theta_)); } accepted_by_low_only_ = false; if( accept ) { Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " Success...\n"); } else if( flexible_penalty_function_ && accept_low ) { Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " Success with nu_low...\n"); accept = true; accepted_by_low_only_ = true; } else { Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, " Failed...\n"); } if( accept ) { // HERE WE RESET THE SLACKS. MAYBE THIS SHOULD BE BEFORE THE // FUNCTION EVALUATIONS? ResetSlacks(); if( flexible_penalty_function_ ) { // update the lower penalty parameter if necessary if( !accept_low ) { Number nu_real = -(trial_barr - reference_barr_) / (trial_theta - reference_theta_); nu_low_ = Min(nu_, nu_low_ + Max(nu_low_fact_ * (nu_real - nu_low_), nu_inc_)); Jnlst().Printf(J_MOREDETAILED, J_LINE_SEARCH, "Updating nu_low to %8.2e with nu_real = %8.2e\n", nu_low_, nu_real); } } } return accept; }
bool Vector::HasValidNumbersImpl() const { Number sum = Asum(); return IsFiniteNumber(sum); }