SerialVector::SerialVector(const VectorSpace<double>& vs)
: SingleChunkVector<double>(),
vecSpace_(vs),
data_(vs.dim()),
dim_(vs.dim())
{
const SerialVectorSpace* rvs
= dynamic_cast<const SerialVectorSpace*>(vs.ptr().get());
TEUCHOS_TEST_FOR_EXCEPTION(rvs==0, std::runtime_error,
"could not cast vector space to SerialVectorSpace in "
"SerialVector ctor");
}
bool VectorSpaceThyra::is_compatible(const VectorSpace& vec_spc ) const
{
if( this->dim()==vec_spc.dim() && this->is_in_core() && vec_spc.is_in_core() )
return true;
const VectorSpaceThyra
*thyra_vec_spc = dynamic_cast<const VectorSpaceThyra*>(&vec_spc);
if( thyra_vec_spc->thyra_vec_spc()->isCompatible(*thyra_vec_spc_) )
return true;
return false;
}
bool VectorSpaceSubSpace::is_compatible(const VectorSpace& another_space) const
{
if( this->dim() == another_space.dim() && this->is_in_core() && another_space.is_in_core() )
return true;
const VectorSpaceSubSpace
*a_space = dynamic_cast<const VectorSpaceSubSpace*>(&another_space);
if(!a_space)
return false;
return
( this->full_space_.get() == NULL && a_space->full_space_.get() == NULL )
||
( this->rng_ == a_space->rng_ && this->full_space_->is_compatible(*a_space->full_space_) );
}
MoochoPack::MoochoSolver::ESolutionStatus
NLPInterfacePack::ExampleNLPFirstOrderRun(
const VectorSpace& vec_space
,value_type xo
,bool has_bounds
,bool dep_bounded
,std::ostream* console_out
,std::ostream* error_out
,bool throw_solve_exception
,std::ostream* algo_out
,std::ostream* summary_out
,std::ostream* journal_out
)
{
using std::endl;
using std::setw;
namespace rcp = MemMngPack;
using Teuchos::RCP;
namespace ofsp = OptionsFromStreamPack;
using ofsp::OptionsFromStream;
namespace rsqp = MoochoPack;
using rsqp::MoochoSolver;
using rsqp::NLPAlgoConfigMamaJama;
MoochoSolver::ESolutionStatus
solve_return = MoochoSolver::SOLVE_RETURN_EXCEPTION;
int prec = 8;
if(console_out)
*console_out
<< std::setprecision(prec)
<< std::scientific
<< "*************************************************\n"
<< "*** Running Tests on ExampleNLPFirstOrder ***\n"
<< "*************************************************\n"
<< "\nUsing a vector space of type \'" << typeName(vec_space) << "\'"
<< "\nwith a dimension of vec_space.dim() = " << vec_space.dim()
<< std::endl;
// Create the nlp
ExampleNLPFirstOrder
nlp(VectorSpace::space_ptr_t(&vec_space,false),xo,has_bounds,dep_bounded);
// Create the solver object and set it up
MoochoSolver solver;
solver.set_nlp(Teuchos::rcp(&nlp,false)); // Set nlp
// set up outputting
solver.set_error_handling(
throw_solve_exception
,Teuchos::rcp(error_out,false)
);
solver.set_console_out(Teuchos::rcp(console_out,false));
solver.set_summary_out(Teuchos::rcp(summary_out,false));
solver.set_journal_out(Teuchos::rcp(journal_out,false));
solver.set_algo_out( Teuchos::rcp(algo_out,false) );
// Run MOOCHO using the MamaJama configuration
solve_return = solver.solve_nlp();
return solve_return;
}