C++ odeint禁止负值

我有一个程序，用“odeint”模拟人口动态。我想设置一个if条件，以禁止我的ode结果为负。以下是我的代码摘要：

class Communities
{
    public :
    typedef boost::array< double , 22 > state_type;

    Communities(...);
    ~Communities();  

    void operator()(state_type &x , state_type &dxdt , double t);
    void operator()(state_type &x , const double t );
    void integration(par::Params parParam);

    private:
    ...
};

void Communities :: operator ()( state_type &x , state_type &dxdt , double t )
{
    for (int i=0; i<nb ; ++i)
    { 
        dxdt[i] = ...
    }
    for (int j=0; j<g ; ++j)
    { 
        dxdt[j] += ...
    }

    for (int k=0; k<nb+g ; ++k)
    { 
        if (x[k] <0)
        {
            x[k] = 0;
        }
    }
 }

类社区
{
公众：
typedef boost：：数组状态类型；
社区（……）；
~Communities（）；
void操作符（）；
void运算符（）（state_type&x，const double t）；
无效积分（par:：Params PARPARPARAM）；
私人：
...
};
void Communities:：operator（）（state_type&x，state_type&dxdt，双t）
{
对于（int i=0；iYes），这个循环是无用的，因为它与求解常微分方程无关。常微分方程是
dx/dt=f（x，t）
，通过计算
f（x）来数值求解常微分方程
并通过数值方法更新
x
。循环会中断此算法。具体而言，odeint假设
x
是一个输入参数

您需要的是一个特殊的集成例程。您可以查看一下
integrade\u adaptive
的实现并在那里介绍您的外观。
integrade\u adaptive
的代码基本上是

template< typename Stepper , typename System , typename State , typename Time , typename Obs >
void integrate_adaptive( Stepper stepper , System system , State &x , Time &start_time , Time end_time , Time dt , Obs obs )
{
    const size_t max_attempts = 1000;
    size_t count = 0;
    while( ( start_time + dt ) < end_time )
    {
        obs( start_state , start_time );
        if( ( start_time + dt ) > end_time  )
        {
            dt = end_time - start_time;
        }

        size_t trials = 0;
        controlled_step_result res = success;
        do
        {
            res = st.try_step( system , start_state , start_time , dt );
            ++trials;
        }
        while( ( res == fail ) && ( trials < max_attempts ) );
        if( trials == max_attempts ) throw std::overflow_error( "error" );
    }
    obs( start_state , start_time );
}

template
void integrate_adaptive（步进式步进机、系统、状态和x、时间和开始时间、时间结束时间、时间dt、Obs Obs）
{
常量大小\u t最大尝试次数=1000；
大小\u t计数=0；
而（（开始时间+dt）<结束时间）
{
obs（启动状态、启动时间）；
如果（（开始时间+dt）>结束时间）
{
dt=结束时间-开始时间；
}
大小试验=0；
受控步骤结果res=成功；
做
{
res=st.try\u步骤（系统，启动状态，启动时间，dt）；
++审判；
}
而（（res==失败）和（&（试验<最大尝试次数））；
如果（试验==最大尝试次数）抛出std:：overflow_错误（“错误”）；
}
obs（启动状态、启动时间）；
}

你可以在最大尝试次数的条件之后直接引入你的循环。
哼哼……奇怪的是，我的integrate\u adaptive不一样（见问题中），而且x不是declare，所以我不能使用这个循环。当然，它是integrate\u adaptive的精简版本。当然，你可以使用这两个。任何“start\u state”都应该使用“x”
    for (int k=0; k<nb+g ; ++k)
    { 
        if (x[k] <0)
        {
            x[k] = 0;
        }
    }

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 , controlled_stepper_tag
)
{
typename odeint::unwrap_reference< Observer >::type &obs = observer;
typename odeint::unwrap_reference< Stepper >::type &st = stepper;

const size_t max_attempts = 1000;
const char *error_string = "Integrate adaptive : Maximal number of iterations reached. A step size could not be found.";
size_t count = 0;
while( less_with_sign( start_time , end_time , dt ) )
{
    obs( start_state , start_time );
    if( less_with_sign( end_time , static_cast<Time>(start_time + dt) , dt ) )
    {
        dt = end_time - start_time;
    }

    size_t trials = 0;
    controlled_step_result res = success;
    do
    {
        res = st.try_step( system , start_state , start_time , dt );
        ++trials;
    }
    while( ( res == fail ) && ( trials < max_attempts ) );
    if( trials == max_attempts ) BOOST_THROW_EXCEPTION( std::overflow_error( error_string ) );

    ++count;
}
obs( start_state , start_time );


return count;
}

template< typename Stepper , typename System , typename State , typename Time , typename Obs >
void integrate_adaptive( Stepper stepper , System system , State &x , Time &start_time , Time end_time , Time dt , Obs obs )
{
    const size_t max_attempts = 1000;
    size_t count = 0;
    while( ( start_time + dt ) < end_time )
    {
        obs( start_state , start_time );
        if( ( start_time + dt ) > end_time  )
        {
            dt = end_time - start_time;
        }

        size_t trials = 0;
        controlled_step_result res = success;
        do
        {
            res = st.try_step( system , start_state , start_time , dt );
            ++trials;
        }
        while( ( res == fail ) && ( trials < max_attempts ) );
        if( trials == max_attempts ) throw std::overflow_error( "error" );
    }
    obs( start_state , start_time );
}