void SharedSurfpackApproxData::
merge_variable_arrays(const RealVector& cv, const IntVector& div,
const RealVector& drv, RealArray& ra)
{
size_t num_cv = cv.length(), num_div = div.length(), num_drv = drv.length(),
num_v = num_cv + num_div + num_drv;
ra.resize(num_v);
if (num_cv) copy_data_partial(cv, ra, 0);
if (num_div) merge_data_partial(div, ra, num_cv);
if (num_drv) copy_data_partial(drv, ra, num_cv+num_div);
}
// convert RealVector to list of floats or numpy array of doubles
bool NRELPythonApplicInterface::
python_convert(const RealVector& src, PyObject** dst)
{
int sz = src.length();
#ifdef DAKOTA_PYTHON_NUMPY
if (userNumpyFlag) {
npy_intp dims[1];
dims[0] = sz;
if (!(*dst = PyArray_SimpleNew(1, dims, PyArray_DOUBLE))) {
Cerr << "Error creating Python numpy array." << std::endl;
return(false);
}
PyArrayObject *pao = (PyArrayObject *) *dst;
for (int i=0; i<sz; ++i)
*(double *)(pao->data + i*(pao->strides[0])) = src[i];
}
else
#endif
{
if (!(*dst = PyList_New(sz))) {
Cerr << "Error creating Python list." << std::endl;
return(false);
}
for (int i=0; i<sz; ++i)
PyList_SetItem(*dst, i, PyFloat_FromDouble(src[i]));
}
return(true);
}
// helper for converting xC, xDI, and xDR to single Python array of all variables
bool PythonInterface::
python_convert(const RealVector& c_src, const IntVector& di_src,
const RealVector& dr_src, PyObject** dst)
{
int c_sz = c_src.length();
int di_sz = di_src.length();
int dr_sz = dr_src.length();
#ifdef DAKOTA_PYTHON_NUMPY
if (userNumpyFlag) {
npy_intp dims[1];
dims[0] = c_sz + di_sz + dr_sz;
if (!(*dst = PyArray_SimpleNew(1, dims, PyArray_DOUBLE))) {
Cerr << "Error creating Python numpy array." << std::endl;
return(false);
}
PyArrayObject *pao = (PyArrayObject *) *dst;
for (int i=0; i<c_sz; ++i)
*(double *)(pao->data + i*(pao->strides[0])) = c_src[i];
for (int i=0; i<di_sz; ++i)
*(double *)(pao->data + (c_sz+i)*(pao->strides[0])) = (double) di_src[i];
for (int i=0; i<dr_sz; ++i)
*(double *)(pao->data + (c_sz+di_sz+i)*(pao->strides[0])) = dr_src[i];
}
else
#endif
{
if (!(*dst = PyList_New(c_sz + di_sz + dr_sz))) {
Cerr << "Error creating Python list." << std::endl;
return(false);
}
for (int i=0; i<c_sz; ++i)
PyList_SetItem(*dst, i, PyFloat_FromDouble(c_src[i]));
for (int i=0; i<di_sz; ++i)
PyList_SetItem(*dst, c_sz + i, PyInt_FromLong((long) di_src[i]));
for (int i=0; i<dr_sz; ++i)
PyList_SetItem(*dst, c_sz + di_sz + i,
PyFloat_FromDouble(dr_src[i]));
}
return(true);
}
void SNLLBase::
snll_initialize_run(OPTPP::NLP0* nlf_objective, OPTPP::NLP* nlp_constraint,
const RealVector& init_pt, bool bound_constr_flag,
const RealVector& lower_bounds,
const RealVector& upper_bounds,
const RealMatrix& lin_ineq_coeffs,
const RealVector& lin_ineq_l_bnds,
const RealVector& lin_ineq_u_bnds,
const RealMatrix& lin_eq_coeffs,
const RealVector& lin_eq_targets,
const RealVector& nln_ineq_l_bnds,
const RealVector& nln_ineq_u_bnds,
const RealVector& nln_eq_targets)
{
// While it is not necessary to pass all of this data through the parameter
// list (it could be accessed with optLSqInstance), it allows different
// behavior between the find optimum on model (with late updating from the
// model) and find optimum on user-functions (no late updating) modes.
// create a ColumnVector x, copy current model variables to it, and then setX
// within opt++. This occurs within the context of the run function so that
// any variable reassignment at the strategy layer (after iterator
// construction) is captured with setX.
RealVector x(init_pt);
nlf_objective->setX(x); // setX accepts a ColumnVector
size_t num_cv = init_pt.length();
// Instantiate bound, linear, and nonlinear constraints and append them to
// constraint_array.
OPTPP::OptppArray<OPTPP::Constraint> constraint_array(0);
// Initialize bound constraints.
// get current model bounds, copy them to ColumnVectors, and then set them
// for bound constrained opt++ methods. This was moved from the constructor
// so that any bounds modifications at the strategy layer (e.g.,
// BranchBndStrategy, SurrBasedOptStrategy) are properly captured.
if (bound_constr_flag) {
OPTPP::Constraint bc
= new OPTPP::BoundConstraint(num_cv, lower_bounds, upper_bounds);
constraint_array.append(bc);
}
size_t num_lin_ineq_con = lin_ineq_l_bnds.length(),
num_lin_eq_con = lin_eq_targets.length(),
num_lin_con = num_lin_ineq_con + num_lin_eq_con,
num_nln_ineq_con = nln_ineq_l_bnds.length(),
num_nln_eq_con = nln_eq_targets.length(),
num_nln_con = num_nln_ineq_con + num_nln_eq_con;
// Initialize linear inequalities
// Assumes that numLinearConstraints = linear_ineqs + linear_eqs
if (num_lin_con) {
if (num_lin_ineq_con){
OPTPP::Constraint li = new OPTPP::LinearInequality(lin_ineq_coeffs,
lin_ineq_l_bnds,
lin_ineq_u_bnds);
constraint_array.append(li);
}
if (num_lin_eq_con) {
OPTPP::Constraint le = new OPTPP::LinearEquation(lin_eq_coeffs,
lin_eq_targets);
constraint_array.append(le);
}
}
if (num_nln_con) {
RealVector augmented_lower_bnds(num_nln_con);
RealVector augmented_upper_bnds(num_nln_con);
// Unlike Dakota, opt++ expects nonlinear equality constraints
// followed by nonlinear inequality constraints.
int i;
if (num_nln_eq_con) {
//RealVector ne_targets(num_nln_eq_con);
for (i=0; i<num_nln_eq_con; i++) {
augmented_lower_bnds(i) = nln_eq_targets[i];
augmented_upper_bnds(i) = nln_eq_targets[i];
}
}
if (num_nln_ineq_con) {
//RealVector ni_lower_bnds, ni_upper_bnds;
for (i=0; i<num_nln_ineq_con; i++) {
augmented_lower_bnds(i+num_nln_eq_con) = nln_ineq_l_bnds[i];
augmented_upper_bnds(i+num_nln_eq_con) = nln_ineq_u_bnds[i];
}
}
OPTPP::Constraint nc = new OPTPP::NonLinearConstraint(nlp_constraint,
augmented_lower_bnds,
augmented_upper_bnds,
num_nln_eq_con,
num_nln_ineq_con);
constraint_array.append(nc);
}
OPTPP::CompoundConstraint* cc
= new OPTPP::CompoundConstraint(constraint_array);
nlf_objective->setConstraints(cc);
// R. Lee/C. Moen: This initial Eval is required in order for bound
// constrained and barrier methods to work properly.
// MSE, 7/23/97: My testing shows no difference with or without this initial
// eval, so comment out for now.
//nlf_objective->eval();
}