void CompoundVector::ElementWiseMinImpl(const Vector& x) { DBG_START_METH("CompoundVector::ElementWiseMinImpl", dbg_verbosity); DBG_ASSERT(vectors_valid_); const CompoundVector* comp_x = static_cast<const CompoundVector*>(&x); DBG_ASSERT(dynamic_cast<const CompoundVector*>(&x)); DBG_ASSERT(NComps() == comp_x->NComps()); for (Index i=0; i<NComps(); i++) { Comp(i)->ElementWiseMin(*comp_x->GetComp(i)); } }
bool DenseGenSchurDriver::SchurFactorize() { DBG_START_METH("DenseGenSchurDriver::SchurFactorize", dbg_verbosity); /* This function is the very same as the one in DenseGenSchurDriver */ bool retval; if (IsValid(S_)) { retval = S_->ComputeLUFactorInPlace(); return retval; } return true; }
Number CompoundVector::Nrm2Impl() const { DBG_START_METH("CompoundVector::Nrm2Impl", dbg_verbosity); DBG_ASSERT(vectors_valid_); Number sum=0.; for (Index i=0; i<NComps(); i++) { Number nrm2 = ConstComp(i)->Nrm2(); sum += nrm2*nrm2; } return sqrt(sum); }
bool CachedResults<T>::GetCachedResult1Dep(T& retResult, const TaggedObject* dependent1) { #ifdef IP_DEBUG_CACHE DBG_START_METH("CachedResults<T>::GetCachedResult1Dep", dbg_verbosity); #endif std::vector<const TaggedObject*> dependents(1); dependents[0] = dependent1; return GetCachedResult(retResult, dependents); }
SmartPtr<const Vector> StandardScalingBase::unapply_vector_scaling_x( const SmartPtr<const Vector>& v) { DBG_START_METH("NLPScalingObject::unapply_vector_scaling_x", dbg_verbosity); if (IsValid(dx_)) { return ConstPtr(unapply_vector_scaling_x_NonConst(v)); } else { return v; } }
SmartPtr<Vector> NLPScalingObject::unapply_grad_obj_scaling_NonConst( const SmartPtr<const Vector>& v) { DBG_START_METH("NLPScalingObject::unapply_grad_obj_scaling_NonConst", dbg_verbosity); SmartPtr<Vector> unscaled_v = apply_vector_scaling_x_NonConst(v); Number df = unapply_obj_scaling(1.); if (df != 1.) { unscaled_v->Scal(df); } return unscaled_v; }
inline void Subject::Notify(Observer::NotifyType notify_type) const { #ifdef IP_DEBUG_OBSERVER DBG_START_METH("Subject::Notify", dbg_verbosity); #endif std::vector<Observer*>::iterator iter; for (iter = observers_.begin(); iter != observers_.end(); iter++) { (*iter)->ProcessNotification(notify_type, this); } }
inline Subject::~Subject() { #ifdef IP_DEBUG_OBSERVER DBG_START_METH("Subject::~Subject", dbg_verbosity); #endif std::vector<Observer*>::iterator iter; for (iter = observers_.begin(); iter != observers_.end(); iter++) { (*iter)->ProcessNotification(Observer::NT_BeingDestroyed, this); } }
void DependentResult<T>::RecieveNotification(NotifyType notify_type, const Subject* subject) { #ifdef IP_DEBUG_CACHE DBG_START_METH("DependentResult<T>::RecieveNotification", dbg_verbosity); #endif if (notify_type == NT_Changed || notify_type==NT_BeingDestroyed) { stale_ = true; // technically, I could unregister the notifications here, but they // aren't really hurting anything } }
bool LowRankAugSystemSolver::AugmentedSystemRequiresChange( const SymMatrix* W, double W_factor, const Vector* D_x, double delta_x, const Vector* D_s, double delta_s, const Matrix& J_c, const Vector* D_c, double delta_c, const Matrix& J_d, const Vector* D_d, double delta_d ) { DBG_START_METH("LowRankAugSystemSolver::AugmentedSystemRequiresChange", dbg_verbosity); #if COIN_IPOPT_VERBOSITY > 0 bool Wtest = (W && W->GetTag() != w_tag_); bool iWtest = (!W && w_tag_ != 0); bool wfactor_test = (W_factor != w_factor_); bool D_xtest = (D_x && D_x->GetTag() != d_x_tag_); bool iD_xtest = (!D_x && d_x_tag_ != 0); bool delta_xtest = (delta_x != delta_x_); bool D_stest = (D_s && D_s->GetTag() != d_s_tag_); bool iD_stest = (!D_s && d_s_tag_ != 0); bool delta_stest = (delta_s != delta_s_); bool J_ctest = (J_c.GetTag() != j_c_tag_); bool D_ctest = (D_c && D_c->GetTag() != d_c_tag_); bool iD_ctest = (!D_c && d_c_tag_ != 0); bool delta_ctest = (delta_c != delta_c_); bool J_dtest = (J_d.GetTag() != j_d_tag_); bool D_dtest = (D_d && D_d->GetTag() != d_d_tag_); bool iD_dtest = (!D_d && d_d_tag_ != 0); bool delta_dtest = (delta_d != delta_d_); #endif DBG_PRINT((2, "Wtest = %d\n", Wtest)); DBG_PRINT((2, "iWtest = %d\n", iWtest)); DBG_PRINT((2, "wfactor_test = %d\n", wfactor_test)); DBG_PRINT((2, "D_xtest = %d\n", D_xtest)); DBG_PRINT((2, "iD_xtest = %d\n", iD_xtest)); DBG_PRINT((2, "delta_xtest = %d\n", delta_xtest)); DBG_PRINT((2, "D_stest = %d\n", D_stest)); DBG_PRINT((2, "iD_stest = %d\n", iD_stest)); DBG_PRINT((2, "delta_stest = %d\n", delta_stest)); DBG_PRINT((2, "J_ctest = %d\n", J_ctest)); DBG_PRINT((2, "D_ctest = %d\n", D_ctest)); DBG_PRINT((2, "iD_ctest = %d\n", iD_ctest)); DBG_PRINT((2, "delta_ctest = %d\n", delta_ctest)); DBG_PRINT((2, "J_dtest = %d\n", J_dtest)); DBG_PRINT((2, "D_dtest = %d\n", D_dtest)); DBG_PRINT((2, "iD_dtest = %d\n", iD_dtest)); DBG_PRINT((2, "delta_dtest = %d\n", delta_dtest)); if( (W && W->GetTag() != w_tag_) || (!W && w_tag_ != 0) || (W_factor != w_factor_) || (D_x && D_x->GetTag() != d_x_tag_) || (!D_x && d_x_tag_ != 0) || (delta_x != delta_x_) || (D_s && D_s->GetTag() != d_s_tag_) || (!D_s && d_s_tag_ != 0) || (delta_s != delta_s_) || (J_c.GetTag() != j_c_tag_) || (D_c && D_c->GetTag() != d_c_tag_) || (!D_c && d_c_tag_ != 0) || (delta_c != delta_c_) || (J_d.GetTag() != j_d_tag_) || (D_d && D_d->GetTag() != d_d_tag_) || (!D_d && d_d_tag_ != 0) || (delta_d != delta_d_) ) { return true; } return false; }
MumpsSolverInterface::~MumpsSolverInterface() { DBG_START_METH("MumpsSolverInterface::~MumpsSolverInterface()", dbg_verbosity); DMUMPS_STRUC_C* mumps_ = (DMUMPS_STRUC_C*)mumps_ptr_; mumps_->job = -2; //terminate mumps dmumps_c(mumps_); MPI_Finalize(); delete [] mumps_->a; delete mumps_; }
SmartPtr<const Vector> StandardScalingBase::unapply_vector_scaling_d( const SmartPtr<const Vector>& v) { DBG_START_METH("NLPScalingObject::unapply_vector_scaling_d", dbg_verbosity); if (IsValid(scaled_jac_d_space_) && IsValid(scaled_jac_d_space_->RowScaling())) { return ConstPtr(unapply_vector_scaling_d_NonConst(v)); } else { return v; } }
bool CGPenaltyLSAcceptor::RestoreBestPoint() { DBG_START_METH("CGPenaltyLSAcceptor::RestoreBestPoint", dbg_verbosity); if (!IsValid(best_iterate_)) { return false; } SmartPtr<IteratesVector> prev_iterate = best_iterate_->MakeNewContainer(); IpData().set_trial(prev_iterate); return true; }
IterativeWsmpSolverInterface::~IterativeWsmpSolverInterface() { DBG_START_METH("IterativeWsmpSolverInterface::~IterativeWsmpSolverInterface()", dbg_verbosity); // Clear WSMP's memory F77_FUNC_(wsmp_clear,WSMP_CLEAR)(); delete[] IPARM_; delete[] DPARM_; delete[] a_; }
Ma57TSolverInterface::~Ma57TSolverInterface() { DBG_START_METH("Ma57TSolverInterface::~Ma57TSolverInterface()", dbg_verbosity); delete [] a_; delete [] wd_fact_; delete [] wd_ifact_; delete [] wd_iwork_; delete [] wd_keep_; }
ESymSolverStatus IterativeWsmpSolverInterface::SymbolicFactorization( const Index* ia, const Index* ja) { DBG_START_METH("IterativeWsmpSolverInterface::SymbolicFactorization", dbg_verbosity); // This is postponed until the first factorization call, since // then the values in the matrix are known return SYMSOLVER_SUCCESS; }
SensAlgorithm::~SensAlgorithm() { DBG_START_METH("SensAlgorithm::~SensAlgorithm", dbg_verbosity); if (NULL != DirectionalD_X_) delete [] DirectionalD_X_ ; if (NULL != DirectionalD_L_) delete [] DirectionalD_L_ ; if (NULL != DirectionalD_Z_U_) delete [] DirectionalD_Z_U_ ; if (NULL != DirectionalD_Z_L_) delete [] DirectionalD_Z_L_ ; if (NULL != SensitivityM_X_) delete [] SensitivityM_X_ ; if (NULL != SensitivityM_L_) delete [] SensitivityM_L_ ; if (NULL != SensitivityM_Z_U_) delete [] SensitivityM_Z_U_ ; if (NULL != SensitivityM_Z_L_) delete [] SensitivityM_Z_L_ ; }
SmartPtr<const Vector> NLPScalingObject::apply_vector_scaling_d_LU( const Matrix& Pd_LU, const SmartPtr<const Vector>& lu, const VectorSpace& d_space) { DBG_START_METH("NLPScalingObject::apply_vector_scaling_d_LU", dbg_verbosity); if (have_d_scaling()) { return ConstPtr(apply_vector_scaling_d_LU_NonConst(Pd_LU, lu, d_space)); } else { return lu; } }
Number PiecewisePenalty::BiggestBarr() { DBG_START_METH("PiecewisePenalty::BiggestBarr", dbg_verbosity); DBG_ASSERT(!IsPiecewisePenaltyListEmpty()); Number value = -1e20; if (PiecewisePenalty_list_.size() > 0) { std::vector<PiecewisePenEntry>::iterator iter; iter = PiecewisePenalty_list_.end(); iter--; value = iter->barrier_obj; } return value; }
Number CompoundVector::MinImpl() const { DBG_START_METH("CompoundVector::MinImpl", dbg_verbosity); DBG_ASSERT(vectors_valid_); DBG_ASSERT(NComps() > 0 && Dim() > 0 && "There is no Min of a zero length vector (no reasonable default can be returned)"); Number min = std::numeric_limits<Number>::max(); for (Index i=0; i<NComps(); i++) { if (ConstComp(i)->Dim() != 0) { min = Ipopt::Min(min, ConstComp(i)->Min()); } } return min; }
void CompoundVector::AxpyImpl(Number alpha, const Vector &x) { DBG_START_METH("CompoundVector::AxpyImpl", dbg_verbosity); DBG_ASSERT(vectors_valid_); const CompoundVector* comp_x = static_cast<const CompoundVector*>(&x); DBG_ASSERT(dynamic_cast<const CompoundVector*>(&x)); DBG_ASSERT(NComps() == comp_x->NComps()); for (Index i=0; i<NComps(); i++) { DBG_ASSERT(Comp(i)); Comp(i)->Axpy(alpha, *comp_x->GetComp(i)); } }
bool TSymDependencyDetector::DetermineDependentRows( Index n_rows, Index n_cols, Index n_jac_nz, Number* jac_c_vals, Index* jac_c_iRow, Index* jac_c_jCol, std::list<Index>& c_deps) { DBG_START_METH("TSymDependencyDetector::DetermineDependentRows", dbg_verbosity); ESymSolverStatus retval = tsym_linear_solver_->DetermineDependentRows(n_rows, n_cols, n_jac_nz, jac_c_vals, jac_c_iRow, jac_c_jCol, c_deps); return (retval == SYMSOLVER_SUCCESS); }
bool IndexPCalculator::InitializeImpl(const OptionsList& options, const std::string& prefix) { DBG_START_METH("IndexPCalculator::InitializeImpl", dbg_verbosity); SmartPtr<const IteratesVector> iv = IpData().curr(); nrows_ = 0; for (Index i=0; i<iv->NComps(); ++i) { nrows_+=iv->GetComp(i)->Dim(); } data_A()->Print(Jnlst(),J_VECTOR,J_USER1,"PCalc SchurData"); return true; }
WsmpSolverInterface::WsmpSolverInterface() : a_(NULL), negevals_(-1), initialized_(false), PERM_(NULL), INVP_(NULL) { DBG_START_METH("WsmpSolverInterface::WsmpSolverInterface()",dbg_verbosity); IPARM_ = new ipfint[64]; DPARM_ = new double[64]; }
Number CompoundVector::DotImpl(const Vector &x) const { DBG_START_METH("CompoundVector::DotImpl", dbg_verbosity); DBG_ASSERT(vectors_valid_); const CompoundVector* comp_x = static_cast<const CompoundVector*>(&x); DBG_ASSERT(dynamic_cast<const CompoundVector*>(&x)); DBG_ASSERT(NComps() == comp_x->NComps()); Number dot = 0.; for (Index i=0; i<NComps(); i++) { DBG_ASSERT(ConstComp(i)); dot += ConstComp(i)->Dot(*comp_x->GetComp(i)); } return dot; }
SmartPtr<Vector> StandardScalingBase::unapply_vector_scaling_x_NonConst( const SmartPtr<const Vector>& v) { DBG_START_METH("StandardScalingBase::unapply_vector_scaling_x_NonConst", dbg_verbosity); SmartPtr<Vector> unscaled_x = v->MakeNewCopy(); if (IsValid(dx_)) { unscaled_x->ElementWiseDivide(*dx_); } else { DBG_PRINT((1, "Creating copy in unapply_vector_scaling_x_NonConst!")); } return unscaled_x; }
ESymSolverStatus MumpsSolverInterface::MultiSolve(bool new_matrix, const Index* ia, const Index* ja, Index nrhs, double* rhs_vals, bool check_NegEVals, Index numberOfNegEVals) { DBG_START_METH("MumpsSolverInterface::MultiSolve", dbg_verbosity); DBG_ASSERT(!check_NegEVals || ProvidesInertia()); DBG_ASSERT(initialized_); DBG_ASSERT(((DMUMPS_STRUC_C*)mumps_ptr_)->irn == ia); DBG_ASSERT(((DMUMPS_STRUC_C*)mumps_ptr_)->jcn == ja); if (pivtol_changed_) { DBG_PRINT((1,"Pivot tolerance has changed.\n")); pivtol_changed_ = false; // If the pivot tolerance has been changed but the matrix is not // new, we have to request the values for the matrix again to do // the factorization again. if (!new_matrix) { DBG_PRINT((1,"Ask caller to call again.\n")); refactorize_ = true; return SYMSOLVER_CALL_AGAIN; } } // check if a factorization has to be done DBG_PRINT((1, "new_matrix = %d\n", new_matrix)); if (new_matrix || refactorize_) { ESymSolverStatus retval; // Do the symbolic facotrization if it hasn't been done yet if (!have_symbolic_factorization_) { retval = SymbolicFactorization(); if (retval != SYMSOLVER_SUCCESS ) { return retval; } have_symbolic_factorization_ = true; } // perform the factorization retval = Factorization(check_NegEVals, numberOfNegEVals); if (retval != SYMSOLVER_SUCCESS) { DBG_PRINT((1, "FACTORIZATION FAILED!\n")); return retval; // Matrix singular or error occurred } refactorize_ = false; } // do the solve return Solve(nrhs, rhs_vals); }
SmartPtr<const Vector> NLPScalingObject::unapply_grad_obj_scaling( const SmartPtr<const Vector>& v) { DBG_START_METH("NLPScalingObject::unapply_grad_obj_scaling", dbg_verbosity); Number df = unapply_obj_scaling(1.); if (df != 1.) { SmartPtr<Vector> unscaled_v = unapply_grad_obj_scaling_NonConst(v); return ConstPtr(unscaled_v); } else { SmartPtr<const Vector> scaled_v = apply_vector_scaling_x(v); return scaled_v; } }
void CachedResults<T>::AddCachedResult2Dep(const T& result, const TaggedObject* dependent1, const TaggedObject* dependent2) { #ifdef IP_DEBUG_CACHE DBG_START_METH("CachedResults<T>::AddCachedResult2dDep", dbg_verbosity); #endif std::vector<const TaggedObject*> dependents(2); dependents[0] = dependent1; dependents[1] = dependent2; AddCachedResult(result, dependents); }
bool AmplTNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g) { DBG_START_METH("AmplTNLP::eval_g", dbg_verbosity); DBG_DO(ASL_pfgh* asl = asl_); DBG_ASSERT(n == n_var); DBG_ASSERT(m == n_con); if (!apply_new_x(new_x, n, x)) { return false; } return internal_conval(x, m, g); }