Вызов другой функции перегрузки

Question

Я направляюсь, чтобы понять odeint от c++ boost библиотеки, и мне нужно знать, какая часть делает что. В boost/numeric/odeint/integrate/integrate_adaptive.hpp есть функция, называемая integrate_adaptive. Эта функция имеет несколько перегрузок. Упрощенный файл с моими нескольких манипуляций заключается в следующем:

integrate_adaptive_minimal.hpp

#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED 

#include <boost/type_traits/is_same.hpp> 

#include <boost/numeric/odeint/stepper/stepper_categories.hpp> 
#include <boost/numeric/odeint/integrate/null_observer.hpp> 
#include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp> 
using namespace std; 
namespace boost { 
namespace numeric { 
namespace odeint { 


/* 
* the two overloads are needed in order to solve the forwarding problem 
*/ 
template< class Stepper , class System , class State , class Time , class Observer > 
size_t integrate_adaptive(
     Stepper stepper , System system , State &start_state , 
     Time start_time , Time end_time , Time dt , 
     Observer observer) 
{ 
    cout<<"type one"<<endl; //added by me *************************************** 
    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; 
    return detail::integrate_adaptive(
      stepper , system , start_state , 
      start_time , end_time , dt , 
      observer , stepper_category()); 
    /* 
    * Suggestion for a new extendable version: 
    * 
    * integrator_adaptive< Stepper , System, State , Time , Observer , typename Stepper::stepper_category > integrator; 
    * return integrator.run(stepper , system , start_state , start_time , end_time , dt , observer); 
    */ 
} 

/** 
* \brief Second version to solve the forwarding problem, 
* can be called with Boost.Range as start_state. 
*/ 
template< class Stepper , class System , class State , class Time , class Observer > 
size_t integrate_adaptive(
     Stepper stepper , System system , const State &start_state , 
     Time start_time , Time end_time , Time dt , 
     Observer observer) 
{ 
    cout<<"type two"<<endl; //added by me *************************************** 
    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; 
    return detail::integrate_adaptive(
      stepper , system , start_state , 
      start_time , end_time , dt , 
      observer , stepper_category()); 
} 


} // namespace odeint 
} // namespace numeric 
} // namespace boost 

Разница между этими двумя функциями связана с параметром start_state. Во второй функции он содержит ключевое слово const. Я хочу знать, какая перегрузка называется. Итак, я добавил cout в каждую функцию. Тогда я называю их из этого тестового файла:

minimal.cpp

#include "integrate_adaptive_minimal.hpp" 
#include <boost/numeric/odeint.hpp> 
#include <armadillo> 

using namespace arma; 
using namespace boost::numeric::odeint; 

typedef vec::fixed<2> state_type; 

void sys(const state_type &x , state_type &dxdt , const double t) 
{ 
    mat A; 
    A<<-1<<0<<endr<<0<<-1; 
    mat B; 
    B<<1<<endr<<1; 

    dxdt=A*x+B*(t>0?1:0); 
} 

void observer(const state_type &x , const double t) 
{ 
} 

typedef runge_kutta_dopri5<state_type> stepper_type; 

int main() 
{ 
    state_type x; 
    x(0) = 0.0; 
    x(1) = 0.0; 
    integrate_adaptive(make_controlled(1E-10,1E-10,stepper_type()), 
         sys,x,0.0,11.0,0.1,observer); 
    return 0; 
} 

Когда я компиляции и запуска:

g++ -std=c++11 minimal.cpp -larmadillo -lboost_thread -lboost_filesystem -lboost_system -Wfatal-errors 

./a.out 

Результат показывает, что первая функция integrate_adaptive называется, которая не имеет const. Теперь, я хочу знать, как правильно выбрать вторую функцию? Объект x не может быть const!

Если кто-то знает о механизме библиотеки boost, говоря мне, что преимущество второй функции оценивается.

Update:

исходный код: github, doc

Answer 1

государство само будет мутировали. Таким образом, передача реального объекта const, который не может быть полностью изменен, не может быть передан для интеграции адаптивной. Перегрузка const здесь для разрешения создания состояния в вызове integrate_adaptive. Как sehe уже упоминалось, можно назвать интеграцию адаптивных как

integrate_adaptive(stepper , system , make_pair(a.begin() , a.begin() + 3) , t0 , t1 , dt , obs); 

Здесь государство диапазон из трех элементов, упакованных в диапазоне. Без второй перегрузки нужно написать

auto r = make_pair(a.begin() , a.begin() + 3); // Without auto the type will be really complicated. 
integrate_adaptive(stepper , system , r , t0 , t1 , dt , obs); 

В предварительно C++ в 11 раз, тип r действительно сложно, что-то вроде pair< vector<double>::iterator , vector<double>::iterator > и вводя вторую перегрузку сильно упрощает. Большинство степлеров do_step имеют аналогичные перегрузки.

Answer 2

Вам нужно только бросить x в const как вы называете integrate_adaptive():

integrate_adaptive(make_controlled(1E-10,1E-10,stepper_type()), 
         sys, const_cast<const state_type &>(x),0.0,11.0,0.1,observer); 

константные версии функции обещает, что он не будет изменять содержимое x во время его действия, но main() может продолжить модификацию нг после integrate_adaptive() возвращается.

(Преимущество использования C++. - стиль const_cast, чтобы поймать себя раньше, если вы когда-нибудь решите изменить тип х в какой-то другой класс)

Answer 3

Честно говоря, я немного запутался о предпосылка вопроса.

integrate_adaptive заканчивается тем, что odeint::copy (from odeint/util/copy.hpp) от controlled_step_result try_step(System, const StateInOut&x, time_type&, time_type&). Документация здесь говорится (в том числе)

• \param системы функции системы, чтобы решить, следовательно, r.h.s. ОДУ. Он должен соответствовать концепции Simple System.
• \param x Состояние ОДУ, которое должно быть разрешено. Перезапись если шаг является успешным. Может быть диапазон повышения.

Я просто не думаю, что вы хотите состояние const. Потому что функция не могла выполнить это обещание, если бы государство было, фактически, const.

Я бы предположил, что существует перегрузка для размещения объектов состояния, представляющих изменчивое состояние, даже когда const. Это кажется странным, но может быть мыслимым с double * const& (в отличие от double const* const&), если хотите.

UPDATE

В документации сказано, для константных перегрузкам:

/* 
* the two overloads are needed in order to solve the forwarding problem 
*/ 

Кроме того, он говорит

/** 
* \brief Second version to solve the forwarding problem, 
* can be called with Boost.Range as start_state. 
*/ 

Таким образом, на самом деле это может быть просто разрешить вызов с boost::make_iterator_range(a,b) где сам объект Boost Range был бы временным (связанным с const&) и итератором аторы все еще изменяемы.

---

Off тему:

В случае, если вы сделал хотите передать его как константы, вот как бы это сделать (конечно, он не компилируется по причинам, указанным выше):

state_type const x { 0, 0 }; 
integrate_adaptive(make_controlled(1E-10, 1E-10, stepper_type()), sys, x, 0.0, 11.0, 0.1/*, observer*/); 

Или даже

integrate_adaptive(make_controlled(1E-10, 1E-10, stepper_type()), sys, 
       state_type { 0.0, 0.0 }, 0.0, 11.0, 0.1/*, observer*/);