C++ Eval_Point::set_mesh_index方法代码示例

//.........这里部分代码省略.........
      const NOMAD::Direction * dir = x[i]->get_direction();
      if ( dir && ( dir->is_mads() || dir->get_type()==NOMAD::MODEL_SEARCH_DIR ) ) {

	// get the x_k's signature:
	signature = x[i]->get_signature();
	if ( !signature )
	  throw NOMAD::Exception ( "Speculative_Search.cpp" , __LINE__ ,
	  "Speculative_Search::search(): could not get the signature" );
      
	xkm1 = *x[i] - *dir;
      
	lk = lkm1 = *x[i]->get_mesh_index();
	NOMAD::Mesh::update ( NOMAD::FULL_SUCCESS , lk );
      
	n           = signature->get_n();
	delta_m_k   = NOMAD::Point ( n );
	delta_m_km1 = NOMAD::Point ( n );
	factor      = NOMAD::Point ( n );

	signature->get_mesh().get_delta_m ( delta_m_k   , lk   );
	signature->get_mesh().get_delta_m ( delta_m_km1 , lkm1 );
      
	// multiplicative factor: takes into account the fact that
	// the direction contains \Delta^m_k:
	try {

	  // factor = delta_m_k / delta_m_km1 :
	  for ( int k = 0 ; k < n ; ++k ) {
	    if ( delta_m_k[k].is_defined()   && delta_m_km1[k].is_defined() &&
		 delta_m_k[k].value() != 0.0 && delta_m_km1[k].value() != 0.0 )
	      factor[k] = delta_m_k[k] / delta_m_km1[k];
	    else
	      factor[k] = 0.0;
	  }
	}
	catch ( NOMAD::Double::Invalid_Value & ) {
	  if ( display_degree == NOMAD::FULL_DISPLAY )
	    out << "could not compute " << _type << " point: stop" << std::endl
		<< NOMAD::close_block ( "end of speculative search" );
	  stop        = true;
	  stop_reason = NOMAD::MESH_PREC_REACHED;
	  return;
	}
      
	if ( lkm1 <= 0 )
	  factor *= NOMAD::Mesh::get_mesh_update_basis();
      
	// speculative search point:
	NOMAD::Direction new_dir ( n , 0.0 , dir->get_type() );
	new_dir.Point::operator = ( factor * *dir );
      
	sk = new NOMAD::Eval_Point;
	sk->set ( n , _p.get_bb_nb_outputs() );
	sk->set_signature  ( signature );
	sk->set_direction  ( &new_dir );
	sk->set_mesh_index ( &lk );
      
	sk->Point::operator = ( xkm1 + new_dir );

	if ( display_degree == NOMAD::FULL_DISPLAY ) {
	  out << "trial point #" << sk->get_tag()
	      << ": ( ";
	  sk->Point::display ( out ," " , 2 , NOMAD::Point::get_display_limit() );
	  out << " )" << std::endl;
	}
      
	// add the new point to the list of search trial points:
	ev_control.add_eval_point ( sk                      ,
				    display_degree          ,
				    _p.get_snap_to_bounds() ,
				    NOMAD::Double()         ,
				    NOMAD::Double()         ,
				    NOMAD::Double()         ,
				    NOMAD::Double()           );
      }
    }
  }
  
  nb_search_pts = ev_control.get_nb_eval_points();
  
  // eval_list_of_points:
  // --------------------
  new_feas_inc = new_infeas_inc = NULL;

  ev_control.eval_list_of_points ( _type                   ,
				   mads.get_true_barrier() ,
				   mads.get_sgte_barrier() ,
				   mads.get_pareto_front() ,
				   stop                    ,
				   stop_reason             ,
				   new_feas_inc            ,
				   new_infeas_inc          ,
				   success                   );

  if ( display_degree == NOMAD::FULL_DISPLAY ) {
    std::ostringstream oss;
    oss << "end of speculative search (" << success << ")";
    out << NOMAD::close_block ( oss.str() ) << std::endl;
  }
}

//.........这里部分代码省略.........
    int                      m          = _p.get_bb_nb_outputs();
    int                      mesh_index = NOMAD::Mesh::get_mesh_index();
    int                      pm1        = p-1;

    // mesh sizes:
    NOMAD::Point delta_m_max(n);
    signature->get_mesh().get_delta_m(delta_m_max , NOMAD::Mesh::get_min_mesh_index());

    NOMAD::Double delta_m_i;
    NOMAD::Point  delta_m;
    if (!_initial_search)
        signature->get_mesh().get_delta_m(delta_m , mesh_index);

    // fixed variables:
    const NOMAD::Point &fixed_variables = signature->get_fixed_variables();

    // bb input types:
    const std::vector<NOMAD::bb_input_type> &bbit = signature->get_input_types();

    // bounds:
    const NOMAD::Point &lb = signature->get_lb();
    const NOMAD::Point &ub = signature->get_ub();

    // pts contains n points of dimension p: each of these points contains
    // p different values for each variable:
    NOMAD::Point **pts = new NOMAD::Point * [n];

    // creation of p search points:
    for (int k = 0 ; k < p ; ++k)
    {

        x = new NOMAD::Eval_Point(n , m);
        x->set_signature(signature);
        x->set_mesh_index(&mesh_index);

        for (i = 0 ; i < n ; ++i)
        {

            if (k==0)
            {
                if (fixed_variables[i].is_defined())
                    pts[i] = new NOMAD::Point(p , fixed_variables[i]);
                else if (bbit[i] == NOMAD::CATEGORICAL)
                {
                    pts[i] = new NOMAD::Point(p , (*ref)[i]);
                }
                else
                {
                    pts[i] = new NOMAD::Point(p);

                    // for the initial mesh: delta_m is not used and there will
                    // be no projection on mesh:
                    if (!_initial_search)
                        delta_m_i = delta_m[i];

                    values_for_var_i(p               ,
                                     delta_m_i       ,
                                     delta_m_max[i]  ,
                                     bbit       [i]  ,
                                     lb         [i]  ,
                                     ub         [i]  ,
                                     *pts       [i]);
                }
            }

            (*x)[i] = (*pts[i])[k];