docs: def itoSRI2(f, G, y0, tspan, Imethod=Ikpw, dW=None, I=None):
      """Use the Roessler2010 order 1.0 strong Stochastic Runge-Kutta algorithm
      SRI2 to integrate an Ito equation dy = f(y,t)dt + G(y,t)dW(t)
  
      where y is d-dimensional vector variable, f is a vector-valued function,
      G is a d x m matrix-valued function giving the noise coefficients and
      dW(t) is a vector of m independent Wiener increments.
  
      This algorithm is suitable for Ito systems with an arbitrary noise
      coefficient matrix G (i.e. the noise does not need to be scalar, diagonal,
      or commutative). The algorithm has order 2.0 convergence for the
      deterministic part alone and order 1.0 strong convergence for the complete
      stochastic system.
  
      Args:
        f: A function f(y, t) returning an array of shape (d,)
           Vector-valued function to define the deterministic part of the system
  
        G: The d x m coefficient function G can be given in two different ways:
  
           You can provide a single function G(y, t) that returns an array of
           shape (d, m). In this case the entire matrix G() will be evaluated
           2m+1 times at each time step so complexity grows quadratically with m.
  
           Alternatively you can provide a list of m functions g(y, t) each
           defining one column of G (each returning an array of shape (d,).
           In this case each g will be evaluated 3 times at each time step so
           complexity grows linearly with m. If your system has large m and
           G involves complicated functions, consider using this way.
  
        y0: array of shape (d,) giving the initial state vector y(t==0)
  
        tspan (array): The sequence of time points for which to solve for y.
          These must be equally spaced, e.g. np.arange(0,10,0.005)
          tspan[0] is the intial time corresponding to the initial state y0.
  
        Imethod (callable, optional): which function to use to simulate repeated
          Ito integrals. Here you can choose either sdeint.Ikpw (the default) or
          sdeint.Iwik (which is more accurate but uses a lot of memory in the
          current implementation).
  
        dW: optional array of shape (len(tspan)-1, d). 
        I: optional array of shape (len(tspan)-1, m, m).
          These optional arguments dW and I are for advanced use, if you want to
          use a specific realization of the d independent Wiener processes and
          their multiple integrals at each time step. If not provided, suitable
          values will be generated randomly.
        
      Returns:
        y: array, with shape (len(tspan), len(y0))
           With the initial value y0 in the first row
  
      Raises:
        SDEValueError
  
      See also:
        A. Roessler (2010) Runge-Kutta Methods for the Strong Approximation of
          Solutions of Stochastic Differential Equations
      """
      return _Roessler2010_SRK2(f, G, y0, tspan, Imethod, dW, I)