自学教程：C++ vals函数代码示例

intmain (void) {   IloEnv env;   try {      IloModel model(env);      IloNumVarArray var(env);      IloRangeArray con(env);      populatebyrow (model, var, con);      IloCplex cplex(model);      IloNumVarArray ordvar(env, 2);      IloNumArray    ordpri(env, 2);      ordvar[0] = var[1]; ordvar[1] = var[3];      ordpri[0] = 8.0;    ordpri[1] = 7.0;      cplex.setPriorities (ordvar, ordpri);      cplex.setDirection(var[1], IloCplex::BranchUp);      cplex.setDirection(var[3], IloCplex::BranchDown);      cplex.solve();      env.out() << "Solution status = " << cplex.getStatus() << endl;      env.out() << "Solution value  = " << cplex.getObjValue() << endl;      IloNumArray vals(env);      cplex.getValues(vals, var);      env.out() << "Values        = " << vals << endl;      cplex.getSlacks(vals, con);      env.out() << "Slacks        = " << vals << endl;      cplex.exportModel("mipex3.lp");      cplex.writeOrder("mipex3.ord");   }   catch (IloException& e) {      cerr << "Concert exception caught: " << e << endl;   }   catch (...) {      cerr << "Unknown exception caught" << endl;   }   env.end();   return 0;}  // END main

intmain (int argc, char **argv){    IloEnv   env;    try {        IloModel model(env);        IloCplex cplex(env);        if ( argc != 2 ) {            usage (argv[0]);            throw(-1);        }        IloObjective   obj;        IloNumVarArray var(env);        IloRangeArray  rng(env);        IloSOS1Array   sos1(env);        IloSOS2Array   sos2(env);        cplex.importModel(model, argv[1], obj, var, rng, sos1, sos2);        cplex.use(SOSbranch(env, sos1));        cplex.setParam(IloCplex::Param::MIP::Strategy::Search,                       IloCplex::Traditional);        cplex.extract(model);        cplex.solve();        IloNumArray vals(env);        cplex.getValues(vals, var);        env.out() << "Solution status = " << cplex.getStatus() << endl;        env.out() << "Solution value  = " << cplex.getObjValue() << endl;        env.out() << "Values          = " << vals << endl;    }    catch (IloException& e) {        cerr << "Concert exception caught: " << e << endl;    }    catch (...) {        cerr << "Unknown exception caught" << endl;    }    env.end();    return 0;}  // END main

auto parse( int argc_, char** argv_, Option option_, Options ... options_ ){    auto parser = make_parser(      [=]( std::string token_, char delimiter_, auto triggered_action_, auto silent_action_, auto tag_, auto integer_ )                                     {                                        for ( int index = 1; index != argc_; ++index )                                            if ( 0 == strcmp( argv_[index], token_.c_str() ) )                                            {                                                if ( index+1 == argc_ ) return 1;                                                std::string str_{ argv_[index+1] };                                                if ( integer_.value-1 != std::count( str_.begin(), str_.end(), delimiter_ ) ) return 1;                                                for( auto& ch : str_ ) ch = ( ch == delimiter_ ) ? ' ' : ch;                                                std::istringstream iss{ str_ };                                                typedef typename decltype(tag_)::value_type value_type;                                                std::vector<value_type> vals( integer_.value, 0.0 );                                                std::copy( std::istream_iterator<value_type>( iss ), std::istream_iterator<value_type>(), vals.begin() );                                                if ( iss.bad() ) return 1;                                                triggered_action_( vals.data() );                                                return 0;                                            }                                        silent_action_();                                        return 0;                                    },                                    [=]( std::string token_, auto triggered_action_, auto silent_action_, auto tag_ )                                    {                                        for ( int index = 1; index != argc_; ++index )                                            if ( 0 == strcmp( argv_[index], token_.c_str() ) )                                            {                                                typedef typename decltype(tag_)::value_type value_type;                                                if ( index+1 == argc_ ) return 1;                                                value_type val;                                                std::istringstream iss{ std::string{ argv_[index+1] } };                                                iss >> val;                                                if ( iss.bad() ) return 1;                                                triggered_action_( val );                                                return 0;                                            }                                        silent_action_();                                        return 0;                                    },

intmain (int argc, char **argv){   IloEnv env;   try {      IloModel model(env, "example");      IloNumVarArray var(env);      IloRangeArray  rng(env);      populatebycolumn (model, var, rng);      IloCplex cplex(model);      cplex.setOut(env.getNullStream());      cplex.setParam(IloCplex::Param::RootAlgorithm, IloCplex::Primal);      cplex.use(MyCallback(env));      cplex.solve();      env.out() << "Solution status = " << cplex.getStatus() << endl;      env.out() << "Solution value  = " << cplex.getObjValue() << endl;      IloNumArray vals(env);      cplex.getValues(vals, var);      env.out() << "Values        = " << vals << endl;      cplex.getSlacks(vals, rng);      env.out() << "Slacks        = " << vals << endl;      cplex.getDuals(vals, rng);      env.out() << "Duals         = " << vals << endl;      cplex.getReducedCosts(vals, var);      env.out() << "Reduced Costs = " << vals << endl;      cplex.exportModel("lpex4.lp");   }   catch (IloException& e) {      cerr << "Concert exception caught: " << e << endl;   }   catch (...) {      cerr << "Unknown exception caught" << endl;   }   env.end();   return 0;}  // END main

int main(int argc, char** argv) {	cuInit(0);	DevicePtr device;	CUresult result = CreateCuDevice(0, &device);	ContextPtr context;	result = CreateCuContext(device, 0, &context);	scanEngine_t engine;	scanStatus_t status = scanCreateEngine(		"../../src/mgpuscan/globalscan.cubin", &engine);	int count = 1<< 19;	std::vector<int> vals(count);	std::tr1::uniform_int<int> r(0, 15);	for(int i(0); i < count; ++i)		vals[i] = r(mt19937);	DeviceMemPtr deviceMem;	result = context->MemAlloc(vals, &deviceMem);	uint scanTotal;	status = scanArray(engine, deviceMem->Handle(), count, &scanTotal, false);	std::vector<int> deviceScan;	deviceMem->ToHost(deviceScan);	std::vector<int> hostScan(count);	for(int i(1); i < count; ++i) {		hostScan[i] = hostScan[i - 1] + vals[i - 1];			}	scanDestroyEngine(engine);	bool success = hostScan == deviceScan;	if(success) printf("Global scan success./n");	else printf("Global scan failure./n");	return 0;}

bool CPlexSolver::solve() {	IloCplex cplex(model);	cplex.setParam(IloCplex::MIPEmphasis, CPX_MIPEMPHASIS_FEASIBILITY);		if (cplex.solve()) {		IloNumArray vals(env);		cplex.getValues(vals, vars);				// Populate solutionVectors from vals		SolutionVector solution(vals.getSize());		for (int i = 0; i < vals.getSize(); i++) {			// IloNumArray does not have iterators, so we do it the hard way			solution[i] = vals[i];		}		solutionVectors.push_back(solution);				return true;	} else {		return false;	}}

int main (void) {  IloEnv env;  try {      IloModel model(env); // declaration du nodel      IloNumVarArray var(env); // liste des variables de decision      IloRangeArray con(env); // liste des contraintes a ajouter a notre probleme      IloNumVarArray duals(env);      populatebyrow (model, var, con); // remplir les variables avec les valeurs adequat      IloCplex cplex(model);      cplex.solve();      env.out() << "Solution status = " << cplex.getStatus() << endl;      env.out() << "Solution value  = " << cplex.getObjValue() << endl;      IloNumArray vals(env);      cplex.getValues(vals, var);      env.out() << "Values = " << vals << endl;      cplex.getSlacks(vals, con);      env.out() << "Slacks = " << vals << endl;            model.add(var[0] == 0);      cplex.solve();      cplex.getValues(vals, var);      env.out() << "Solution status = " << cplex.getStatus() << endl;      env.out() << "Solution value  = " << cplex.getObjValue() << endl;      env.out() << "Values = " << vals << endl;      //cplex.exportModel("pl.lp");    }    catch (IloException& e) {      cerr << "Concert exception caught: " << e << endl;    }    catch (...) {      cerr << "Unknown exception caught" << endl;    }  env.end();  return 0;}

  // Wrapper for elem::HermitianGenDefiniteEig sorts vals ascending  ElemEigenSystem  HermitianGenEigensolver(const TAMatrix &F, const TAMatrix &S){    // Get mats from TA    EMatrix EF = TiledArray::array_to_elem(F, elem::DefaultGrid()); // Fock    EMatrix ES = TiledArray::array_to_elem(S, elem::DefaultGrid()); // Overlap    // Vec and value storage    elem::DistMatrix<double , elem::VR, elem::STAR> vals(elem::DefaultGrid());    EMatrix vecs(elem::DefaultGrid());    // Compute vecs and values    elem::mpi::Barrier(elem::mpi::COMM_WORLD);    // Compute evals evals    sc::Timer tim("Solving HermitianGenEig:");    elem::HermitianGenDefiniteEig(elem::AXBX, elem::LOWER,EF,ES,vals,vecs,                                  elem::ASCENDING);    elem::mpi::Barrier(elem::mpi::COMM_WORLD);    tim.exit("Solving HermitianGenEig:");    return std::make_pair(vals, vecs);  }

void compute_sketch_matrix(sketch_t sketch, const DistMatrixType &A,                           DistMatrixType &result) {    std::vector<size_t> row_idx = sketch.getRowIdx();    std::vector<double> row_val = sketch.getRowValues();    // PI generated by random number gen    size_t sketch_size = row_val.size();    mpi_vector_t cols(sketch_size);    mpi_vector_t rows(sketch_size);    mpi_vector_t vals(sketch_size);    for(size_t i = 0; i < sketch_size; ++i) {        cols.SetElement(i, i);        rows.SetElement(i, row_idx[i]);        vals.SetElement(i, row_val[i]);    }    result = DistMatrixType(result.getnrow(), result.getncol(),                            rows, cols, vals);}

APCHandle::Pair APCArray::MakePacked(ArrayData* arr, bool unserializeObj) {  auto num_elems = arr->size();  auto size = sizeof(APCArray) + sizeof(APCHandle*) * num_elems;  auto p = malloc(size);  auto ret = new (p) APCArray(static_cast<size_t>(num_elems));  try {    size_t i = 0;    for (ArrayIter it(arr); !it.end(); it.next()) {      auto val = APCHandle::Create(it.secondRef(), false,                                   APCHandleLevel::Inner, unserializeObj);      size += val.size;      ret->vals()[i++] = val.handle;    }    assert(i == num_elems);  } catch (...) {    delete ret;    throw;  }  return {ret->getHandle(), size};}

ILOUSERCUTCALLBACK4( CtCallback, IloNumVarArray, vars, int**, graph, int, num_cuts, int, max_deep ) {		if( current_deep > max_deep ){		//cout << "aa " << current_deep << endl;		return;	}		IloNumArray vals(getEnv());	getValues(vals, vars);	IntegerFeasibilityArray feas( getEnv() );	getFeasibilities( feas, vars );	int old_win[vals.getSize()];	memset(old_win, 0, sizeof(old_win));	for(int n=0;  n<num_cuts; n++){		static int cont=0;		int cnt=0;		for( int i = 0; i < 2; ++i ){			IloRange cut( getEnv(), 0, 1 );			if( getCut( vals, vars, CLQ2B, i, feas, cut, graph, old_win ) ){				add(cut);				cnt++;							}			else if( getCut( vals, vars, CLQ2A, i, feas, cut, graph, old_win ) ){				cnt++;				add(cut);			}else{ //se nao encotrar algum corte, sai															}			cut.end();		}		if(n>1 && cnt==0)break;					}	feas.end();	vals.end();}

LinearApproximation LinearApproximation::operator-(const LinearApproximation &t_rhs) const{  if (m_numVars != t_rhs.m_numVars)  {    throw std::runtime_error("Unable to subtract, different number of variables");  }  LinearApproximation retval(m_numVars);  for (const auto & lhsitr : m_values)  {    for (const auto & rhsitr : t_rhs.m_values)    {      std::vector<double> vals(m_numVars, 0);      bool match = true;      for (size_t i = 0; i < m_numVars; ++i)      {        if ( lhsitr[i] != rhsitr[i] )        {          match = false;          break;        } else {          vals[i] = lhsitr[i];        }      }      if (match)      {        double value = lhsitr[m_numVars] - rhsitr[m_numVars];        retval.addVals(vals, value);        break;      }    }  }  return retval;}

static voidsolveanddisplay   (IloEnv env, IloCplex cplex, IloNumVarArray var,                   IloRangeArray con){      // Optimize the problem and obtain solution.      if ( !cplex.solve() ) {         env.error() << "Failed to optimize LP" << endl;         throw(-1);      }      IloNumArray vals(env);      env.out() << "Solution status = " << cplex.getStatus() << endl;      env.out() << "Solution value  = " << cplex.getObjValue() << endl;      cplex.getValues(vals, var);      env.out() << "Values        = " << vals << endl;      cplex.getSlacks(vals, con);      env.out() << "Slacks        = " << vals << endl;      cplex.getDuals(vals, con);      env.out() << "Duals         = " << vals << endl;      cplex.getReducedCosts(vals, var);      env.out() << "Reduced Costs = " << vals << endl;}  // END solveanddisplay

void dlgUser::SetupVarEditor(int var){    if (var >= 0 && varInfo.Count() > 0)    {        wxStringTokenizer vals(varInfo.Item(var));        wxString typ=vals.GetNextToken();        if (typ == wxT("bool"))        {            txtValue->Hide();            chkValue->Show();        }        else        {            chkValue->Hide();            txtValue->Show();            if (typ == wxT("string"))                txtValue->SetValidator(wxTextValidator());            else                txtValue->SetValidator(numericValidator);        }    }}

Field<T> volumeIntegrateFunctionObject::integrate(const word& fieldName,T unsetVal) const{    const GeometricField<T, fvPatchField, volMesh>& fld =        obr_.lookupObject<GeometricField<T, fvPatchField, volMesh> >        (            fieldName        );    Field<T> vals(1, unsetVal);    const fvMesh &mesh=refCast<const fvMesh>(obr_);        vals[0] = (        sum        (            mesh.V()*fld        )    ).value();    forAll(vals,i) {        vals[i]*=factor();    }    if(verbose()) {        Info<< regionString()             << " Integral of " << fieldName << " = "            << vals[0] << "  "             << fld.dimensions()*dimensionSet(0,3,0,0,0,0,0)            << endl;    }    //    Pstream::listCombineGather(vals, isNotEqOp<T>());    //    Pstream::listCombineScatter(vals);    return vals;}

    bool operator() ()    {      bool passed = true;      printf("%s::%s ... ",TOSTRING(isa),name);      fflush(stdout);      /* create key/value vectors with random numbers */      const size_t N = 10000;      std::vector<uint32_t> keys(N);      std::vector<uint32_t> vals(N);      for (size_t i=0; i<N; i++) {	keys[i] = 2*rand();	vals[i] = 2*rand();      }            /* create map */      pmap<uint32_t,uint32_t> map;      map.init(keys,vals);      /* check that all keys are properly mapped */      for (size_t i=0; i<N; i++) {	const uint32_t* val = map.lookup(keys[i]);	passed &= val && (*val == vals[i]);      }      /* check that these keys are not in the map */      for (size_t i=0; i<N; i++) {	passed &= !map.lookup(keys[i]+1);      }      /* output if test passed or not */      if (passed) printf("[passed]/n");      else        printf("[failed]/n");            return passed;    }

voiddft_HardSphereA22_Tpetra_Operator<Scalar,MatrixType>::formA22Matrix(){    if (A22Matrix_ == Teuchos::null) {        A22Matrix_ = rcp(new MAT(getRangeMap(), 1));        A22Matrix_->setObjectLabel("HardSphereA22::A22Matrix");    }    LocalOrdinal numRows = getRangeMap()->getNodeNumElements();    Teuchos::ArrayRCP<const Scalar> vectorValues = densityOnDensityMatrix_->get1dView();    for (LocalOrdinal i=OTLO::zero(); i<numRows; i++) {        GlobalOrdinal row = A22Matrix_->getRowMap()->getGlobalElement(i);        Scalar value = vectorValues[i];        GlobalOrdinal col = row;        Array<GlobalOrdinal> cols(1);        Array<MatScalar> vals(1);        cols[0] = col;        vals[0] = Teuchos::as<MatScalar>(value);        A22Matrix_->insertGlobalValues(row, cols, vals);    }    A22Matrix_->fillComplete();}

 int evalRPN(vector<string> &tokens) {     int top = 0;     vector<int> vals(tokens.size());     for (auto token : tokens) {         if (token == "+") {             vals[top - 2] += vals[top - 1];             --top;         } else if (token == "-") {             vals[top - 2] -= vals[top - 1];             --top;         } else if (token == "*") {             vals[top - 2] *= vals[top - 1];             --top;         } else if (token == "/") {             vals[top - 2] /= vals[top - 1];             --top;         } else {             stringstream ss(token);             ss >> vals[top];             ++top;         }     }     return vals[0]; }

void LoaderDatabaseConnection::write(				const double * values,				unsigned int noOfValues,				const std::string & dataProviderName,				const std::string & placeName,	   			const std::string & referenceTime,			    const std::string & validTimeFrom,			    const std::string & validTimeTo,			    const std::string & valueParameterName,				const std::string & levelParameterName,				float levelFrom,				float levelTo,	   			int dataVersion,			    int confidenceCode){	std::vector<float> vals(values, values + noOfValues);	write(&vals[0], noOfValues,			dataProviderName, placeName,			referenceTime, validTimeFrom, validTimeTo,			valueParameterName,			levelParameterName, levelFrom, levelTo,			dataVersion, confidenceCode);}

inttest_main(int, char*[]){  typedef boost::multi_array<double, 3>::size_type size_type;  boost::array<size_type,3> sizes = { { 3, 3, 3 } };  int strides[] = { 9, 3, 1 };  size_type num_elements = 27;  // Default multi_array constructor  {    boost::multi_array<double, 3> A;  }  // Constructor 1, default storage order and allocator  {    boost::multi_array<double, 3> A(sizes);    check_shape(A, &sizes[0], strides, num_elements);    double* ptr = 0;    boost::multi_array_ref<double,3> B(ptr,sizes);    check_shape(B, &sizes[0], strides, num_elements);        const double* cptr = ptr;    boost::const_multi_array_ref<double,3> C(cptr,sizes);    check_shape(C, &sizes[0], strides, num_elements);  }  // Constructor 1, fortran storage order and user-supplied allocator  {    typedef boost::multi_array<double, 3,      std::allocator<double> >::size_type size_type;    size_type num_elements = 27;    int col_strides[] = { 1, 3, 9 };    boost::multi_array<double, 3,      std::allocator<double> > A(sizes,boost::fortran_storage_order());    check_shape(A, &sizes[0], col_strides, num_elements);    double *ptr=0;    boost::multi_array_ref<double, 3>      B(ptr,sizes,boost::fortran_storage_order());    check_shape(B, &sizes[0], col_strides, num_elements);    const double *cptr=ptr;    boost::const_multi_array_ref<double, 3>      C(cptr,sizes,boost::fortran_storage_order());    check_shape(C, &sizes[0], col_strides, num_elements);  }  // Constructor 2, default storage order and allocator  {    typedef boost::multi_array<double, 3>::size_type size_type;    size_type num_elements = 27;    boost::multi_array<double, 3>::extent_gen extents;    boost::multi_array<double, 3> A(extents[3][3][3]);    check_shape(A, &sizes[0], strides, num_elements);    double *ptr=0;    boost::multi_array_ref<double, 3> B(ptr,extents[3][3][3]);    check_shape(B, &sizes[0], strides, num_elements);    const double *cptr=ptr;    boost::const_multi_array_ref<double, 3> C(cptr,extents[3][3][3]);    check_shape(C, &sizes[0], strides, num_elements);  }  // Copy Constructors  {    typedef boost::multi_array<double, 3>::size_type size_type;    size_type num_elements = 27;    std::vector<double> vals(27, 4.5);    boost::multi_array<double, 3> A(sizes);    A.assign(vals.begin(),vals.end());    boost::multi_array<double, 3> B(A);    check_shape(B, &sizes[0], strides, num_elements);    BOOST_TEST(equal(A, B));    double ptr[27];    boost::multi_array_ref<double, 3> C(ptr,sizes);    A.assign(vals.begin(),vals.end());    boost::multi_array_ref<double, 3> D(C);    check_shape(D, &sizes[0], strides, num_elements);    BOOST_TEST(C.data() == D.data());    const double* cptr = ptr;    boost::const_multi_array_ref<double, 3> E(cptr,sizes);    boost::const_multi_array_ref<double, 3> F(E);    check_shape(F, &sizes[0], strides, num_elements);    BOOST_TEST(E.data() == F.data());  }  // Conversion construction  {    typedef boost::multi_array<double, 3>::size_type size_type;    size_type num_elements = 27;    std::vector<double> vals(27, 4.5);//.........这里部分代码省略.........

intmain (int argc, char **argv){   IloEnv env;   try {      IloModel model(env);      IloCplex cplex(env);      if (( argc != 3 )                             ||          ( strchr ("opdbn", argv[2][0]) == NULL )  ) {         usage (argv[0]);         throw(-1);      }      switch (argv[2][0]) {         case 'o':            cplex.setParam(IloCplex::Param::RootAlgorithm, IloCplex::AutoAlg);            break;         case 'p':            cplex.setParam(IloCplex::Param::RootAlgorithm, IloCplex::Primal);            break;         case 'd':            cplex.setParam(IloCplex::Param::RootAlgorithm, IloCplex::Dual);            break;         case 'b':            cplex.setParam(IloCplex::Param::RootAlgorithm, IloCplex::Barrier);            break;         case 'n':            cplex.setParam(IloCplex::Param::RootAlgorithm, IloCplex::Network);            break;         default:            break;      }      IloObjective   obj;      IloNumVarArray var(env);      IloRangeArray  rng(env);      cplex.importModel(model, argv[1], obj, var, rng);      cplex.extract(model);      if ( !cplex.solve() ) {         env.error() << "Failed to optimize LP" << endl;         throw(-1);      }      IloNumArray vals(env);      cplex.getValues(vals, var);      env.out() << "Solution status = " << cplex.getStatus() << endl;      env.out() << "Solution value  = " << cplex.getObjValue() << endl;      env.out() << "Solution vector = " << vals << endl;   }   catch (IloException& e) {      cerr << "Concert exception caught: " << e << endl;   }   catch (...) {      cerr << "Unknown exception caught" << endl;   }   env.end();   return 0;}  // END main

//.........这里部分代码省略.........			con.add(IloRange(env, 2 * t[i][j], 2 * t[i][j]));			//varCount1 = 0;			for(k=0;k<K;k++)				for(w=0;w<W;w++){					con[conCount].setLinearCoef(var1[i*N*W*K+j*W*K+k*W+w],1.0);					con[conCount].setLinearCoef(var2[i*N*W*K+j*W*K+k*W+w],1.0);				}			conCount++;		}//Adding Demands Constraints to con	cout<<"1st/n";	IloInt z= 0;        for(w=0;w<W;w++){                for(l=0;l<L;l++){                        con.add(IloRange(env, -IloInfinity, 1));                        for(i=0;i<N;i++){                                for(j=0;j<N;j++){                                        for(k=0;k<K;k++){                                                con[conCount].setLinearCoef(var1[i*N*W*K+j*W*K+k*W+w],xijkl_m[l][i][j][k]);						con[conCount].setLinearCoef(var2[i*N*W*K+j*W*K+k*W+w],xijkl_m[l][i][j][k]);                                        }                                }                        }                        conCount++;                }        }	cout<<"2nd/n";	//Adding Wavelength Constraints_1 to con	P = N * (N-1) * K;		for(w=0;w<W;w++){		con.add(IloRange(env, -IloInfinity, 0));		varCount1 = 0;                for(i=0;i<N;i++)                       for(j=0;j<N;j++)                               for(k=0;k<K;k++){					con[conCount].setLinearCoef(var1[i*N*W*K+j*W*K+k*W+w],1.0);					con[conCount].setLinearCoef(var2[i*N*W*K+j*W*K+k*W+w],1.0);                               }		con[conCount].setLinearCoef(var3[w],-P);                conCount++;	}	cout<<"3rd/n";		for(i=0;i<N;i++)                       for(j=0;j<N;j++)                               for(k=0;k<K;k++)					for(w=0;w<W;w++){						con.add(IloRange(env, -IloInfinity, 1));						con[conCount].setLinearCoef(var1[i*N*W*K+j*W*K+k*W+w], 1.0);						con[conCount++].setLinearCoef(var2[i*N*W*K+j*W*K+k*W+w], 1.0);											}	varCount3 = 0;	for(w=0;w<W;w++){                con.add(IloRange(env, 0, IloInfinity));                con[conCount].setLinearCoef(W_max, 1.0);                con[conCount++].setLinearCoef(var3[w], -1.0 * (w+1));        }	cout<<"after constraints/n";		//model.add(obj);			//add objective function into model        model.add(IloMinimize(env,obj));	model.add(con);			//add constraints into model        IloCplex cplex(model);			//create a cplex object and extract the 					//model to this cplex object        // Optimize the problem and obtain solution.        if ( !cplex.solve() ) {           env.error() << "Failed to optimize LP" << endl;           throw(-1);        }        IloNumArray vals(env);		//declare an array to store the outputs				 //if 2 dimensional: IloNumArray2 vals(env);        env.out() << "Solution status = " << cplex.getStatus() << endl;		//return the status: Feasible/Optimal/Infeasible/Unbounded/Error/…        env.out() << "Solution value  = " << cplex.getObjValue() << endl; 		//return the optimal value for objective function	cplex.getValues(vals, var1);                    //get the variable outputs        env.out() << "Values Var1        = " <<  vals << endl;  //env.out() : output stream        cplex.getValues(vals, var3);        env.out() << "Values Val3        = " <<  vals << endl;     }     catch (IloException& e) {        cerr << "Concert exception caught: " << e << endl;     }     catch (...) {        cerr << "Unknown exception caught" << endl;     }       env.end();				//close the CPLEX environment     return 0;  }  // END main

void FactorAdditionOp::execute(){	if (_generalFactors.size() == 2) {		if (_intendedStorageType == EVAL) {			_generalTarget->setStorageType(EVAL);			return;		} else if (_intendedStorageType == SPARSE) {			/* TODO: test this */#if 0			vector<int> vars = _generalTarget->getOrderedVars();			drwnSparseFactor *fac1 = _A->getSparseFactor();			drwnSparseFactor *fac2 = _B->getSparseFactor();			drwnSparseFactor *target = _generalTarget->getSparseFactor();			map<vector<int>, double> assignmtsA = fac1->getAssignments();			map<vector<int>, double> assignmtsB = fac2->getAssignments();			for (map< vector<int>, double >::iterator mi = assignmtsA.begin();					mi != assignmtsA.end(); mi++) {				vector<int> vals(vars.size());				for (int i = 0; i < vars.size(); i++) {					vals[_targetToA[i]] = (*mi).first[_targetToA[i]];				}				drwnPartialAssignment dpa;				target->setValueOf(dpa, (*mi).second);			}			for (map< vector<int>, double >::iterator mi = assignmtsB.begin();					mi != assignmtsA.end(); mi++) {				vector<int> vals(vars.size());				for (int i = 0; i < vars.size(); i++) {					vals[_targetToB[i]] = (*mi).first[_targetToB[i]];				}				drwnPartialAssignment dpa;				target->setValueOf(dpa, target->getValueOf(dpa) + (*mi).second);			}#endif			return;		}		/* dealing with dense factors */		drwnTableFactor *target = _generalTarget->getTableFactor();		drwnFactorAdditionOp dfao(target, _generalFactors[0]->getTableFactor(),				_generalFactors[1]->getTableFactor());		dfao.execute();		_generalTarget = new drwnGeneralFactor(*target, _generalTarget->THRESHOLD);		return;	}	drwnGeneralFactor *prevSum = _generalFactors.front()->clone();	for (int fi = 1; fi < _generalFactors.size(); fi++) {		drwnTableFactor tf(_generalTarget->getUniverse());		drwnGeneralFactor *partSum = (fi == (_generalFactors.size() - 1)) ?				_generalTarget :				new drwnGeneralFactor(tf, _generalTarget->THRESHOLD);		FactorAdditionOp fao(partSum, prevSum, _generalFactors[fi]);		fao.execute();		prevSum = partSum;	}}

void ClusterProperties::performTask( const unsigned& task_index, const unsigned& current, MultiValue& myvals ) const {  std::vector<double> vals( myvals.getNumberOfValues() ); getPropertiesOfNode( current, vals );  if( !doNotCalculateDerivatives() ) getNodePropertyDerivatives( current, myvals );  for(unsigned k=0; k<vals.size(); ++k) myvals.setValue( k, vals[k] );}

//.........这里部分代码省略.........        case TYPE_SINT64:        case TYPE_SFIXED64: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedInt64(message, field_desc, index[i], GET_int64(values, i));            }            break;        }        case TYPE_UINT32:        case TYPE_FIXED32: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedUInt32(message, field_desc, GET_int(index, i),                                       GET_uint32(values, i));            }            break;        }        case TYPE_UINT64:        case TYPE_FIXED64: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedUInt64(message, field_desc, index[i], GET_uint64(values, i));            }            break;        }        case TYPE_DOUBLE: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedDouble(message, field_desc, index[i], GET_double(values, i));            }            break;        }        case TYPE_FLOAT: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedFloat(message, field_desc, index[i], GET_float(values, i));            }            break;        }        case TYPE_BOOL: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedBool(message, field_desc, index[i], GET_bool(values, i));            }            break;        }        case TYPE_STRING: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedString(message, field_desc, index[i], GET_stdstring(values, i));            }            break;        }        case TYPE_BYTES: {            for (int i = 0; i < n; i++) {                ref->SetRepeatedString(message, field_desc, index[i], GET_bytes(values, i));            }            break;        }        case TYPE_ENUM: {            CHECK_values_for_enum(field_desc, values);            const GPB::EnumDescriptor* enum_desc = field_desc->enum_type();            switch (TYPEOF(values)) {                case INTSXP:                case REALSXP:                case LGLSXP:                case RAWSXP: {                    for (int i = 0; i < n; i++) {                        int val = GET_int(values, i);                        ref->SetRepeatedEnum(message, field_desc, i,                                             enum_desc->FindValueByNumber(val));                    }                    break;                }                case STRSXP: {                    Rcpp::CharacterVector vals(values);                    std::string val;                    for (int i = 0; i < n; i++) {                        val = vals[i];                        const GPB::EnumValueDescriptor* evd = enum_desc->FindValueByName(val);                        ref->SetRepeatedEnum(message, field_desc, i, evd);                    }                    break;                }                default:                    throw std::range_error("impossible to convert to a enum");            }	    break;        }        case TYPE_MESSAGE:        case TYPE_GROUP: {            CHECK_messages(field_desc, values);            Rcpp::List vals(values);            for (int i = 0; i < n; i++) {                GPB::Message* mess = GET_MESSAGE_POINTER_FROM_S4(vals[i]);                ref->MutableRepeatedMessage(message, field_desc, i)->CopyFrom(*mess);            }            break;        }        default:            throw std::range_error("unknown type");    }}

intmain(int argc){	IloEnv   env;	try {		IloModel model(env);		NumVarMatrix varOutput(env, J + current);		NumVar3Matrix varHelp(env, J + current);		Range3Matrix cons(env, J + current);		for (int j = 0; j <J + current; j++){			varOutput[j] = IloNumVarArray(env, K);			varHelp[j] = NumVarMatrix(env, K);			cons[j] = RangeMatrix(env, K);			for (int k = 0; k < K; k++){				varOutput[j][k] = IloNumVar(env, 0.0, IloInfinity);				varHelp[j][k] = IloNumVarArray(env, L);				cons[j][k] = IloRangeArray(env, C);				for (int l = 0; l < L; l++){					varHelp[j][k][l] = IloNumVar(env, 0.0, IloInfinity);				}				if (j > current){					cons[j][k][0] = IloRange(env, 0.0, 0.0);//will be used to express equality of varOutput, constraint (0)					cons[j][k][1] = IloRange(env, 0.0, IloInfinity);// constraint (1)					cons[j][k][2] = IloRange(env, -IloInfinity, T[j] - Tdc - Tblow[j] - Tslack);// constraint (2)					cons[j][k][3] = IloRange(env, Tfd[k], Tfd[k]);// constraint (3)					cons[j][k][4] = IloRange(env, 0.0, IloInfinity);// constraint (4)					cons[j][k][5] = IloRange(env, Tdf[k], IloInfinity);// constraint (5)					cons[j][k][6] = IloRange(env, T[j - a[k]] + Tcd, T[j - a[k]] + Tcd);// constraint (6)					cons[j][k][7] = IloRange(env, TlossD[k], IloInfinity);// constraint (7)					cons[j][k][8] = IloRange(env, TlossF[k], IloInfinity);// constraint (8)				}			}		}		populatebynonzero(model, varOutput, varHelp, cons);		IloCplex cplex(model);		// Optimize the problem and obtain solution.		if (!cplex.solve()) {			env.error() << "Failed to optimize LP" << endl;			throw(-1);		}		IloNumArray vals(env);		IloNumVar val(env);		//vars to save output		double TimeAvailable[J][K];		double TimeInstances[J][K][L];		double LK103[J][2];		env.out() << "Solution status = " << cplex.getStatus() << endl;		env.out() << "Solution value  = " << cplex.getObjValue() << endl;		for (int j = current; j < current + J; ++j)		{			cplex.getValues(vals, varOutput[j]);			env.out() << "Seconds for load "<<j<<"       = " << vals << endl;			/*for (int k = 0; k < K; k++){				TimeAvailable[j][k] = cplex.getValue(varOutput[j][k]);			}*/		}		for (int j = current; j < current + J; j++){			for (int k = 0; k < K; k++){				cplex.getValues(vals, varHelp[j][k]);				env.out() << "Time instances for spoon "<<k<<" in load "<<j<<" = " << vals << endl;				/*for (int l = 0; l < L; l++){					TimeInstances[j][k][l] = cplex.getValue(varHelp[j][k][l]);				}*/			}		}		for (int j = current + 2; j < J + current; j++){			LK103[j][0] = TimeInstances[j - 2][0][0];			LK103[j][1] = TimeInstances[j][0][5];			env.out() << "LK103, load " << j << " : " << LK103[j][1]-LK103[j][0] << endl;		}		/*cplex.getSlacks(vals, cons);		env.out() << "Slacks        = " << vals << endl;		cplex.getDuals(vals, cons);		env.out() << "Duals         = " << vals << endl;		cplex.getReducedCosts(vals, varOutput);		env.out() << "Reduced Costs = " << vals << endl;*/		cplex.exportModel("lpex1.lp");	}	catch (IloException& e) {		cerr << "Concert exception caught: " << e << endl;	}	catch (...) {		cerr << "Unknown exception caught" << endl;	}	env.end();	cin.get();	return 0;//.........这里部分代码省略.........

  int HGRAD_TET_C2_FEM_Test01(const bool verbose) {    Teuchos::RCP<std::ostream> outStream;    Teuchos::oblackholestream bhs; // outputs nothing    if (verbose)      outStream = Teuchos::rcp(&std::cout, false);    else      outStream = Teuchos::rcp(&bhs,       false);    Teuchos::oblackholestream oldFormatState;    oldFormatState.copyfmt(std::cout);    typedef typename      Kokkos::Impl::is_space<DeviceSpaceType>::host_mirror_space::execution_space HostSpaceType ;    *outStream << "DeviceSpace::  "; DeviceSpaceType::print_configuration(*outStream, false);    *outStream << "HostSpace::    ";   HostSpaceType::print_configuration(*outStream, false);    *outStream    << "/n"    << "===============================================================================/n"    << "|                                                                             |/n"    << "|                 Unit Test (Basis_HGRAD_TET_C2_FEM)                          |/n"    << "|                                                                             |/n"    << "|     1) Conversion of Dof tags into Dof ordinals and back                    |/n"    << "|     2) Basis values for VALUE, GRAD, and Dk operators                       |/n"    << "|                                                                             |/n"    << "|  Questions? Contact  Pavel Bochev  ([email
C++ value1函数代码示例
C++ valloc函数代码示例