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;
}