odeint thrust slows down massively when using nested zip_iterators -

I am creating an analysis tool on the top of odeint and emphasis the tool solves a large number of initial condition problems . I have had success after the OdiNet and Thrill tutorial / demo So far, the systems with which I am working are less than 5 state variables, but now I need to expand the system so that they are able to deal more with it.

As mentioned in the tutorial, there is a small problem that Tupuls can only contain 10 items. This problem can be solved using a nested zip-altreator.

: Excerpt from:

"There is a small difficulty that loud tueplay has a maximum of 10 but this is only a small problem because we zip It can create a zip iterator packed with iterators. So a zip iterator for the top level zip iterator state, a normal iterator for the parameter, and a zip iterator for the derivative. "

< P> I have implemented this solution, and it works, but unfortunately Sector with a significant loss in speed. For the same system (solving a two-variable system, simultaneously solving 8192 preliminary conditions), for more than 5 variable solutions, bus runs in basic, simple but not-extensible seconds:

  Real 0m1.244s user 0m0.798s sys 0m0.356s  

While more complex, but extensible nested solutions seem ~ 2000 times longer!

1. 1. Inside the operator () , where I refer to state variables and derivatives, and

   2. Inside the manufacturer of the factory, special I have included the sections of these sections for each program below. I hope that the for_each command, where I made Zip_iterators and Tuples

   That i'm here I am, because this type of motion loss is devastating! Any help will be very much appreciated.

   Excerpt for "simple" code (non-nested-eaterators)

     /////////////////// Within the /////////////////////////////////////// ICFunctor Operator () / / Variable values ​​of the state are being evaluated by valueTypex = thrust :: get & lt; 0 & gt; (T); // Derivative thrust set: Get & lt; 2 & gt; (T) = 0.5 * a - 1.5 * X; //////////////////////////////////////////////// //////////// for_each statement that creates a zip-altator thrust :: for_each (//// start index emphasis :: make_zip_iterator (thrust :: make_tuple (// state variable boost :: start (X) + 0 * m_n, boost :: start (x) + 1 * m_n, // derivative boost :: start (dxdt) + 0 * m_n, boost :: start (dxdt + 1 * m_n), / / // and index thrust: make_zip_iterator (emphasis :: make_tuple (// state variable boost: start (x) + 1 * m_n, boost :: start (x) + 2 * m_n, // generate derivative :: start (dxdt ) + 1 * m_N, boost :: start (dxdt + 2 * m_N)), ICFu Nctor ());  

   Excerpt for "EXTENSIBLE" code (nested-easter)

     ///////////////// / ///////////////////////////////////////// ICFunctor Operator inside () / / State variable is being set STATE_VARIABLES = 0; // A global constant value_type is defined as X = thrust :: 0 & gt; (Emphasis: get & lt; STATE_VARIABLES & gt; (T)); // derivative const int DERIVATIVES = 1 setting; // defined as a global continuous emphasis: get & lt; 0 & gt; (Thrust: Get & lt; DERIVATIVES & gt; (T)) = 0.5 * A - 1.5 * X; //////////////////////////////////////////////// //////////// for_each statement that creates a zip-altator thrust :: for_each (//// start index emphasis :: create_zip_ititor (emphasis :: make_tuple (// state variable thrust :: make_zip_iterator (Emphasis): Make-Tipple (boost :: start (x) + 0 * m_n, boost :: start (x) + 1 * m_n), // throwing derivatives :: make-aspiratorator (emphasis :: make- Tepe (boost: start (dxdt) + 0 * m_N, boost :: start (dxdt) + 1 * m_N))), //// END index thrust: make_zip_iterator (emphasis :: make_tuple (// state variable Thrust :: make_zip_iterator (thrust :: make_tuple) (increment) Java :: start (x) + 1 * m_n, boost :: start (x) + 2 * m_n), // derivatives thrust :: make_zip_iterator (emphasis :: make_tuple (boost :: start (dxdt) + 1 * m_n , Prompt: Start (dxdt) + 2 * m_N)))), ICFunctor ());