wxString BattleroomListCtrl::GetItemText(long item, long column) const { if ( (item == -1) || (item >= (long)m_data.size()) || (m_battle == NULL)) return _T(""); const User& user = *GetDataFromIndex( item ); bool is_bot = user.BattleStatus().IsBot(); bool is_spec = user.BattleStatus().spectator; if ( column == m_faction_column_index ) { try { auto sides = LSL::usync().GetSides(STD_STRING(m_battle->GetHostModName())); ASSERT_EXCEPTION( user.BattleStatus().side < (long)sides.size(), _T("Side index too high") ); } catch ( ... ) { return wxFormat( _T("s%d") ) % (user.BattleStatus().side + 1); } return _T(""); } if ( column == m_nick_column_index ) { if ( is_bot ) { wxString botname = user.BattleStatus().aishortname; if ( !user.BattleStatus().aiversion.IsEmpty() ) botname += _T(" ") + user.BattleStatus().aiversion; if ( !LSL::usync().VersionSupports( LSL::USYNC_GetSkirmishAI ) ) { if ( botname.Find(_T('.')) != wxNOT_FOUND ) botname = botname.BeforeLast(_T('.')); if ( botname.Find(_T('/')) != wxNOT_FOUND ) botname = botname.AfterLast(_T('/')); if ( botname.Find(_T('\\')) != wxNOT_FOUND ) botname = botname.AfterLast(_T('\\')); if ( botname.Find(_T("LuaAI:")) != wxNOT_FOUND ) botname = botname.AfterFirst(_T(':')); } return (wxFormat(_T("%s - %s (%s)")) % user.GetNick() % botname % user.BattleStatus().owner); } else return user.GetNick(); } if ( column == m_team_column_index ) return is_spec ? _T("") : (wxFormat( _T("%d") ) % ( user.BattleStatus().team + 1 ) ).c_str(); if ( column == m_ally_column_index ) return is_spec ? _T("") : (wxFormat( _T("%d") ) % ( user.BattleStatus().ally + 1 ) ).c_str(); if ( column == m_resourcebonus_column_index ) return is_spec ? _T("") : (wxFormat( _T("%d%%") ) % user.BattleStatus().handicap ).c_str(); if ( column == m_country_column_index ) return _T(""); return _T(""); }
void ServerEvents::OnBattleOpened(int id, BattleType type, NatType nat, const std::string& nick, const std::string& host, int port, int maxplayers, bool haspass, int rank, const std::string& maphash, const std::string& engineName, const std::string& engineVersion, const std::string& map, const std::string& title, const std::string& mod) { slLogDebugFunc(""); try { ASSERT_EXCEPTION(!m_serv.BattleExists(id), _T("New battle from server, but already exists!")); IBattle& battle = m_serv._AddBattle(id); User& user = m_serv.GetUser(nick); battle.OnUserAdded(user); battle.SetBattleType(type); battle.SetNatType(nat); battle.SetFounder(nick); battle.SetHostIp(host); battle.SetHostPort(port); battle.SetMaxPlayers(maxplayers); battle.SetIsPassworded(haspass); battle.SetRankNeeded(rank); battle.SetHostMap(map, maphash); battle.SetDescription(title); battle.SetHostGame(mod, ""); battle.SetEngineName(engineName); battle.SetEngineVersion(engineVersion); if (useractions().DoActionOnUser(UserActions::ActNotifBattle, TowxString(user.GetNick()))) { actNotifBox(SL_MAIN_ICON, TowxString(user.GetNick()) + _(" opened battle ") + TowxString(title)); } if (!m_serv.IsOnline()) { //login info isn't complete yet return; } ui().OnBattleOpened(battle); if (user.Status().in_game) { battle.SetInGame(true); battle.StartSpring(); } } catch (std::runtime_error& except) { } }
void ServerEvents::OnBattleOpened( int id, BattleType type, NatType nat, const wxString& nick, const wxString& host, int port, int maxplayers, bool haspass, int rank, const wxString& maphash, const wxString& map, const wxString& title, const wxString& mod ) { wxLogDebugFunc( _T("") ); try { ASSERT_EXCEPTION( !m_serv.BattleExists( id ), _T("New battle from server, but already exists!") ); Battle& battle = m_serv._AddBattle( id ); User& user = m_serv.GetUser( nick ); battle.OnUserAdded( user ); battle.SetBattleType( type ); battle.SetNatType( nat ); battle.SetFounder( nick ); battle.SetHostIp( host ); battle.SetHostPort( port ); battle.SetMaxPlayers( maxplayers ); battle.SetIsPassworded( haspass ); battle.SetRankNeeded( rank ); battle.SetHostMap( map, maphash ); battle.SetDescription( title ); battle.SetHostMod( mod, wxEmptyString ); if ( useractions().DoActionOnUser( UserActions::ActNotifBattle, user.GetNick() ) ) actNotifBox( SL_MAIN_ICON, user.GetNick() + _(" opened battle ") + title ); ui().OnBattleOpened( battle ); if ( user.Status().in_game ) { battle.SetInGame( true ); battle.StartSpring(); } } catch (std::runtime_error &except) { } }
wxString BattleroomListCtrl::GetItemText(long item, long column) const { if ((item == -1) || (item >= (long)m_data.size()) || (m_battle == NULL)) return wxEmptyString; const User& user = *GetDataFromIndex(item); bool is_bot = user.BattleStatus().IsBot(); bool is_spec = user.BattleStatus().spectator; if (column == m_faction_column_index) { try { auto sides = LSL::usync().GetSides(m_battle->GetHostModName()); ASSERT_EXCEPTION(user.BattleStatus().side < (long)sides.size(), _T("Side index too high")); } catch (...) { return wxString::Format(_T("s%d"), user.BattleStatus().side + 1); } return wxEmptyString; } if (column == m_nick_column_index) { if (is_bot) { wxString botname = TowxString(user.BattleStatus().aishortname); if (!user.BattleStatus().aiversion.empty()) botname += _T(" ") + TowxString(user.BattleStatus().aiversion); return wxString::Format(_T("%s - %s (%s)"), TowxString(user.GetNick()).c_str(), botname.c_str(), TowxString(user.BattleStatus().owner).c_str()); } else return TowxString(user.GetNick()); } if (column == m_team_column_index) return is_spec ? wxString(wxEmptyString) : (wxString::Format(_T("%d"), user.BattleStatus().team + 1)); if (column == m_ally_column_index) return is_spec ? wxString(wxEmptyString) : (wxString::Format(_T("%d"), user.BattleStatus().ally + 1)); if (column == m_resourcebonus_column_index) return is_spec ? wxString(wxEmptyString) : (wxString::Format(_T("%d%%"), user.BattleStatus().handicap)); if (column == m_country_column_index) return wxEmptyString; return wxEmptyString; }
bool PhysicalQueryPlanNode::getInputIsStrict(const PhysicalOperator::Parameters& inputParameters) { bool isStrict = true; if (inputParameters.size() == 6 && inputParameters[5]->getParamType() == scidb::PARAM_PHYSICAL_EXPRESSION) { OperatorParamPhysicalExpression* paramExpr = static_cast<OperatorParamPhysicalExpression*>(inputParameters[5].get()); SCIDB_ASSERT(paramExpr->isConstant()); isStrict = paramExpr->getExpression()->evaluate().getBool(); } else if (inputParameters.size() == 7) { ASSERT_EXCEPTION((inputParameters[6]->getParamType() == scidb::PARAM_PHYSICAL_EXPRESSION), "Invalid input() parameters 6"); OperatorParamPhysicalExpression* paramExpr = static_cast<OperatorParamPhysicalExpression*>(inputParameters[6].get()); SCIDB_ASSERT(paramExpr->isConstant()); isStrict = paramExpr->getExpression()->evaluate().getBool(); } return isStrict; }
MainJoinBattleTab& MainWindow::GetJoinTab() { ASSERT_EXCEPTION(m_join_tab != 0, _T("m_join_tab = 0")); return *m_join_tab; }
//! @brief Returns the curent BattleListTab object BattleListTab& MainWindow::GetBattleListTab() { ASSERT_EXCEPTION(m_list_tab != 0, _T( "m_list_tab = 0" )); return *m_list_tab; }
//! @brief Returns the curent MainChatTab object MainChatTab& MainWindow::GetChatTab() { ASSERT_EXCEPTION(m_chat_tab != 0, _T("m_chat_tab = 0")); return *m_chat_tab; }
BattleroomMMOptionsTab& MainSinglePlayerTab::GetMMOptionsTab() { ASSERT_EXCEPTION(m_mm_opts_tab, _T( "m_mm_opts_tab == 0" )); return *m_mm_opts_tab; }
bool Ma57TSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { // Obtain the options settings options.GetNumericValue("ma57_pivtol", pivtol_, prefix); if (options.GetNumericValue("ma57_pivtolmax", pivtolmax_, prefix)) { ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID, "Option \"pivtolmax\": This value must be between " "pivtol and 1."); } else { pivtolmax_ = Max(pivtolmax_, pivtol_); } options.GetNumericValue("ma57_pre_alloc", ma57_pre_alloc_, prefix); Index ma57_pivot_order; options.GetIntegerValue("ma57_pivot_order", ma57_pivot_order, prefix); // The following option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); DBG_ASSERT(!warm_start_same_structure_ && "warm_start_same_structure not yet implemented"); bool ma57_automatic_scaling; options.GetBoolValue("ma57_automatic_scaling", ma57_automatic_scaling, prefix); // CET 04-29-2010 Index ma57_block_size; options.GetIntegerValue("ma57_block_size", ma57_block_size, prefix); Index ma57_node_amalgamation; options.GetIntegerValue("ma57_node_amalgamation", ma57_node_amalgamation, prefix); Index ma57_small_pivot_flag; options.GetIntegerValue("ma57_small_pivot_flag", ma57_small_pivot_flag, prefix); // CET 04-29-2010 /* Initialize. */ F77_FUNC (ma57id, MA57ID) (wd_cntl_, wd_icntl_); /* Custom settings for MA57. */ wd_icntl_[1-1] = 0; /* Error stream */ wd_icntl_[2-1] = 0; /* Warning stream. */ wd_icntl_[4-1] = 1; /* Print statistics. NOT Used. */ wd_icntl_[5-1] = 0; /* Print error. */ wd_icntl_[6-1] = ma57_pivot_order; /* Pivoting order. */ wd_cntl_[1-1] = pivtol_; /* Pivot threshold. */ wd_icntl_[7-1] = 1; /* Pivoting strategy. */ // CET: Added 04-29-2010 at suggestion of Jonathan Hogg of HSL wd_icntl_[11-1] = ma57_block_size; /* Block size used by Level 3 BLAS in MA57BD - should be a multiple of 8. Default is 16. */ wd_icntl_[12-1] = ma57_node_amalgamation; /* Two nodes of the assembly tree are merged only if both involve less than ICNTL(12) eliminations. Default is 16. */ // CET: 04-29-2010 if (ma57_automatic_scaling) { wd_icntl_[15-1] = 1; } else { wd_icntl_[15-1] = 0; } // CET: Added 04-29-2010 at suggestion of Jonathan Hogg of HSL wd_icntl_[16-1] = ma57_small_pivot_flag; /* If set to 1, small entries are removed and corresponding pivots are placed at the end of factorization. May be useful for highly rank deficient matrices. Default is 0. */ // CET: 04-29-2010 // wd_icntl[8-1] = 0; /* Retry factorization. */ if (!warm_start_same_structure_) { dim_=0; nonzeros_=0; delete [] a_; a_ = NULL; delete [] wd_fact_; wd_fact_ = NULL; delete [] wd_ifact_; wd_ifact_ = NULL; delete [] wd_iwork_; wd_iwork_ = NULL; delete [] wd_keep_; wd_keep_ = NULL; } else { ASSERT_EXCEPTION(dim_>0 && nonzeros_>0, INVALID_WARMSTART, "Ma57TSolverInterface called with warm_start_same_structure, " "but the problem is solved for the first time."); } return true; }
SmartPtr<IpoptAlgorithm> AlgorithmBuilder::BuildBasicAlgorithm(const Journalist& jnlst, const OptionsList& options, const std::string& prefix) { DBG_START_FUN("AlgorithmBuilder::BuildBasicAlgorithm", dbg_verbosity); bool mehrotra_algorithm; options.GetBoolValue("mehrotra_algorithm", mehrotra_algorithm, prefix); // Create the convergence check SmartPtr<ConvergenceCheck> convCheck = new OptimalityErrorConvergenceCheck(); // Create the solvers that will be used by the main algorithm SmartPtr<SparseSymLinearSolverInterface> SolverInterface; std::string linear_solver; options.GetStringValue("linear_solver", linear_solver, prefix); bool use_custom_solver = false; if (linear_solver=="ma27") { #ifndef COINHSL_HAS_MA27 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma27TSolverInterface(); if (!LSL_isMA27available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver MA27 not available.\nTried to obtain MA27 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MA27 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma27TSolverInterface(); #endif } else if (linear_solver=="ma57") { #ifndef COINHSL_HAS_MA57 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma57TSolverInterface(); if (!LSL_isMA57available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver MA57 not available.\nTried to obtain MA57 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MA57 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma57TSolverInterface(); #endif } else if (linear_solver=="ma77") { #ifndef COINHSL_HAS_MA77 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma77SolverInterface(); if (!LSL_isMA77available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA77 not available.\nTried to obtain HSL_MA77 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA77 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma77SolverInterface(); #endif } else if (linear_solver=="ma86") { #ifndef COINHSL_HAS_MA86 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma86SolverInterface(); if (!LSL_isMA86available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA86 not available.\nTried to obtain HSL_MA86 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA86 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma86SolverInterface(); #endif } else if (linear_solver=="pardiso") { #ifndef HAVE_PARDISO # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new PardisoSolverInterface(); char buf[256]; int rc = LSL_loadPardisoLib(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver Pardiso not available.\nTried to obtain Pardiso from shared library \""; errmsg += LSL_PardisoLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } # else THROW_EXCEPTION(OPTION_INVALID, "Support for Pardiso has not been compiled into Ipopt."); # endif #else SolverInterface = new PardisoSolverInterface(); #endif } else if (linear_solver=="ma97") { #ifndef COINHSL_HAS_MA97 # ifdef HAVE_LINEARSOLVERLOADER SolverInterface = new Ma97SolverInterface(); if (!LSL_isMA97available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear solver HSL_MA97 not available.\nTried to obtain HSL_MA97 from shared library \""; errmsg += LSL_HSLLibraryName(); errmsg += "\", but the following error occured:\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for HSL_MA97 has not been compiled into Ipopt."); # endif #else SolverInterface = new Ma97SolverInterface(); #endif } else if (linear_solver=="wsmp") { #ifdef HAVE_WSMP bool wsmp_iterative; options.GetBoolValue("wsmp_iterative", wsmp_iterative, prefix); if (wsmp_iterative) { SolverInterface = new IterativeWsmpSolverInterface(); } else { SolverInterface = new WsmpSolverInterface(); } #else THROW_EXCEPTION(OPTION_INVALID, "Selected linear solver WSMP not available."); #endif } else if (linear_solver=="mumps") { #ifdef COIN_HAS_MUMPS SolverInterface = new MumpsSolverInterface(); #else THROW_EXCEPTION(OPTION_INVALID, "Selected linear solver MUMPS not available."); #endif } else if (linear_solver=="custom") { ASSERT_EXCEPTION(IsValid(custom_solver_), OPTION_INVALID, "Selected linear solver CUSTOM not available."); use_custom_solver = true; } SmartPtr<AugSystemSolver> AugSolver; if (use_custom_solver) { AugSolver = custom_solver_; } else { SmartPtr<TSymScalingMethod> ScalingMethod; std::string linear_system_scaling; if (!options.GetStringValue("linear_system_scaling", linear_system_scaling, prefix)) { // By default, don't use mc19 for non-HSL solvers, or HSL_MA97 if (linear_solver!="ma27" && linear_solver!="ma57" && linear_solver!="ma77" && linear_solver!="ma86") { linear_system_scaling="none"; } } if (linear_system_scaling=="mc19") { #ifndef COINHSL_HAS_MC19 # ifdef HAVE_LINEARSOLVERLOADER ScalingMethod = new Mc19TSymScalingMethod(); if (!LSL_isMC19available()) { char buf[256]; int rc = LSL_loadHSL(NULL, buf, 255); if (rc) { std::string errmsg; errmsg = "Selected linear system scaling method MC19 not available.\n"; errmsg += buf; THROW_EXCEPTION(OPTION_INVALID, errmsg.c_str()); } } # else THROW_EXCEPTION(OPTION_INVALID, "Support for MC19 has not been compiled into Ipopt."); # endif #else ScalingMethod = new Mc19TSymScalingMethod(); #endif } else if (linear_system_scaling=="slack-based") { ScalingMethod = new SlackBasedTSymScalingMethod(); } SmartPtr<SymLinearSolver> ScaledSolver = new TSymLinearSolver(SolverInterface, ScalingMethod); AugSolver = new StdAugSystemSolver(*ScaledSolver); } Index enum_int; options.GetEnumValue("hessian_approximation", enum_int, prefix); HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { std::string lm_aug_solver; options.GetStringValue("limited_memory_aug_solver", lm_aug_solver, prefix); if (lm_aug_solver == "sherman-morrison") { AugSolver = new LowRankAugSystemSolver(*AugSolver); } else if (lm_aug_solver == "extended") { Index lm_history; options.GetIntegerValue("limited_memory_max_history", lm_history, prefix); Index max_rank; std::string lm_type; options.GetStringValue("limited_memory_update_type", lm_type, prefix); if (lm_type == "bfgs") { max_rank = 2*lm_history; } else if (lm_type == "sr1") { max_rank = lm_history; } else { THROW_EXCEPTION(OPTION_INVALID, "Unknown value for option \"limited_memory_update_type\"."); } AugSolver = new LowRankSSAugSystemSolver(*AugSolver, max_rank); } else { THROW_EXCEPTION(OPTION_INVALID, "Unknown value for option \"limited_memory_aug_solver\"."); } } SmartPtr<PDPerturbationHandler> pertHandler; std::string lsmethod; options.GetStringValue("line_search_method", lsmethod, prefix); if (lsmethod=="cg-penalty") { pertHandler = new CGPerturbationHandler(); } else { pertHandler = new PDPerturbationHandler(); } SmartPtr<PDSystemSolver> PDSolver = new PDFullSpaceSolver(*AugSolver, *pertHandler); // Create the object for initializing the iterates Initialization // object. We include both the warm start and the defaut // initializer, so that the warm start options can be activated // without having to rebuild the algorithm SmartPtr<EqMultiplierCalculator> EqMultCalculator = new LeastSquareMultipliers(*AugSolver); SmartPtr<IterateInitializer> WarmStartInitializer = new WarmStartIterateInitializer(); SmartPtr<IterateInitializer> IterInitializer = new DefaultIterateInitializer(EqMultCalculator, WarmStartInitializer, AugSolver); SmartPtr<RestorationPhase> resto_phase; SmartPtr<RestoConvergenceCheck> resto_convCheck; // We only need a restoration phase object if we use the filter // line search if (lsmethod=="filter" || lsmethod=="penalty") { // Solver for the restoration phase SmartPtr<AugSystemSolver> resto_AugSolver = new AugRestoSystemSolver(*AugSolver); SmartPtr<PDPerturbationHandler> resto_pertHandler = new PDPerturbationHandler(); SmartPtr<PDSystemSolver> resto_PDSolver = new PDFullSpaceSolver(*resto_AugSolver, *resto_pertHandler); // Convergence check in the restoration phase if (lsmethod=="filter") { resto_convCheck = new RestoFilterConvergenceCheck(); } else if (lsmethod=="penalty") { resto_convCheck = new RestoPenaltyConvergenceCheck(); } // Line search method for the restoration phase SmartPtr<RestoRestorationPhase> resto_resto = new RestoRestorationPhase(); SmartPtr<BacktrackingLSAcceptor> resto_LSacceptor; std::string resto_lsacceptor; options.GetStringValue("line_search_method", resto_lsacceptor, "resto."+prefix); if (resto_lsacceptor=="filter") { resto_LSacceptor = new FilterLSAcceptor(GetRawPtr(resto_PDSolver)); } else if (resto_lsacceptor=="cg-penalty") { resto_LSacceptor = new CGPenaltyLSAcceptor(GetRawPtr(resto_PDSolver)); } else if (resto_lsacceptor=="penalty") { resto_LSacceptor = new PenaltyLSAcceptor(GetRawPtr(resto_PDSolver)); } SmartPtr<LineSearch> resto_LineSearch = new BacktrackingLineSearch(resto_LSacceptor, GetRawPtr(resto_resto), GetRawPtr(resto_convCheck)); // Create the mu update that will be used by the restoration phase // algorithm SmartPtr<MuUpdate> resto_MuUpdate; std::string resto_smuupdate; if (!options.GetStringValue("mu_strategy", resto_smuupdate, "resto."+prefix)) { // Change default for quasi-Newton option (then we use adaptive) Index enum_int; if (options.GetEnumValue("hessian_approximation", enum_int, prefix)) { HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { resto_smuupdate = "adaptive"; } } } std::string resto_smuoracle; std::string resto_sfixmuoracle; if (resto_smuupdate=="adaptive" ) { options.GetStringValue("mu_oracle", resto_smuoracle, "resto."+prefix); options.GetStringValue("fixed_mu_oracle", resto_sfixmuoracle, "resto."+prefix); } if (resto_smuupdate=="monotone" ) { resto_MuUpdate = new MonotoneMuUpdate(GetRawPtr(resto_LineSearch)); } else if (resto_smuupdate=="adaptive") { SmartPtr<MuOracle> resto_MuOracle; if (resto_smuoracle=="loqo") { resto_MuOracle = new LoqoMuOracle(); } else if (resto_smuoracle=="probing") { resto_MuOracle = new ProbingMuOracle(resto_PDSolver); } else if (resto_smuoracle=="quality-function") { resto_MuOracle = new QualityFunctionMuOracle(resto_PDSolver); } SmartPtr<MuOracle> resto_FixMuOracle; if (resto_sfixmuoracle=="loqo") { resto_FixMuOracle = new LoqoMuOracle(); } else if (resto_sfixmuoracle=="probing") { resto_FixMuOracle = new ProbingMuOracle(resto_PDSolver); } else if (resto_sfixmuoracle=="quality-function") { resto_FixMuOracle = new QualityFunctionMuOracle(resto_PDSolver); } else { resto_FixMuOracle = NULL; } resto_MuUpdate = new AdaptiveMuUpdate(GetRawPtr(resto_LineSearch), resto_MuOracle, resto_FixMuOracle); } // Initialization of the iterates for the restoration phase SmartPtr<EqMultiplierCalculator> resto_EqMultCalculator = new LeastSquareMultipliers(*resto_AugSolver); SmartPtr<IterateInitializer> resto_IterInitializer = new RestoIterateInitializer(resto_EqMultCalculator); // Create the object for the iteration output during restoration SmartPtr<OrigIterationOutput> resto_OrigIterOutput = NULL; // new OrigIterationOutput(); SmartPtr<IterationOutput> resto_IterOutput = new RestoIterationOutput(resto_OrigIterOutput); // Get the Hessian updater for the restoration phase SmartPtr<HessianUpdater> resto_HessUpdater; switch (hessian_approximation) { case EXACT: resto_HessUpdater = new ExactHessianUpdater(); break; case LIMITED_MEMORY: // ToDo This needs to be replaced! resto_HessUpdater = new LimMemQuasiNewtonUpdater(true); break; } // Put together the overall restoration phase IP algorithm SmartPtr<SearchDirectionCalculator> resto_SearchDirCalc; if (resto_lsacceptor=="cg-penalty") { resto_SearchDirCalc = new CGSearchDirCalculator(GetRawPtr(resto_PDSolver)); } else { resto_SearchDirCalc = new PDSearchDirCalculator(GetRawPtr(resto_PDSolver)); } SmartPtr<IpoptAlgorithm> resto_alg = new IpoptAlgorithm(resto_SearchDirCalc, GetRawPtr(resto_LineSearch), GetRawPtr(resto_MuUpdate), GetRawPtr(resto_convCheck), resto_IterInitializer, resto_IterOutput, resto_HessUpdater, resto_EqMultCalculator); // Set the restoration phase resto_phase = new MinC_1NrmRestorationPhase(*resto_alg, EqMultCalculator); } // Create the line search to be used by the main algorithm SmartPtr<BacktrackingLSAcceptor> LSacceptor; if (lsmethod=="filter") { LSacceptor = new FilterLSAcceptor(GetRawPtr(PDSolver)); } else if (lsmethod=="cg-penalty") { LSacceptor = new CGPenaltyLSAcceptor(GetRawPtr(PDSolver)); } else if (lsmethod=="penalty") { LSacceptor = new PenaltyLSAcceptor(GetRawPtr(PDSolver)); } SmartPtr<LineSearch> lineSearch = new BacktrackingLineSearch(LSacceptor, GetRawPtr(resto_phase), convCheck); // The following cross reference is not good: We have to store a // pointer to the lineSearch object in resto_convCheck as a // non-SmartPtr to make sure that things are properly deleted when // the IpoptAlgorithm return by the Builder is destructed. if (IsValid(resto_convCheck)) { resto_convCheck->SetOrigLSAcceptor(*LSacceptor); } // Create the mu update that will be used by the main algorithm SmartPtr<MuUpdate> MuUpdate; std::string smuupdate; if (!options.GetStringValue("mu_strategy", smuupdate, prefix)) { // Change default for quasi-Newton option (then we use adaptive) Index enum_int; if (options.GetEnumValue("hessian_approximation", enum_int, prefix)) { HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if (hessian_approximation==LIMITED_MEMORY) { smuupdate = "adaptive"; } } if (mehrotra_algorithm) smuupdate = "adaptive"; } ASSERT_EXCEPTION(!mehrotra_algorithm || smuupdate=="adaptive", OPTION_INVALID, "If mehrotra_algorithm=yes, mu_strategy must be \"adaptive\"."); std::string smuoracle; std::string sfixmuoracle; if (smuupdate=="adaptive" ) { if (!options.GetStringValue("mu_oracle", smuoracle, prefix)) { if (mehrotra_algorithm) smuoracle = "probing"; } options.GetStringValue("fixed_mu_oracle", sfixmuoracle, prefix); ASSERT_EXCEPTION(!mehrotra_algorithm || smuoracle=="probing", OPTION_INVALID, "If mehrotra_algorithm=yes, mu_oracle must be \"probing\"."); } if (smuupdate=="monotone" ) { MuUpdate = new MonotoneMuUpdate(GetRawPtr(lineSearch)); } else if (smuupdate=="adaptive") { SmartPtr<MuOracle> muOracle; if (smuoracle=="loqo") { muOracle = new LoqoMuOracle(); } else if (smuoracle=="probing") { muOracle = new ProbingMuOracle(PDSolver); } else if (smuoracle=="quality-function") { muOracle = new QualityFunctionMuOracle(PDSolver); } SmartPtr<MuOracle> FixMuOracle; if (sfixmuoracle=="loqo") { FixMuOracle = new LoqoMuOracle(); } else if (sfixmuoracle=="probing") { FixMuOracle = new ProbingMuOracle(PDSolver); } else if (sfixmuoracle=="quality-function") { FixMuOracle = new QualityFunctionMuOracle(PDSolver); } else { FixMuOracle = NULL; } MuUpdate = new AdaptiveMuUpdate(GetRawPtr(lineSearch), muOracle, FixMuOracle); } // Create the object for the iteration output SmartPtr<IterationOutput> IterOutput = new OrigIterationOutput(); // Get the Hessian updater for the main algorithm SmartPtr<HessianUpdater> HessUpdater; switch (hessian_approximation) { case EXACT: HessUpdater = new ExactHessianUpdater(); break; case LIMITED_MEMORY: // ToDo This needs to be replaced! HessUpdater = new LimMemQuasiNewtonUpdater(false); break; } // Create the main algorithm SmartPtr<SearchDirectionCalculator> SearchDirCalc; if (lsmethod=="cg-penalty") { SearchDirCalc = new CGSearchDirCalculator(GetRawPtr(PDSolver)); } else { SearchDirCalc = new PDSearchDirCalculator(GetRawPtr(PDSolver)); } SmartPtr<IpoptAlgorithm> alg = new IpoptAlgorithm(SearchDirCalc, GetRawPtr(lineSearch), MuUpdate, convCheck, IterInitializer, IterOutput, HessUpdater, EqMultCalculator); return alg; }
MainDownloadTab& MainWindow::GetDownloadTab() { ASSERT_EXCEPTION(m_torrent_tab != 0, _T("m_torrent_tab = 0")); return *m_torrent_tab; }
BattleroomMMOptionsTab<Battle>& MainJoinBattleTab::GetMMOptionsTab() { ASSERT_EXCEPTION( m_mm_opts_tab, _T( "m_mm_opts_tab == 0" ) ); return *m_mm_opts_tab; }
BattleOptionsTab& MainJoinBattleTab::GetOptionsTab() { ASSERT_EXCEPTION( m_opts_tab, _T( "m_opts_tab == 0" ) ); return *m_opts_tab; }
BattleMapTab& MainJoinBattleTab::GetBattleMapTab() { ASSERT_EXCEPTION( m_map_tab, _T( "m_map_tab == 0" ) ); return *m_map_tab; }
BattleRoomTab& MainJoinBattleTab::GetBattleRoomTab() { ASSERT_EXCEPTION( m_battle_tab, _T( "m_battle_tab == 0" ) ); return *m_battle_tab; }
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; }
bool IterativeWsmpSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetIntegerValue("wsmp_num_threads", wsmp_num_threads_, prefix); Index wsmp_ordering_option; if (!options.GetIntegerValue("wsmp_ordering_option", wsmp_ordering_option, prefix)) { wsmp_ordering_option = 1; } Index wsmp_ordering_option2; if (!options.GetIntegerValue("wsmp_ordering_option2", wsmp_ordering_option2, prefix)) { wsmp_ordering_option2 = 0; } if (!options.GetNumericValue("wsmp_pivtol", wsmp_pivtol_, prefix)) { wsmp_pivtol_ = 1e-3; } if (options.GetNumericValue("wsmp_pivtolmax", wsmp_pivtolmax_, prefix)) { ASSERT_EXCEPTION(wsmp_pivtolmax_>=wsmp_pivtol_, OPTION_INVALID, "Option \"wsmp_pivtolmax\": This value must be between " "wsmp_pivtol and 1."); } else { wsmp_pivtolmax_ = Max(wsmp_pivtolmax_, wsmp_pivtol_); } if (!options.GetIntegerValue("wsmp_scaling", wsmp_scaling_, prefix)) { wsmp_scaling_ = 1; } options.GetIntegerValue("wsmp_write_matrix_iteration", wsmp_write_matrix_iteration_, prefix); Index wsmp_max_iter; options.GetIntegerValue("wsmp_max_iter", wsmp_max_iter, prefix); options.GetNumericValue("wsmp_inexact_droptol", wsmp_inexact_droptol_, prefix); options.GetNumericValue("wsmp_inexact_fillin_limit", wsmp_inexact_fillin_limit_, prefix); // Reset all private data dim_=0; initialized_=false; pivtol_changed_ = false; have_symbolic_factorization_ = false; delete[] a_; a_ = NULL; #if 1 // Set the number of threads ipfint NTHREADS = wsmp_num_threads_; F77_FUNC(wsetmaxthrds,WSETMAXTHRDS)(&NTHREADS); Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "WSMP will use %d threads.\n", wsmp_num_threads_); #else Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "Not setting WISMP threads at the moment.\n"); #endif // Get WSMP's default parameters and set the ones we want differently IPARM_[0] = 0; IPARM_[1] = 0; IPARM_[2] = 0; ipfint idmy; double ddmy; F77_FUNC(wismp,WISMP)(&idmy, &idmy, &idmy, &ddmy, &ddmy, &idmy, &ddmy, &idmy, &idmy, &ddmy, &ddmy, IPARM_, DPARM_); IPARM_[3] = 3; // Upper trianguar portion of matrix in CSR format // (same as for WSSMP) IPARM_[6] = 3; IPARM_[13] = 0; // do not overwrite avals IPARM_[27] = 0; // to make runs repeatable #if 1 IPARM_[5] = wsmp_max_iter; // maximal number of iterations IPARM_[15] = wsmp_ordering_option; // ordering option IPARM_[16] = wsmp_ordering_option2; // for ordering in IP methods? #endif DPARM_[13] = wsmp_inexact_droptol_; DPARM_[14] = wsmp_inexact_fillin_limit_; // DELETE IPARM_[33] = 0; matrix_file_number_ = 0; // Check for SPINLOOPTIME and YIELDLOOPTIME? return true; }
PlasmaResourceInfo PlasmaInterface::ParseResourceInfoData( const int buffer_index ) { PlasmaResourceInfo info; wxString wxbuf = m_buffers[buffer_index]; wxString t_begin = _T("<soap:Envelope"); wxString t_end = _T("</soap:Envelope>"); wxString xml_section = wxbuf.Mid( wxbuf.Find( t_begin ) );//first char after t_begin to one before t_end wxStringInputStream str_input( xml_section ); wxXmlDocument xml( str_input ); ASSERT_EXCEPTION( xml.GetRoot(), _T("Plasma: XMLparser: no root") ); wxXmlNode *node = xml.GetRoot()->GetChildren(); ASSERT_EXCEPTION( node , _T("Plasma: XMLparser: no first node") ); wxString resourceType ( _T("unknown") ); node = node->GetChildren(); ASSERT_EXCEPTION( node , _T("Plasma: XMLparser: no node") ); while ( node ) { wxString node_name = node->GetName(); if ( node_name == _T("DownloadFileResponse") ) { wxXmlNode* downloadFileResult = node->GetChildren(); ASSERT_EXCEPTION( downloadFileResult, _T("Plasma: XMLparser: no result section") ); wxString result = downloadFileResult->GetNodeContent(); //check result wxXmlNode* links = downloadFileResult->GetNext(); ASSERT_EXCEPTION( links, _T("Plasma: XMLparser: no webseed section") ); wxXmlNode* url = links->GetChildren(); while ( url ) { wxString seed_url = url->GetNodeContent(); seed_url.Replace(_T(" "),_T("%20")); info.m_webseeds.Add( seed_url ); url = url->GetNext(); } wxXmlNode* next = links->GetNext(); while ( next ) { wxString next_name = next->GetName(); if ( next_name == _T("torrentFileName") ) { info.m_torrent_filename = next->GetNodeContent(); } else if ( next_name == _T("dependencies") ) { wxXmlNode* deps = next->GetChildren(); while ( deps ) { info.m_dependencies.Add( deps->GetNodeContent() ); deps = deps->GetNext(); } } else if ( next_name == _T("resourceType") ) { resourceType = next->GetNodeContent(); if ( resourceType == _T("Mod") ) info.m_type = PlasmaResourceInfo::mod; else if ( resourceType == _T("Map") ) info.m_type = PlasmaResourceInfo::map; else info.m_type = PlasmaResourceInfo::unknown; } next = next->GetNext(); } break; } // end section <DownloadFileResponse/> node = node->GetNext(); } wxString seeds; for ( size_t i = 0; i < info.m_webseeds.Count(); ++i ) seeds += info.m_webseeds[i] + _T("\n"); return info; }
MainSinglePlayerTab& MainWindow::GetSPTab() { ASSERT_EXCEPTION(m_sp_tab != 0, _T("m_sp_tab = 0")); return *m_sp_tab; }
PlaybackTab& MainWindow::GetReplayTab() { ASSERT_EXCEPTION(m_replay_tab != 0, _T("m_replay_tab = 0")); return *m_replay_tab; }
Channel& IServer::GetChannel(const std::string& name) { ASSERT_EXCEPTION(!name.empty(), _T("GetChannel with empty nickname called")); return m_channels.GetChannel(name); }
ESymSolverStatus IterativePardisoSolverInterface::Solve(const Index* ia, const Index* ja, Index nrhs, double *rhs_vals) { DBG_START_METH("IterativePardisoSolverInterface::Solve",dbg_verbosity); DBG_ASSERT(nrhs==1); if (HaveIpData()) { IpData().TimingStats().LinearSystemBackSolve().Start(); } // Call Pardiso to do the solve for the given right-hand sides ipfint PHASE = 33; ipfint N = dim_; ipfint PERM; // This should not be accessed by Pardiso ipfint NRHS = nrhs; double* X = new double[nrhs*dim_]; double* ORIG_RHS = new double[nrhs*dim_]; ipfint ERROR; // Initialize solution with zero and save right hand side for (int i = 0; i < N; i++) { X[i] = 0; ORIG_RHS[i] = rhs_vals[i]; } // Dump matrix to file if requested Index iter_count = 0; if (HaveIpData()) { iter_count = IpData().iter_count(); } write_iajaa_matrix (N, ia, ja, a_, rhs_vals, iter_count, debug_cnt_); IterativeSolverTerminationTester* tester; int attempts = 0; const int max_attempts = pardiso_max_droptol_corrections_+1; bool is_normal = false; if (IsNull(InexData().normal_x()) && InexData().compute_normal()) { tester = GetRawPtr(normal_tester_); is_normal = true; } else { tester = GetRawPtr(pd_tester_); } global_tester_ptr_ = tester; while (attempts<max_attempts) { bool retval = tester->InitializeSolve(); ASSERT_EXCEPTION(retval, INTERNAL_ABORT, "tester->InitializeSolve(); returned false"); for (int i = 0; i < N; i++) { rhs_vals[i] = ORIG_RHS[i]; } DPARM_[ 8] = 25; // non_improvement in SQMR iteration F77_FUNC(pardiso,PARDISO)(PT_, &MAXFCT_, &MNUM_, &MTYPE_, &PHASE, &N, a_, ia, ja, &PERM, &NRHS, IPARM_, &MSGLVL_, rhs_vals, X, &ERROR, DPARM_); if (ERROR <= -100 && ERROR >= -110) { Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "Iterative solver in Pardiso did not converge (ERROR = %d)\n", ERROR); Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, " Decreasing drop tolerances from DPARM_[ 4] = %e and DPARM_[ 5] = %e ", DPARM_[ 4], DPARM_[ 5]); if (is_normal) { Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "(normal step)\n"); } else { Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "(PD step)\n"); } PHASE = 23; DPARM_[ 4] *= decr_factor_; DPARM_[ 5] *= decr_factor_; Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, " to DPARM_[ 4] = %e and DPARM_[ 5] = %e\n", DPARM_[ 4], DPARM_[ 5]); // Copy solution back to y to get intial values for the next iteration attempts++; ERROR = 0; } else { attempts = max_attempts; Index iterations_used = tester->GetSolverIterations(); if (is_normal) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Number of iterations in Pardiso iterative solver for normal step = %d.\n", iterations_used); } else { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Number of iterations in Pardiso iterative solver for PD step = %d.\n", iterations_used); } } tester->Clear(); } if (is_normal) { if (DPARM_[4] < normal_pardiso_iter_dropping_factor_) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Increasing drop tolerances from DPARM_[ 4] = %e and DPARM_[ 5] = %e (normal step\n", DPARM_[ 4], DPARM_[ 5]); } normal_pardiso_iter_dropping_factor_used_ = Min(DPARM_[4]/decr_factor_, normal_pardiso_iter_dropping_factor_); normal_pardiso_iter_dropping_schur_used_ = Min(DPARM_[5]/decr_factor_, normal_pardiso_iter_dropping_schur_); if (DPARM_[4] < normal_pardiso_iter_dropping_factor_) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, " to DPARM_[ 4] = %e and DPARM_[ 5] = %e for next iteration.\n", normal_pardiso_iter_dropping_factor_used_, normal_pardiso_iter_dropping_schur_used_); } } else { if (DPARM_[4] < pardiso_iter_dropping_factor_) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Increasing drop tolerances from DPARM_[ 4] = %e and DPARM_[ 5] = %e (PD step\n", DPARM_[ 4], DPARM_[ 5]); } pardiso_iter_dropping_factor_used_ = Min(DPARM_[4]/decr_factor_, pardiso_iter_dropping_factor_); pardiso_iter_dropping_schur_used_ = Min(DPARM_[5]/decr_factor_, pardiso_iter_dropping_schur_); if (DPARM_[4] < pardiso_iter_dropping_factor_) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, " to DPARM_[ 4] = %e and DPARM_[ 5] = %e for next iteration.\n", pardiso_iter_dropping_factor_used_, pardiso_iter_dropping_schur_used_); } } delete [] X; delete [] ORIG_RHS; if (IPARM_[6] != 0) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Number of iterative refinement steps = %d.\n", IPARM_[6]); if (HaveIpData()) { IpData().Append_info_string("Pi"); } } if (HaveIpData()) { IpData().TimingStats().LinearSystemBackSolve().End(); } if (ERROR!=0 ) { Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA, "Error in Pardiso during solve phase. ERROR = %d.\n", ERROR); return SYMSOLVER_FATAL_ERROR; } if (test_result_ == IterativeSolverTerminationTester::MODIFY_HESSIAN) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Termination tester requests modification of Hessian\n"); return SYMSOLVER_WRONG_INERTIA; } #if 0 // FRANK: look at this: if (test_result_ == IterativeSolverTerminationTester::CONTINUE) { if (InexData().compute_normal()) { Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Termination tester not satisfied!!! Pretend singular\n"); return SYMSOLVER_SINGULAR; } } #endif if (test_result_ == IterativeSolverTerminationTester::TEST_2_SATISFIED) { // Termination Test 2 is satisfied, set the step for the primal // iterates to zero Index nvars = IpData().curr()->x()->Dim() + IpData().curr()->s()->Dim(); const Number zero = 0.; IpBlasDcopy(nvars, &zero, 0, rhs_vals, 1); } return SYMSOLVER_SUCCESS; }
void run() { create(); BSONObjSetDefaultOrder keys; ASSERT_EXCEPTION( id().getKeysFromObject( fromjson( "{a:[{b:[1],c:[2]}]}" ), keys ), UserException ); }
User& IServer::GetUser(const std::string& nickname) const { ASSERT_EXCEPTION(!nickname.empty(), _T("GetUser with empty nickname called")); return m_users.GetUser(nickname); }
IBattle& BattleroomListCtrl::GetBattle() { ASSERT_EXCEPTION( m_battle, _T("m_battle == 0") ); return *m_battle; }
IBattle& IServer::GetBattle(const int& battleid) { ASSERT_EXCEPTION(BattleExists(battleid), _T("Battle doesn't exist!")); return battles_iter->GetBattle(battleid); }
bool CompositeNLP::GetSpaces(SmartPtr<const VectorSpace>& x_space, SmartPtr<const VectorSpace>& c_space, SmartPtr<const VectorSpace>& d_space, SmartPtr<const VectorSpace>& x_l_space, SmartPtr<const MatrixSpace>& px_l_space, SmartPtr<const VectorSpace>& x_u_space, SmartPtr<const MatrixSpace>& px_u_space, SmartPtr<const VectorSpace>& d_l_space, SmartPtr<const MatrixSpace>& pd_l_space, SmartPtr<const VectorSpace>& d_u_space, SmartPtr<const MatrixSpace>& pd_u_space, SmartPtr<const MatrixSpace>& Jac_c_space, SmartPtr<const MatrixSpace>& Jac_d_space, SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space) { Index n_nlps = nlps_.size(); DBG_ASSERT(n_nlps > 0); Index q_dim = Jq_linking_eqns_[0]->NCols(); Index linking_eqn_dim = 0; Index x_dim=0; Index c_dim=0; Index d_dim=0; Index x_l_dim = 0; Index px_l_cols = 0; Index px_l_rows = 0; Index x_u_dim = 0; Index px_u_cols = 0; Index px_u_rows = 0; Index d_l_dim = 0; Index pd_l_cols = 0; Index pd_l_rows = 0; Index d_u_dim = 0; Index pd_u_cols = 0; Index pd_u_rows = 0; Index jac_c_cols = 0; Index jac_c_rows = 0; Index jac_d_cols = 0; Index jac_d_rows = 0; Index h_cols = 0; Index h_rows = 0; // retrieve the necessary spaces from the individual NLPS std::vector<SmartPtr<const VectorSpace> > x_spaces; std::vector<SmartPtr<const VectorSpace> > c_spaces; std::vector<SmartPtr<const VectorSpace> > d_spaces; std::vector<SmartPtr<const VectorSpace> > x_l_spaces; std::vector<SmartPtr<const MatrixSpace> > px_l_spaces; std::vector<SmartPtr<const VectorSpace> > x_u_spaces; std::vector<SmartPtr<const MatrixSpace> > px_u_spaces; std::vector<SmartPtr<const VectorSpace> > d_l_spaces; std::vector<SmartPtr<const MatrixSpace> > pd_l_spaces; std::vector<SmartPtr<const VectorSpace> > d_u_spaces; std::vector<SmartPtr<const MatrixSpace> > pd_u_spaces; std::vector<SmartPtr<const MatrixSpace> > jac_c_spaces; std::vector<SmartPtr<const MatrixSpace> > jac_d_spaces; std::vector<SmartPtr<const SymMatrixSpace> > h_spaces; for (Index i=0; i<n_nlps; i++) { DBG_ASSERT(IsValid(nlps_[i])); ASSERT_EXCEPTION(Jq_linking_eqns_[i]->NCols() == q_dim, INVALID_JACOBIAN_DIMENSION_FOR_LINKING_EQUATIONS, "The # of columns in the Jq_linking_eqn must be the same for all nlp periods, i.e. Jc_linking_eqns[i] == q_dim for all i"); linking_eqn_dim += Jx_linking_eqns_[i]->NRows(); ASSERT_EXCEPTION(Jx_linking_eqns_[i]->NRows() == Jq_linking_eqns_[i]->NRows() , INVALID_JACOBIAN_DIMENSION_FOR_LINKING_EQUATIONS, "The # of rows in the Jx_linking_eqns[i] must be the same as the number of rows in the Jq_linking_eqns[i]"); SmartPtr<const VectorSpace> x_space_i; SmartPtr<const VectorSpace> c_space_i; SmartPtr<const VectorSpace> d_space_i; SmartPtr<const VectorSpace> x_l_space_i; SmartPtr<const MatrixSpace> px_l_space_i; SmartPtr<const VectorSpace> x_u_space_i; SmartPtr<const MatrixSpace> px_u_space_i; SmartPtr<const VectorSpace> d_l_space_i; SmartPtr<const MatrixSpace> pd_l_space_i; SmartPtr<const VectorSpace> d_u_space_i; SmartPtr<const MatrixSpace> pd_u_space_i; SmartPtr<const MatrixSpace> jac_c_space_i; SmartPtr<const MatrixSpace> jac_d_space_i; SmartPtr<const SymMatrixSpace> h_space_i; bool retvalue = nlps_[i]->GetSpaces(x_space_i, c_space_i, d_space_i, x_l_space_i, px_l_space_i, x_u_space_i, px_u_space_i, d_l_space_i, pd_l_space_i, d_u_space_i, pd_u_space_i, jac_c_space_i, jac_d_space_i, h_space_i); if (!retvalue) { return false; } x_spaces.push_back(x_space_i); x_dim += x_space_i->Dim(); ASSERT_EXCEPTION(Jx_linking_eqns_[i]->NCols() == x_space_i->Dim(), INVALID_JACOBIAN_DIMENSION_FOR_LINKING_EQUATIONS, "The # of columns in the Jx_linking_eqn must be the same as the dimension of x for that NLP period."); c_spaces.push_back(c_space_i); c_dim += c_space_i->Dim(); d_spaces.push_back(d_space_i); d_dim += d_space_i->Dim(); x_l_spaces.push_back(x_l_space_i); x_l_dim += x_l_space_i->Dim(); px_l_spaces.push_back(px_l_space_i); px_l_cols += px_l_space_i->NCols(); px_l_rows += px_l_space_i->NRows(); x_u_spaces.push_back(x_u_space_i); x_u_dim += x_u_space_i->Dim(); px_u_spaces.push_back(px_u_space_i); px_u_cols += px_u_space_i->NCols(); px_u_rows += px_u_space_i->NRows(); d_l_spaces.push_back(d_l_space_i); d_l_dim += d_l_space_i->Dim(); pd_l_spaces.push_back(pd_l_space_i); pd_l_cols += pd_l_space_i->NCols(); pd_l_rows += pd_l_space_i->NRows(); d_u_spaces.push_back(d_u_space_i); d_u_dim += d_u_space_i->Dim(); pd_u_spaces.push_back(pd_u_space_i); pd_u_cols += pd_u_space_i->NCols(); pd_u_rows += pd_u_space_i->NRows(); jac_c_spaces.push_back(jac_c_space_i); jac_c_cols += jac_c_space_i->NCols(); jac_c_rows += jac_c_space_i->NRows(); jac_d_spaces.push_back(jac_d_space_i); jac_d_cols += jac_d_space_i->NCols(); jac_d_rows += jac_d_space_i->NRows(); h_spaces.push_back(h_space_i); h_cols += h_space_i->NCols(); h_rows += h_space_i->NRows(); } // Create the compound vector spaces for the composite nlps // Need space for each nlp + one for the common variables SmartPtr<CompoundVectorSpace> Cx_space = new CompoundVectorSpace(n_nlps + 1, x_dim + q_dim); SmartPtr<CompoundVectorSpace> Cc_space = new CompoundVectorSpace(2*n_nlps, c_dim + linking_eqn_dim); SmartPtr<CompoundVectorSpace> Cd_space = new CompoundVectorSpace(n_nlps, d_dim); SmartPtr<CompoundVectorSpace> Cx_l_space = new CompoundVectorSpace(n_nlps, x_l_dim); SmartPtr<CompoundMatrixSpace> Cpx_l_space = new CompoundMatrixSpace(n_nlps + 1, n_nlps, px_l_rows + q_dim, px_l_cols); SmartPtr<CompoundVectorSpace> Cx_u_space = new CompoundVectorSpace(n_nlps, x_u_dim); SmartPtr<CompoundMatrixSpace> Cpx_u_space = new CompoundMatrixSpace(n_nlps + 1, n_nlps, px_u_rows + q_dim, px_u_cols); SmartPtr<CompoundVectorSpace> Cd_l_space = new CompoundVectorSpace(n_nlps, d_l_dim); SmartPtr<CompoundMatrixSpace> Cpd_l_space = new CompoundMatrixSpace(n_nlps, n_nlps, pd_l_rows, pd_l_cols); SmartPtr<CompoundVectorSpace> Cd_u_space = new CompoundVectorSpace(n_nlps, d_u_dim); SmartPtr<CompoundMatrixSpace> Cpd_u_space = new CompoundMatrixSpace(n_nlps, n_nlps, pd_u_rows, pd_u_cols); DBG_ASSERT(jac_c_cols == x_dim && jac_c_rows == c_dim); SmartPtr<CompoundMatrixSpace> CJac_c_space = new CompoundMatrixSpace(2*n_nlps, n_nlps+1, c_dim + linking_eqn_dim, x_dim + q_dim); DBG_ASSERT(jac_d_cols == x_dim && jac_d_rows == d_dim); SmartPtr<CompoundMatrixSpace> CJac_d_space = new CompoundMatrixSpace(n_nlps, n_nlps+1, d_dim, x_dim + q_dim); SmartPtr<CompoundSymMatrixSpace> CHess_lagrangian_space = new CompoundSymMatrixSpace(n_nlps + 1, x_dim + q_dim); // Set the compound space dimensions for (Index i=0; i<n_nlps; i++) { Cpx_l_space->SetBlockRows(i, x_spaces[i]->Dim()); Cpx_l_space->SetBlockCols(i, x_l_spaces[i]->Dim()); Cpx_u_space->SetBlockRows(i, x_spaces[i]->Dim()); Cpx_u_space->SetBlockCols(i, x_u_spaces[i]->Dim()); Cpd_l_space->SetBlockRows(i, d_spaces[i]->Dim()); Cpd_l_space->SetBlockCols(i, d_l_spaces[i]->Dim()); Cpd_u_space->SetBlockRows(i, d_spaces[i]->Dim()); Cpd_u_space->SetBlockCols(i, d_u_spaces[i]->Dim()); CJac_c_space->SetBlockRows(i, jac_c_spaces[i]->NRows()); CJac_c_space->SetBlockCols(i, x_spaces[i]->Dim()); CJac_c_space->SetBlockRows(n_nlps + i, Jx_linking_eqns_[i]->NRows()); CJac_d_space->SetBlockRows(i, jac_d_spaces[i]->NRows()); CJac_d_space->SetBlockCols(i, x_spaces[i]->Dim()); CHess_lagrangian_space->SetBlockDim(i, x_spaces[i]->Dim()); } Cpx_l_space->SetBlockRows(n_nlps, q_dim); Cpx_u_space->SetBlockRows(n_nlps, q_dim); CJac_c_space->SetBlockCols(n_nlps, q_dim); CJac_d_space->SetBlockCols(n_nlps, q_dim); CHess_lagrangian_space->SetBlockDim(n_nlps, q_dim); // Set the compound spaces x_space = GetRawPtr(Cx_space); c_space = GetRawPtr(Cc_space); d_space = GetRawPtr(Cd_space); x_l_space = GetRawPtr(Cx_l_space); px_l_space = GetRawPtr(Cpx_l_space); x_u_space = GetRawPtr(Cx_u_space); px_u_space = GetRawPtr(Cpx_u_space); d_l_space = GetRawPtr(Cd_l_space); pd_l_space = GetRawPtr(Cpd_l_space); d_u_space = GetRawPtr(Cd_u_space); pd_u_space = GetRawPtr(Cpd_u_space); Jac_c_space = GetRawPtr(CJac_c_space); Jac_d_space = GetRawPtr(CJac_d_space); Hess_lagrangian_space = GetRawPtr(CHess_lagrangian_space); for (Index i=0; i<n_nlps; i++) { // Assign the individual vector spaces to the compound vectors Cx_space->SetCompSpace(i, *x_spaces[i]); Cc_space->SetCompSpace(i, *c_spaces[i]); Cc_space->SetCompSpace(i + n_nlps, *linking_eqn_c_spaces_[i]); Cd_space->SetCompSpace(i, *d_spaces[i]); Cx_l_space->SetCompSpace(i, *x_l_spaces[i]); bool auto_allocate = true; Cpx_l_space->SetCompSpace(i, i, *px_l_spaces[i], auto_allocate); Cx_u_space->SetCompSpace(i, *x_u_spaces[i]); Cpx_u_space->SetCompSpace(i, i, *px_u_spaces[i], auto_allocate); Cd_l_space->SetCompSpace(i, *d_l_spaces[i]); Cpd_l_space->SetCompSpace(i, i, *pd_l_spaces[i], auto_allocate); Cd_u_space->SetCompSpace(i, *d_u_spaces[i]); Cpd_u_space->SetCompSpace(i, i, *pd_u_spaces[i], auto_allocate); CJac_c_space->SetCompSpace(i, i, *jac_c_spaces[i], true); CJac_c_space->SetCompSpace(n_nlps + i, i, *Jx_linking_eqns_[i]->OwnerSpace()); CJac_c_space->SetCompSpace(n_nlps + i, n_nlps, *Jq_linking_eqns_[i]->OwnerSpace()); CJac_d_space->SetCompSpace(i, i, *jac_d_spaces[i], true); // CJac_d_space->SetCompSpace(i, n_nlps, *(new ZeroMatrixSpace(jac_d_spaces[i]->NRows(), q_dim)), true); CHess_lagrangian_space->SetCompSpace(i, i, *h_spaces[i], true); // h_space->SetCompSpace(n_nlps, i, new ZeroMatrixSpace(q_dim, jac_c_spaces[i]->NCols())); } Cx_space->SetCompSpace(n_nlps, *q_space_); // Cpx_l_space->SetCompSpace(n_nlps, n_nlps - 1, *(new ZeroMatrixSpace(q_dim, px_l_spaces[n_nlps-1]->NCols())), true); // Cpx_u_space->SetCompSpace(n_nlps, n_nlps - 1, *(new ZeroMatrixSpace(q_dim, px_u_spaces[n_nlps-1]->NCols())), true); // CHess_lagrangian_space->SetCompSpace(n_nlps, n_nlps, *(new ZeroMatrixSpace(q_dim, q_dim))); x_space = GetRawPtr(Cx_space); c_space = GetRawPtr(Cc_space); d_space = GetRawPtr(Cd_space); x_l_space = GetRawPtr(Cx_l_space); px_l_space = GetRawPtr(Cpx_l_space); x_u_space = GetRawPtr(Cx_u_space); px_u_space = GetRawPtr(Cpx_u_space); d_l_space = GetRawPtr(Cd_l_space); pd_l_space = GetRawPtr(Cpd_l_space); d_u_space = GetRawPtr(Cd_u_space); pd_u_space = GetRawPtr(Cpd_u_space); Jac_c_space = GetRawPtr(CJac_c_space); Jac_d_space = GetRawPtr(CJac_d_space); Hess_lagrangian_space = GetRawPtr(CHess_lagrangian_space); return true; }
GroupOptionsPanel& MainOptionsTab::GetGroupOptionsPanel() { ASSERT_EXCEPTION( m_groups_opts != 0, _T( "m_groups_opts == 0" ) ); return *m_groups_opts; }
SinglePlayerTab& MainSinglePlayerTab::GetSinglePlayerTab() { ASSERT_EXCEPTION(m_sp_tab, _T( "m_sp_tab == 0" )); return *m_sp_tab; }