MAPM MAPM::operator--()
{
// m_apm_enter();
MAPM ret;
m_apm_subtract_mt(ret.val(),cval(),MM_One);
*this = ret;
// m_apm_leave();
return *this;
}
MAPM MAPM::operator++()
{
// m_apm_enter();
MAPM ret;
m_apm_add_mt(ret.val(),cval(),MM_One);
*this = ret;
// m_apm_leave();
return *this;
}
score() {
int scor, maxsco, obj, i;
scor=maxsco=0;
for(obj=treasr; obj<=objt; ++obj) {
if( place(obj)>0 ) {
maxsco=maxsco+20;
if( place(obj)==3 && prop(obj)==0 ) { /* сокровище b доме */
scor=scor+20;
} else if( (prop(obj)&0377)!=inipro ) { /* сокровище видел */
scor=scor+5;
}
}
}
rspeak(32);
mscore(scor,maxsco);
obj = 1;
for(i=1; i<=plcl; ++i) if( cval(i) && scor>=cval(i) ) obj = i;
mes(ctext(obj));
}
void strget(const char *str,Type& numeric_val,size_t num_chars)
{
std::string cval(str,num_chars);
char *chr=const_cast<char *>(cval.c_str());
trim(cval);
size_t decimal;
num_chars=decimal=cval.length();
numeric_val=0;
int exp=0;
bool neg_val=false,neg_exp=false,reading_exponent=false;
for (size_t n=0; n < num_chars; ++n) {
if (chr[n] == '.') {
numeric_val*=0.1;
decimal=n;
}
else if (chr[n] == 'E') {
reading_exponent=true;
}
else {
if (chr[n] == ' ' || chr[n] == '+' || chr[n] == '-') {
if (chr[n] == '-') {
if (!reading_exponent) {
neg_val=true;
}
else {
neg_exp=true;
}
}
chr[n]='0';
}
if (!reading_exponent) {
numeric_val+=static_cast<Type>((chr[n]-48)*std::pow(10.,num_chars-n-1));
}
else {
exp+=static_cast<int>((chr[n]-48)*std::pow(10.,num_chars-n-1));
}
}
}
if (neg_val) {
numeric_val=-numeric_val;
}
if (decimal != num_chars) {
auto mult=pow(0.1,num_chars-decimal-1);
numeric_val*=static_cast<Type>(mult);
}
if (reading_exponent) {
if (neg_exp) {
exp=-exp;
}
numeric_val*=static_cast<Type>(pow(10.,exp));
}
}
int MAPM::myDigits(void) const
{
int maxd=m_apm_significant_digits_mt(cval());
if (maxd<MM_cpp_min_precision) maxd=MM_cpp_min_precision;
return maxd;
}
MAPM MAPM::integer_divide(const MAPM &denom) const
{
MAPM ret;
m_apm_integer_divide_mt(ret.val(),cval(),denom.cval());
return ret;
}
MAPM MAPM::ipow_nr(int p) const
{
MAPM ret;
m_apm_integer_pow_nr_mt(ret.val(),cval(),p);
return ret;
}
MAPM MAPM::ceil(void) const
{
MAPM ret;
m_apm_ceil_mt(ret.val(),cval());
return ret;
}
MAPM MAPM::lcm(const MAPM &m) const
{
MAPM ret;
m_apm_lcm_mt(ret.val(),cval(),m.cval());
return ret;
}
MAPM MAPM::atan2(const MAPM &x,int toDigits) const
{
MAPM ret;
m_apm_arctan2_mt(ret.val(),toDigits,cval(),x.cval());
return ret;
}
int MAPM::exponent(void) const
{
return m_apm_exponent(cval());
}
int MAPM::sign(void) const
{
return m_apm_sign(cval());
}
MAPM MAPM::divide(const MAPM &m,int toDigits) const
{
MAPM ret;
m_apm_divide_mt(ret.val(),toDigits,cval(),m.cval());
return ret;
}
int MAPM::compare(const MAPM &m) const
{
return m_apm_compare(cval(),m.cval());
}
bool MAPM::operator>=(const MAPM &m) const
{
return m_apm_compare(cval(),m.cval())>=0;
}
void MAPM::sincos(MAPM &sinR,MAPM &cosR,int toDigits)
{
m_apm_sin_cos_mt(sinR.val(),cosR.val(),toDigits,cval());
}
MAPM MAPM::pow(const MAPM &m,int toDigits) const
{
MAPM ret;
m_apm_pow_mt(ret.val(),toDigits,cval(), m.cval());
return ret;
}
int MAPM::significant_digits(void) const
{
return m_apm_significant_digits_mt(cval());
}
MAPM MAPM::gcd(const MAPM &m) const
{
MAPM ret;
m_apm_gcd_mt(ret.val(),cval(),m.cval());
return ret;
}
int MAPM::is_integer(void) const
{
return m_apm_is_integer(cval());
}
MAPM MAPM::floor(void) const
{
MAPM ret;
m_apm_floor_mt(ret.val(),cval());
return ret;
}
int MAPM::is_even(void) const
{
return m_apm_is_even(cval());
}
MAPM MAPM::factorial(void) const
{
MAPM ret;
m_apm_factorial_mt(ret.val(),cval());
return ret;
}
int MAPM::is_odd(void) const
{
return m_apm_is_odd(cval());
}
MAPM MAPM::ipow(int p,int toDigits) const
{
MAPM ret;
m_apm_integer_pow_mt(ret.val(),toDigits,cval(),p);
return ret;
}
MAPM MAPM::abs(void) const
{
MAPM ret;
m_apm_absolute_value(ret.val(),cval());
return ret;
}
void MAPM::integer_div_rem(const MAPM &denom,MAPM ",MAPM &rem) const
{
m_apm_integer_div_rem_mt(quot.val(),rem.val(),cval(),denom.cval());
}
MAPM MAPM::neg(void) const
{
MAPM ret;
m_apm_negate(ret.val(),cval());
return ret;
}
TEST(MiniTensor_ROL, NLLS01)
{
bool const
print_output = ::testing::GTEST_FLAG(print_time);
// outputs nothing
Teuchos::oblackholestream
bhs;
std::ostream &
os = (print_output == true) ? std::cout : bhs;
constexpr Intrepid2::Index
NUM_CONSTR{3};
constexpr Intrepid2::Index
NUM_VAR{5};
using MSEC = Intrepid2::Nonlinear01<Real, NUM_CONSTR>;
MSEC
msec;
ROL::MiniTensor_EqualityConstraint<MSEC, Real, NUM_CONSTR, NUM_VAR>
constr(msec);
Intrepid2::Vector<Real, NUM_VAR>
xval(Intrepid2::ZEROS);
Intrepid2::Vector<Real, NUM_CONSTR>
cval(Intrepid2::ZEROS);
Intrepid2::Vector<Real, NUM_VAR>
solval(Intrepid2::ZEROS);
// Set initial guess.
xval(0) = -1.8;
xval(1) = 1.7;
xval(2) = 1.9;
xval(3) = -0.8;
xval(4) = -0.8;
// Set solution.
solval(0) = -1.717143570394391e+00;
solval(1) = 1.595709690183565e+00;
solval(2) = 1.827245752927178e+00;
solval(3) = -7.636430781841294e-01;
solval(4) = -7.636430781841294e-01;
Real const
error_full_hess{2.3621708067012991e-02};
Real const
error_gn_hess{2.3669791103726853e-02};
Real const
tol{1.0e-08};
ROL::MiniTensorVector<Real, NUM_VAR>
x(xval);
ROL::MiniTensorVector<Real, NUM_CONSTR>
c(cval);
ROL::MiniTensorVector<Real, NUM_VAR>
sol(solval);
Teuchos::RCP<ROL::EqualityConstraint<Real>>
pconstr = Teuchos::rcp(&constr, false);
// Define algorithm.
Teuchos::ParameterList
params;
std::string
step{"Trust Region"};
params.sublist("Step").sublist(step).set("Subproblem Solver", "Truncated CG");
params.sublist("Status Test").set("Gradient Tolerance", 1.0e-10);
params.sublist("Status Test").set("Constraint Tolerance", 1.0e-10);
params.sublist("Status Test").set("Step Tolerance", 1.0e-18);
params.sublist("Status Test").set("Iteration Limit", 128);
ROL::Algorithm<Real>
algo(step, params);
ROL::NonlinearLeastSquaresObjective<Real>
nlls(pconstr, x, c, false);
os << "\nSOLVE USING FULL HESSIAN\n";
algo.run(x, nlls, true, os);
Intrepid2::Vector<Real, NUM_VAR>
xfinal = ROL::MTfromROL<Real, NUM_VAR>(x);
os << "\nfinal x : " << xfinal << "\n";
Real
error = std::abs(Intrepid2::norm(xfinal - solval) - error_full_hess);
os << "\nerror : " << error << "\n";
ASSERT_LE(error, tol);
algo.reset();
x.set(xval);
ROL::NonlinearLeastSquaresObjective<Real>
gnnlls(pconstr, x, c, true);
os << "\nSOLVE USING GAUSS-NEWTON HESSIAN\n";
algo.run(x, gnnlls, true, os);
xfinal = ROL::MTfromROL<Real, NUM_VAR>(x);
os << "\nfinal x : " << xfinal << "\n";
error = std::abs(Intrepid2::norm(xfinal - solval) - error_gn_hess);
os << "\nerror : " << error << "\n";
ASSERT_LE(error, tol);
}
MAPM MAPM::round(int toDigits) const
{
MAPM ret;
m_apm_round_mt(ret.val(),toDigits,cval());
return ret;
}
