From af204720f09162b44d06bf07dfd0d2c657d781bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Anna=20St=C3=B6riko?= <a.storiko@tudelft.nl>
Date: Wed, 24 Apr 2024 19:10:11 +0200
Subject: [PATCH 1/2] Fix example for usage without Pytensor

---
 doc/source/without_pymc.rst | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/doc/source/without_pymc.rst b/doc/source/without_pymc.rst
index 4392cf1..5f74772 100644
--- a/doc/source/without_pymc.rst
+++ b/doc/source/without_pymc.rst
@@ -85,6 +85,8 @@ ODE might look like this::
 After defining states, parameters and right-hand-side function we can create a
 `SympyProblem` instance::
 
+    import sunode
+
     problem = sunode.SympyProblem(
         params=params,
         states=states,
@@ -99,12 +101,13 @@ create a solver for no derivatives or with forward derivatives
 (``sunode.Solver``), or a solver that can compute gradients using
 the adjoint ODE (``sunode.AdjointSolver``).::
 
-    solver = sunode.solver.Solver(problem, compute_sens=False, solver='BDF')
+    solver = sunode.solver.Solver(problem, solver='BDF')
 
 We can use numpy structured arrays as input, so that we don't need to
 think about how the different variables are stored in the array.
 This does not introduce runtime overhead.::
 
+    import numpy as np
     y0 = np.zeros((), dtype=problem.state_dtype)
     y0['hares'] = 1
     y0['lynxes'] = 0.1
@@ -128,4 +131,4 @@ We can convert the solution to an xarray Dataset or access the
 individual states as numpy record array::
 
     solver.as_xarray(tvals, output).solution_hares.plot()
-    plt.plot(output.view(tvals, problem.state_dtype)['hares'])
+    plt.plot(tvals, output.view(problem.state_dtype)['hares'])

From b2d5606c3f8bf6f9bce04816334ac5d6469142f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Anna=20St=C3=B6riko?= <a.storiko@tudelft.nl>
Date: Wed, 24 Apr 2024 19:14:32 +0200
Subject: [PATCH 2/2] Remove old notebooks

---
 ...ysundials-demo-sens-analytical-Copy1.ipynb | 1127 ------------
 .../pysundials-demo-sens-analytical.ipynb     | 1535 -----------------
 2 files changed, 2662 deletions(-)
 delete mode 100644 notebooks/pysundials-demo-sens-analytical-Copy1.ipynb
 delete mode 100644 notebooks/pysundials-demo-sens-analytical.ipynb

diff --git a/notebooks/pysundials-demo-sens-analytical-Copy1.ipynb b/notebooks/pysundials-demo-sens-analytical-Copy1.ipynb
deleted file mode 100644
index 16351a4..0000000
--- a/notebooks/pysundials-demo-sens-analytical-Copy1.ipynb
+++ /dev/null
@@ -1,1127 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import numpy as np\n",
-    "import numba\n",
-    "import numba.cffi_support\n",
-    "import importlib\n",
-    "import sunode\n",
-    "from sunode import lambdify\n",
-    "import sympy as sy\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ndim = 2\n",
-    "nparam = 3\n",
-    "\n",
-    "#p = sy.MatrixSymbol('p', nparam, 1)\n",
-    "#y = sy.MatrixSymbol('y', ndim, 1)\n",
-    "\n",
-    "a, b, c = sy.symarray('p', (3,))\n",
-    "V, R = sy.symarray('y', (2,))\n",
-    "\n",
-    "dV_dt = (V - V**3 / 3 + R) * c\n",
-    "dR_dt = (V - a + b * R) / -c\n",
-    "\n",
-    "dy = sy.Matrix([dV_dt, dR_dt])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import sympy.codegen.rewriting"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def optimize(expr):\n",
-    "    return sympy.codegen.rewriting.optimize(\n",
-    "        expr, sympy.codegen.rewriting.optims_c99)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle \\left[\\begin{matrix}p_{2} \\left(- \\frac{y_{0}^{3}}{3} + y_{0} + y_{1}\\right)\\\\- \\frac{- p_{0} + p_{1} y_{1} + y_{0}}{p_{2}}\\end{matrix}\\right]$"
-      ],
-      "text/plain": [
-       "Matrix([\n",
-       "[p_2*(-y_0**3/3 + y_0 + y_1)],\n",
-       "[-(-p_0 + p_1*y_1 + y_0)/p_2]])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dy = dy.applyfunc(optimize)\n",
-    "dy"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create native function using numba\n",
-    "dy_pre, dy_comp = lambdify.lambdify_consts('_rhs', [], [p, y], dy)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle \\left[\\begin{matrix}\\left(1 - y_{0, 0}^{2}\\right) p_{2, 0} v_{0, 0} + p_{2, 0} v_{1, 0}\\\\- \\frac{p_{1, 0} v_{1, 0}}{p_{2, 0}} - \\frac{v_{0, 0}}{p_{2, 0}}\\end{matrix}\\right]$"
-      ],
-      "text/plain": [
-       "Matrix([\n",
-       "[(1 - y[0, 0]**2)*p[2, 0]*v[0, 0] + p[2, 0]*v[1, 0]],\n",
-       "[        -p[1, 0]*v[1, 0]/p[2, 0] - v[0, 0]/p[2, 0]]])"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "v = sy.MatrixSymbol('v', ndim, 1)\n",
-    "Jv = dy.jacobian(y) * sy.Matrix(v)\n",
-    "Jv = Jv.applyfunc(optimize)\n",
-    "Jv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We also have dy in the matrix-vector product. Can we use it somehow?\n",
-    "Jv_pre, Jv_comp = lambdify.lambdify_consts('_jacobian_prod', [], [p, y, v], Jv)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle \\left[\\begin{matrix}\\left(1 - y_{0, 0}^{2}\\right) p_{2, 0} & p_{2, 0}\\\\- \\frac{1}{p_{2, 0}} & - \\frac{p_{1, 0}}{p_{2, 0}}\\end{matrix}\\right]$"
-      ],
-      "text/plain": [
-       "Matrix([\n",
-       "[(1 - y[0, 0]**2)*p[2, 0],          p[2, 0]],\n",
-       "[              -1/p[2, 0], -p[1, 0]/p[2, 0]]])"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "J = dy.jacobian(y)\n",
-    "J = J.applyfunc(optimize)\n",
-    "J"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "J_pre, J_comp = lambdify.lambdify_consts('_jacobian', [], [p, y], J)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle \\left[\\begin{matrix}0 & 0 & - \\frac{y_{0, 0}^{3}}{3} + y_{0, 0} + y_{1, 0}\\\\\\frac{1}{p_{2, 0}} & - \\frac{y_{1, 0}}{p_{2, 0}} & \\frac{- p_{0, 0} + p_{1, 0} y_{1, 0} + y_{0, 0}}{p_{2, 0}^{2}}\\end{matrix}\\right]$"
-      ],
-      "text/plain": [
-       "Matrix([\n",
-       "[        0,                0,                 -y[0, 0]**3/3 + y[0, 0] + y[1, 0]],\n",
-       "[1/p[2, 0], -y[1, 0]/p[2, 0], (-p[0, 0] + p[1, 0]*y[1, 0] + y[0, 0])/p[2, 0]**2]])"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_dp = dy.jacobian(p)\n",
-    "df_dp = df_dp.applyfunc(optimize)\n",
-    "df_dp"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df_dp_pre, df_dp_comp = lambdify.lambdify_consts('_df_dp', [], [p, y], df_dp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "([1., 1., 1.],)"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "user_dtype = np.dtype([('p', (np.float64, (nparam,)))], align=True)\n",
-    "user_ndtype = numba.from_dtype(user_dtype)\n",
-    "user_ndtype\n",
-    "\n",
-    "user_ndtype_p = numba.types.CPointer(user_ndtype)\n",
-    "user_data = np.zeros((1,), dtype=user_dtype)[0]\n",
-    "user_data['p'] = 1\n",
-    "user_data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@numba.njit()\n",
-    "def rhs(t, y, out, user_data):\n",
-    "    p = user_data.p.reshape(-1, 1)\n",
-    "    # TODO The optimizer doesn't seem to be able\n",
-    "    # to optimize the malloc away. We could\n",
-    "    # extend lambdify to take an out argument.\n",
-    "    out[:] = dy_comp((), p, y.reshape(-1, 1))[:, 0]\n",
-    "    return 0\n",
-    "\n",
-    "@numba.njit\n",
-    "def jacobian_prod(t, v, y, fy, out, user_data):\n",
-    "    p = user_data.p\n",
-    "    out[:] = Jv_comp(\n",
-    "        (),\n",
-    "        p.reshape((-1, 1)),\n",
-    "        y.reshape((-1, 1)),\n",
-    "        v.reshape((-1, 1))\n",
-    "    )[:, 0]\n",
-    "    return 0\n",
-    "\n",
-    "@numba.njit\n",
-    "def jacobian(t, y, fy, out, user_data):\n",
-    "    p = user_data.p\n",
-    "    out[:, :] = J_comp((), p.reshape((-1, 1)), y.reshape((-1, 1)))\n",
-    "    return 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ffi = sunode._cvodes.ffi\n",
-    "lib = sunode._cvodes.lib"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "numba.cffi_support.register_module(sunode._cvodes)\n",
-    "numba.cffi_support.register_type(\n",
-    "    ffi.typeof('N_Vector').item,\n",
-    "    numba.types.Opaque('N_Vector'))\n",
-    "numba.cffi_support.register_type(\n",
-    "    ffi.typeof('SUNMatrix').item,\n",
-    "    numba.types.Opaque('SUNMatrix'))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ndim = 2\n",
-    "y0 = sunode.empty_vector(ndim)\n",
-    "y0.data[:] = 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "abstol = sunode.empty_vector(ndim)\n",
-    "abstol.data[:] = [1e-8, 1e-8]\n",
-    "reltol = 1e-8"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 72,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#ode = lib.CVodeCreate(lib.CV_BDF)\n",
-    "ode = lib.CVodeCreate(lib.CV_ADAMS)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 73,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "user_data_p = ffi.cast('void *', ffi.addressof(ffi.from_buffer(user_data.data)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 74,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "N_VGetArrayPointer_Serial = lib.N_VGetArrayPointer_Serial\n",
-    "\n",
-    "func_type = numba.cffi_support.map_type(ffi.typeof('CVRhsFn'))\n",
-    "func_type = func_type.return_type(*(func_type.args[:-1] + (user_ndtype_p,)))\n",
-    "func_type\n",
-    "\n",
-    "@numba.cfunc(func_type)\n",
-    "def rhs_wrapper(t, y_, out_, user_data_):\n",
-    "    y_ptr = N_VGetArrayPointer_Serial(y_)\n",
-    "    out_ptr = N_VGetArrayPointer_Serial(out_)\n",
-    "    y = numba.carray(y_ptr, (ndim,))\n",
-    "    out = numba.carray(out_ptr, (ndim,))\n",
-    "    user_data = numba.carray(user_data_, (1,))[0]\n",
-    "    p = user_data.p\n",
-    "    \n",
-    "    return rhs(t, y, out, user_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 75,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "SUNDenseMatrix_Data = lib.SUNDenseMatrix_Data\n",
-    "\n",
-    "func_type = numba.cffi_support.map_type(ffi.typeof('CVLsJacFn'))\n",
-    "args = list(func_type.args)\n",
-    "args[4] = user_ndtype_p\n",
-    "func_type = func_type.return_type(*args)\n",
-    "func_type\n",
-    "\n",
-    "@numba.cfunc(func_type)\n",
-    "def Jac(t, y_, fy_, out_, user_data_, tmp1_, tmp2_, tmp3_):\n",
-    "    y_ptr = N_VGetArrayPointer_Serial(y_)\n",
-    "    out_ptr = SUNDenseMatrix_Data(out_)\n",
-    "    fy_ptr = N_VGetArrayPointer_Serial(fy_)\n",
-    "    y = numba.carray(y_ptr, (ndim,))\n",
-    "    out = numba.farray(out_ptr, (ndim, ndim))\n",
-    "    fy = numba.carray(fy_ptr, (ndim,))\n",
-    "    user_data = numba.carray(user_data_, (1,))[0]\n",
-    "    p = user_data.p\n",
-    "    \n",
-    "    return jacobian(t, y, fy, out, user_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 76,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Not used\n",
-    "SUNDenseMatrix_Data = lib.SUNDenseMatrix_Data\n",
-    "\n",
-    "func_type = numba.cffi_support.map_type(ffi.typeof('CVLsJacTimesVecFn'))\n",
-    "args = list(func_type.args)\n",
-    "args[-2] = user_ndtype_p\n",
-    "func_type = func_type.return_type(*args)\n",
-    "func_type\n",
-    "\n",
-    "@numba.cfunc(func_type)\n",
-    "def jac_prod_wrapper(v_, out_, t, y_, fy_, user_data_, tmp_):\n",
-    "    v_ptr = N_VGetArrayPointer_Serial(v_)\n",
-    "    y_ptr = N_VGetArrayPointer_Serial(y_)\n",
-    "    #out_ptr = SUNDenseMatrix_Data(out_)\n",
-    "    out_ptr = N_VGetArrayPointer_Serial(out_)\n",
-    "    fy_ptr = N_VGetArrayPointer_Serial(fy_)\n",
-    "    v = numba.carray(v_ptr, (ndim,))\n",
-    "    y = numba.carray(y_ptr, (ndim,))\n",
-    "    out = numba.carray(out_ptr, (ndim,))\n",
-    "    fy = numba.carray(fy_ptr, (ndim,))\n",
-    "    user_data = numba.carray(user_data_, (1,))[0]\n",
-    "    p = user_data.p\n",
-    "    \n",
-    "    return jacobian_prod(t, v, y, fy, out, user_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 77,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 77,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "print(lib.CVodeInit(ode, rhs_wrapper.cffi, 0, y0.c_ptr))\n",
-    "lib.CVodeSVtolerances(ode, reltol, abstol.c_ptr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 78,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "A = lib.SUNDenseMatrix(ndim, ndim)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 79,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "linsolver = lib.SUNLinSol_Dense(y0.c_ptr, A)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 80,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 80,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeSetLinearSolver(ode, linsolver, A)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 81,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 81,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeSetJacFn(ode, Jac.cffi)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 82,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 82,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeSetUserData(ode, user_data_p)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 83,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "yS = lib.N_VCloneVectorArray(nparam, y0.c_ptr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 84,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[]\n",
-      "[]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "array([[0., 0.],\n",
-       "       [0., 0.],\n",
-       "       [0., 0.]])"
-      ]
-     },
-     "execution_count": 84,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "vecs = [sunode.basic.Vector(yS[i]) for i in range(nparam)]\n",
-    "for vec in vecs:\n",
-    "    vec.data[:] = 0\n",
-    "np.array([vec.data for vec in vecs])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "func_type = numba.cffi_support.map_type(ffi.typeof('CVSensRhsFn'))\n",
-    "args = list(func_type.args)\n",
-    "args[-3] = user_ndtype_p\n",
-    "func_type = func_type.return_type(*args)\n",
-    "func_type\n",
-    "\n",
-    "@numba.cfunc(func_type)\n",
-    "def sens_rhs(n_params, t, y_, ydot_, yS_, out_, user_data_, tmp1_, tmp2_):\n",
-    "    y_ptr = N_VGetArrayPointer_Serial(y_)\n",
-    "    y = numba.carray(y_ptr, (ndim,))\n",
-    "    y_dot_ptr = N_VGetArrayPointer_Serial(ydot_)\n",
-    "    ydot = numba.carray(y_dot_ptr, (ndim,))\n",
-    "    \n",
-    "    out = []\n",
-    "    for i in range(n_params):\n",
-    "        out_i_ptr = N_VGetArrayPointer_Serial(out_[i])\n",
-    "        out_i = numba.carray(out_i_ptr, (ndim,))\n",
-    "        out.append(out_i)\n",
-    "\n",
-    "    yS = []\n",
-    "    for i in range(n_params):\n",
-    "        yS_i_ptr = N_VGetArrayPointer_Serial(yS_[i])\n",
-    "        yS_i = numba.carray(yS_i_ptr, (ndim,))\n",
-    "        yS.append(yS_i)\n",
-    "        \n",
-    "    user_data = numba.carray(user_data_, (1,))[0]\n",
-    "    p = user_data.p\n",
-    "    \n",
-    "    df_dp = df_dp_comp((), p.reshape((-1, 1)), y.reshape((-1, 1)))\n",
-    "\n",
-    "    for i in range(n_params):\n",
-    "        s = yS[i]\n",
-    "        ySdot = out[i]\n",
-    "\n",
-    "        jacobian_prod(t, s, y, None, ySdot, user_data)\n",
-    "        ySdot[:] += df_dp[:, i]\n",
-    "    \n",
-    "    return 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 86,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "assert 0 == lib.CVodeSensInit(ode, nparam, lib.CV_STAGGERED, sens_rhs.cffi, yS)\n",
-    "assert 0 == lib.CVodeSensEEtolerances(ode)\n",
-    "assert 0 == lib.CVodeSetSensErrCon(ode, 1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 87,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pbar = np.ones(nparam)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 88,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "NULL_D = ffi.cast('double *', 0)\n",
-    "NULL_I = ffi.cast('int *', 0)\n",
-    "pbar_p = ffi.cast('double *', ffi.addressof(ffi.from_buffer(pbar.data)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 89,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 89,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeSetSensParams(ode, NULL_D, pbar_p, NULL_I)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 90,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "time_p = ffi.new('double*')\n",
-    "time_p[0] = 0."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 91,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tvals = np.linspace(0, 10)\n",
-    "y_vals = []\n",
-    "sens_vals = []\n",
-    "\n",
-    "user_data['p'][...] = [-0.2, 0.3, 0.5]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 92,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "([-0.2,  0.3,  0.5],)"
-      ]
-     },
-     "execution_count": 92,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "user_data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 93,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1.91 ms ± 6.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit\n",
-    "y_vals.clear()\n",
-    "sens_vals.clear()\n",
-    "\n",
-    "y0.data[:] = [0.5, 0.6]\n",
-    "for vec in vecs:\n",
-    "    vec.data[:] = 0\n",
-    "\n",
-    "lib.CVodeReInit(ode, 0, y0.c_ptr)\n",
-    "for t in tvals:\n",
-    "    retval = -1\n",
-    "    while retval == -1:\n",
-    "        retval = lib.CVode(ode, t, y0.c_ptr, time_p, lib.CV_NORMAL)\n",
-    "    y_vals.append(y0.data.copy())\n",
-    "    lib.CVodeGetSens(ode, time_p, yS)\n",
-    "    sens_vals.append(np.array([vec.data.copy() for vec in vecs]).T)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 94,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 95,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f9586674048>]"
-      ]
-     },
-     "execution_count": 95,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, np.array(y_vals)[:, 0])\n",
-    "plt.plot(tvals, np.array(y_vals)[:, 1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 96,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f9589b91dd8>]"
-      ]
-     },
-     "execution_count": 96,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, np.array(sens_vals)[:, 0, 0])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 0, 1])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 0, 2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 97,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f9589932630>]"
-      ]
-     },
-     "execution_count": 97,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, np.array(sens_vals)[:, 1, 0])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 1, 1])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 1, 2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 98,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "num_evals_p = ffi.new('long*')\n",
-    "num_evals_p[0] = 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 99,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "331"
-      ]
-     },
-     "execution_count": 99,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeGetNumRhsEvals(ode, num_evals_p)\n",
-    "num_evals_p[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 100,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "158"
-      ]
-     },
-     "execution_count": 100,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeGetNumSteps(ode, num_evals_p)\n",
-    "num_evals_p[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 101,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "10.0"
-      ]
-     },
-     "execution_count": 101,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "time_p[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 102,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from scipy import integrate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 103,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rhs_(t, y):\n",
-    "    out = np.empty_like(y)\n",
-    "    assert rhs(t, y, out, user_data) == 0\n",
-    "    return out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 104,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def jac_(t, y):\n",
-    "    out = np.empty((ndim, ndim))\n",
-    "    assert jacobian(t, y, None, out, user_data) == 0\n",
-    "    return out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 105,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from scipy import integrate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 106,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "46.6 ms ± 185 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit\n",
-    "out = integrate.solve_ivp(\n",
-    "    rhs_,\n",
-    "    jac=jac_,\n",
-    "    t_span=(0, tvals.max()),\n",
-    "    t_eval=tvals, y0=np.array([0.5, 0.6]), method='BDF',\n",
-    "    rtol=reltol, atol=abstol.data.copy())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 107,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "out = integrate.solve_ivp(\n",
-    "    rhs_,\n",
-    "    jac=jac_,\n",
-    "    t_span=(0, tvals.max()),\n",
-    "    t_eval=tvals, y0=np.array([0.5, 0.6]), method='BDF',\n",
-    "    rtol=reltol, atol=abstol.data.copy())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f95890abeb8>]"
-      ]
-     },
-     "execution_count": 108,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, out.y[0, :])\n",
-    "plt.plot(tvals, out.y[1, :])\n",
-    "\n",
-    "plt.plot(tvals, np.array(y_vals)[:, 0], '.-.')\n",
-    "plt.plot(tvals, np.array(y_vals)[:, 1], '.-.')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  message: 'The solver successfully reached the end of the integration interval.'\n",
-       "     nfev: 414\n",
-       "     njev: 1\n",
-       "      nlu: 36\n",
-       "      sol: None\n",
-       "   status: 0\n",
-       "  success: True\n",
-       "        t: array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,\n",
-       "        1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,\n",
-       "        2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,\n",
-       "        3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,\n",
-       "        4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,\n",
-       "        5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,\n",
-       "        6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,\n",
-       "        7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,\n",
-       "        8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,\n",
-       "        9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])\n",
-       " t_events: None\n",
-       "        y: array([[ 0.5       ,  0.59330775,  0.6558635 ,  0.68691887,  0.68730437,\n",
-       "         0.65901042,  0.60470768,  0.52735582,  0.42997359,  0.31557878,\n",
-       "         0.18726967,  0.04840153, -0.09720291, -0.24508888, -0.39014637,\n",
-       "        -0.52681342, -0.64953166, -0.75337261, -0.83465121, -0.89132052,\n",
-       "        -0.92303038, -0.93087671, -0.91697523, -0.88401334, -0.83488646,\n",
-       "        -0.77245968, -0.69944732, -0.61838069, -0.53163038, -0.44145466,\n",
-       "        -0.35005157, -0.25959857, -0.172268  , -0.09021141, -0.01551158,\n",
-       "         0.0498925 ,  0.10429556,  0.14631476,  0.17496078,  0.18967952,\n",
-       "         0.19036044,  0.17731603,  0.15124244,  0.11317357,  0.06443882,\n",
-       "         0.0066299 , -0.05842347, -0.12867506, -0.20189037, -0.27569338],\n",
-       "       [ 0.6       ,  0.24269343, -0.10330376, -0.42727928, -0.71978789,\n",
-       "        -0.97303477, -1.18103599, -1.33959005, -1.44613273, -1.49955428,\n",
-       "        -1.5000435 , -1.44900144, -1.34904174, -1.20406567, -1.0193672 ,\n",
-       "        -0.80169251, -0.55916445, -0.30100268, -0.03703116,  0.22295627,\n",
-       "         0.4698444 ,  0.69572922,  0.89425338,  1.06073041,  1.19209685,\n",
-       "         1.28675424,  1.3443617 ,  1.36562446,  1.35210615,  1.30607714,\n",
-       "         1.23040031,  1.12844806,  1.0040396 ,  0.86138545,  0.70502601,\n",
-       "         0.53975302,  0.37050806,  0.20225772,  0.03985218, -0.11212185,\n",
-       "        -0.24948055, -0.36856378, -0.4663299 , -0.54042293, -0.5892147 ,\n",
-       "        -0.61182775, -0.60814451, -0.57880707, -0.52520765, -0.44946602]])"
-      ]
-     },
-     "execution_count": 71,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/notebooks/pysundials-demo-sens-analytical.ipynb b/notebooks/pysundials-demo-sens-analytical.ipynb
deleted file mode 100644
index 05d6e24..0000000
--- a/notebooks/pysundials-demo-sens-analytical.ipynb
+++ /dev/null
@@ -1,1535 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import numpy as np\n",
-    "import numba\n",
-    "import numba.cffi_support\n",
-    "import importlib\n",
-    "import sunode\n",
-    "from sunode import lambdify\n",
-    "import sympy as sy\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "state_dtype = np.dtype([('X', (np.float64, ())), ('S', (np.float64, ()))], align=True)\n",
-    "state_ndtype = numba.from_dtype(state_dtype)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "((0.4, 0.5), (0.02,))"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "user_dtype = np.dtype(\n",
-    "    [\n",
-    "        ('deriv_params', [\n",
-    "            ('mu_max', (np.float64, ())),\n",
-    "            ('Y_XS', (np.float64, ())),\n",
-    "        ]),\n",
-    "        ('params', [\n",
-    "            ('K_S', (np.float64, ())),\n",
-    "        ]),\n",
-    "    ],\n",
-    "    align=True\n",
-    ")\n",
-    "user_ndtype = numba.from_dtype(user_dtype)\n",
-    "user_ndtype\n",
-    "\n",
-    "user_ndtype_p = numba.types.CPointer(user_ndtype)\n",
-    "user_data = np.zeros((1,), dtype=user_dtype)[0]\n",
-    "user_data['deriv_params']['mu_max'] = 0.4\n",
-    "user_data['deriv_params']['Y_XS'] = 0.5\n",
-    "user_data['params']['K_S'] = 0.02\n",
-    "user_data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# log scale\n",
-    "@numba.njit\n",
-    "def rhs(out_state, t, state, deriv_params, params, section):\n",
-    "    mu_max = deriv_params.mu_max\n",
-    "    Y_XS = deriv_params.Y_XS\n",
-    "    K_S = params.K_S\n",
-    "\n",
-    "    dXdt = mu_max / (np.exp(state.S) + K_S)\n",
-    "    out_state.S = -1 / Y_XS * dXdt * np.exp(state.X)\n",
-    "    out_state.X = dXdt * np.exp(state.S)\n",
-    "    return 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@numba.njit\n",
-    "def rhs(out_state, t, state, deriv_params, params, section):\n",
-    "    mu_max = deriv_params.mu_max\n",
-    "    Y_XS = deriv_params.Y_XS\n",
-    "    K_S = params.K_S\n",
-    "\n",
-    "    dXdt = mu_max * state.X * state.S / (state.S + K_S)\n",
-    "    out_state.S = -1 / Y_XS * dXdt\n",
-    "    out_state.X = dXdt\n",
-    "    return 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def sympy_func(t, state, grad_params, params, section):\n",
-    "    S = state['S']\n",
-    "    X = state['X']\n",
-    "\n",
-    "    return {\n",
-    "        'S': 0,\n",
-    "        'X': 0,\n",
-    "    }"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_numba(sympy_func, arg_dtypes, out_dtypes):\n",
-    "    ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'solver' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-8-92054d896bcd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m (\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0msolver\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     .coords({\n\u001b[1;32m      4\u001b[0m         \u001b[0;34m'time'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     })\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'solver' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "(\n",
-    "    solver()\n",
-    "    .coords({\n",
-    "        'time': np.linspace(0, 10)\n",
-    "    })\n",
-    "    .states({\n",
-    "        'S': (),\n",
-    "        'X': (),\n",
-    "    })\n",
-    "    .deriv_params({\n",
-    "        'mu_max': (),\n",
-    "        'Y_XS': (),\n",
-    "    })\n",
-    "    .params({\n",
-    "        'K_S': (),\n",
-    "    })\n",
-    "    .rhs(numba_rhs, backend='numba')\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ffi = sunode._cvodes.ffi\n",
-    "lib = sunode._cvodes.lib"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "numba.cffi_support.register_module(sunode._cvodes)\n",
-    "numba.cffi_support.register_type(\n",
-    "    ffi.typeof('N_Vector').item,\n",
-    "    numba.types.Opaque('N_Vector'))\n",
-    "numba.cffi_support.register_type(\n",
-    "    ffi.typeof('SUNMatrix').item,\n",
-    "    numba.types.Opaque('SUNMatrix'))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ndim = 2\n",
-    "y0 = sunode.empty_vector(ndim)\n",
-    "y0.data[:] = 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "abstol = sunode.empty_vector(ndim)\n",
-    "abstol.data[:] = [1e-8, 1e-8]\n",
-    "reltol = 1e-8"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ode = lib.CVodeCreate(lib.CV_BDF)\n",
-    "#ode = lib.CVodeCreate(lib.CV_ADAMS)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "user_data_p = ffi.cast('void *', ffi.addressof(ffi.from_buffer(user_data.data)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "N_VGetArrayPointer_Serial = lib.N_VGetArrayPointer_Serial\n",
-    "\n",
-    "func_type = numba.cffi_support.map_type(ffi.typeof('CVRhsFn'))\n",
-    "func_type = func_type.return_type(*(func_type.args[:-1] + (user_ndtype_p,)))\n",
-    "func_type\n",
-    "\n",
-    "@numba.cfunc(func_type)\n",
-    "def rhs_wrapper(t, y_, out_, user_data_):\n",
-    "    y_ptr = N_VGetArrayPointer_Serial(y_)\n",
-    "    out_ptr = N_VGetArrayPointer_Serial(out_)\n",
-    "    y = numba.carray(y_ptr, (ndim,))\n",
-    "    out = numba.carray(out_ptr, (ndim,))\n",
-    "    \n",
-    "    y = y.view(state_dtype)[0]\n",
-    "    out = out.view(state_dtype)[0]\n",
-    "    \n",
-    "    user_data = numba.carray(user_data_, (1,))[0]\n",
-    "    #grad_vars = user_data.grad_vars\n",
-    "    #p = user_data.p\n",
-    "    section = 0\n",
-    "    \n",
-    "    return rhs(out, t, y, user_data.deriv_params, user_data.params, section)\n",
-    "    #return rhs(t, y, out, user_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "print(lib.CVodeInit(ode, rhs_wrapper.cffi, 0, y0.c_ptr))\n",
-    "#lib.CVodeSVtolerances(ode, reltol, abstol.c_ptr)\n",
-    "lib.CVodeSStolerances(ode, 1e-8, 1e-8)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "A = lib.SUNDenseMatrix(ndim, ndim)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "linsolver = lib.SUNLinSol_Dense(y0.c_ptr, A)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeSetLinearSolver(ode, linsolver, A)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#lib.CVodeSetJacFn(ode, Jac.cffi)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeSetUserData(ode, user_data_p)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "nparam = 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "yS = lib.N_VCloneVectorArray(nparam, y0.c_ptr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[0., 0.],\n",
-       "       [0., 0.]])"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "vecs = [sunode.basic.Vector(yS[i]) for i in range(nparam)]\n",
-    "for vec in vecs:\n",
-    "    vec.data[:] = 0\n",
-    "np.array([vec.data for vec in vecs])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 188,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "func_type = numba.cffi_support.map_type(ffi.typeof('CVSensRhsFn'))\n",
-    "args = list(func_type.args)\n",
-    "args[-3] = user_ndtype_p\n",
-    "func_type = func_type.return_type(*args)\n",
-    "func_type\n",
-    "\n",
-    "@numba.cfunc(func_type)\n",
-    "def sens_rhs(n_params, t, y_, ydot_, yS_, out_, user_data_, tmp1_, tmp2_):\n",
-    "    y_ptr = N_VGetArrayPointer_Serial(y_)\n",
-    "    y = numba.carray(y_ptr, (ndim,))\n",
-    "    y_dot_ptr = N_VGetArrayPointer_Serial(ydot_)\n",
-    "    ydot = numba.carray(y_dot_ptr, (ndim,))\n",
-    "    \n",
-    "    out = []\n",
-    "    for i in range(n_params):\n",
-    "        out_i_ptr = N_VGetArrayPointer_Serial(out_[i])\n",
-    "        out_i = numba.carray(out_i_ptr, (ndim,))\n",
-    "        out.append(out_i)\n",
-    "\n",
-    "    yS = []\n",
-    "    for i in range(n_params):\n",
-    "        yS_i_ptr = N_VGetArrayPointer_Serial(yS_[i])\n",
-    "        yS_i = numba.carray(yS_i_ptr, (ndim,))\n",
-    "        yS.append(yS_i)\n",
-    "        \n",
-    "    user_data = numba.carray(user_data_, (1,))[0]\n",
-    "    p = user_data.p\n",
-    "    \n",
-    "    df_dp = df_dp_comp((), p.reshape((-1, 1)), y.reshape((-1, 1)))\n",
-    "\n",
-    "    for i in range(n_params):\n",
-    "        s = yS[i]\n",
-    "        ySdot = out[i]\n",
-    "\n",
-    "        jacobian_prod(t, s, y, None, ySdot, user_data)\n",
-    "        ySdot[:] += df_dp[:, i]\n",
-    "    \n",
-    "    return 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#assert 0 == lib.CVodeSensInit(ode, nparam, lib.CV_STAGGERED, sens_rhs.cffi, yS)\n",
-    "\n",
-    "#assert 0 == lib.CVodeSensInit(ode, nparam, lib.CV_STAGGERED, ffi.cast('void*', 0), yS)\n",
-    "#assert 0 == lib.CVodeSensEEtolerances(ode)\n",
-    "#assert 0 == lib.CVodeSetSensErrCon(ode, 1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#pbar = np.ones(nparam)\n",
-    "#NULL_D = ffi.cast('double *', 0)\n",
-    "#NULL_I = ffi.cast('int *', 0)\n",
-    "#pbar_p = ffi.cast('double *', ffi.addressof(ffi.from_buffer(pbar.data)))\n",
-    "#p = ffi.cast('double *', ffi.addressof(ffi.from_buffer(user_data['deriv_params'])))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#lib.CVodeSetSensParams(ode, p, pbar_p, NULL_I)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "time_p = ffi.new('double*')\n",
-    "time_p[0] = 0."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tvals = np.linspace(0, 20, 200)\n",
-    "y_vals = []\n",
-    "sens_vals = []\n",
-    "\n",
-    "#user_data['p'][...] = [0.4, 0.02, 0.5]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#start = np.log([0.05, 20])\n",
-    "start = np.array([0.05, 20])\n",
-    "y_vals = np.empty((len(tvals), len(start)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#%%timeit\n",
-    "CVodeReInit = lib.CVodeReInit\n",
-    "CVode = lib.CVode\n",
-    "CVodeGetSens = lib.CVodeGetSens\n",
-    "y0_ptr = y0.c_ptr\n",
-    "y0_data = y0.data\n",
-    "sens_data = tuple(vec.data for vec in vecs)\n",
-    "\n",
-    "@numba.njit()\n",
-    "def solve(ode, y0_ptr, time_p, y0_data, start, t0, y_vals):\n",
-    "    #y_vals.clear()\n",
-    "    #sens_vals.clear()\n",
-    "\n",
-    "    y0_data[:] = start\n",
-    "    #y0.data[:] = np.log(y0.data)\n",
-    "    #for vec in vecs:\n",
-    "    #    vec.data[:] = 0\n",
-    "    #current_time[0] = t0\n",
-    "\n",
-    "    CVodeReInit(ode, t0, y0_ptr)\n",
-    "    for i, t in enumerate(tvals):\n",
-    "        retval = -1\n",
-    "        while retval == -1:\n",
-    "            retval = CVode(ode, t, y0_ptr, time_p, lib.CV_NORMAL)\n",
-    "        #y_vals.append(y0_data.copy())\n",
-    "        y_vals[i, :] = y0_data\n",
-    "        CVodeGetSens(ode, time_p, yS)\n",
-    "        for \n",
-    "        #sens_vals.append(np.array([vec.data.copy() for vec in vecs]).T)\n",
-    "\n",
-    "solve(ode, y0_ptr, time_p, y0_data, start, 0., y_vals)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "import pandas as pd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "12.6 µs ± 37.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%timeit xr.DataArray(y_vals)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = y_vals.view(state_dtype)[:, 0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 80,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "255 µs ± 465 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%timeit pd.DataFrame.from_records(y_vals.view(state_dtype)[:, 0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 88,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['X', 'S'])"
-      ]
-     },
-     "execution_count": 88,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "state_dtype.fields.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 105,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "state_dtype['X'].fields"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 101,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f610d9b5b70>]"
-      ]
-     },
-     "execution_count": 101,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "data_xr = xr.Dataset({name: (('time'), data[name]) for name in state_dtype.fields})\n",
-    "xr.Dataset({name: (('time'), data[name]) for name in state_dtype.fields}).X.plot.line()\n",
-    "xr.Dataset({name: (('time'), data[name]) for name in state_dtype.fields}).S.plot.line()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7f610d829b70>"
-      ]
-     },
-     "execution_count": 108,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "data_xr.to_dataframe().plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 103,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<xarray.Dataset>\n",
-       "Dimensions:  (time: 2000)\n",
-       "Dimensions without coordinates: time\n",
-       "Data variables:\n",
-       "    X        (time) float64 0.05 0.0502 0.0504 0.0506 ... 10.05 10.05 10.05\n",
-       "    S        (time) float64 20.0 20.0 20.0 ... -8.184e-18 -8.18e-18 -8.176e-18"
-      ]
-     },
-     "execution_count": 103,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data_xr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 89,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "228 µs ± 1.09 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%timeit xr.Dataset({name: data[name] for name in state_dtype.fields})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 78,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " "
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "         2827003 function calls (2773003 primitive calls) in 1.715 seconds\n",
-       "\n",
-       "   Ordered by: internal time\n",
-       "\n",
-       "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
-       "   369000    0.082    0.000    0.127    0.000 {built-in method builtins.isinstance}\n",
-       "   118000    0.064    0.000    0.064    0.000 {built-in method builtins.hasattr}\n",
-       "     4000    0.046    0.000    0.305    0.000 alignment.py:340(deep_align)\n",
-       "     7000    0.039    0.000    0.256    0.000 merge.py:227(collect_variables_and_indexes)\n",
-       "     4000    0.033    0.000    0.865    0.000 merge.py:490(merge_core)\n",
-       "175000/133000    0.032    0.000    0.044    0.000 {built-in method builtins.len}\n",
-       "15000/11000    0.031    0.000    0.128    0.000 {built-in method numpy.array}\n",
-       "    28000    0.029    0.000    0.034    0.000 typing.py:806(__new__)\n",
-       "    62000    0.028    0.000    0.040    0.000 <frozen importlib._bootstrap>:416(parent)\n",
-       "     4000    0.026    0.000    0.161    0.000 alignment.py:61(align)\n",
-       "    80000    0.021    0.000    0.029    0.000 generic.py:7(_check)\n",
-       "     4000    0.020    0.000    0.094    0.000 merge.py:320(determine_coords)\n",
-       "     3000    0.019    0.000    0.828    0.000 merge.py:828(dataset_update_method)\n",
-       "55000/53000    0.019    0.000    0.021    0.000 common.py:251(__setattr__)\n",
-       "     6000    0.018    0.000    0.122    0.000 variable.py:65(as_variable)\n",
-       "    72000    0.018    0.000    0.074    0.000 <frozen importlib._bootstrap>:1009(_handle_fromlist)\n",
-       "     1000    0.018    0.000    0.141    0.000 managers.py:1726(form_blocks)\n",
-       "     4000    0.018    0.000    0.071    0.000 variable.py:2235(assert_unique_multiindex_level_names)\n",
-       "   136000    0.017    0.000    0.024    0.000 {built-in method builtins.getattr}\n",
-       "     4000    0.017    0.000    0.037    0.000 merge.py:358(coerce_pandas_values)\n",
-       "    11000    0.016    0.000    0.058    0.000 variable.py:166(as_compatible_data)\n",
-       "     9000    0.015    0.000    0.039    0.000 _dtype.py:319(_name_get)\n",
-       "     7000    0.015    0.000    0.024    0.000 merge.py:153(merge_collected)\n",
-       "     6000    0.015    0.000    0.034    0.000 utils.py:66(_maybe_cast_to_cftimeindex)\n",
-       "    48000    0.014    0.000    0.014    0.000 {built-in method _abc._abc_instancecheck}\n",
-       "        1    0.013    0.013    1.715    1.715 <string>:1(<module>)\n",
-       "    26000    0.013    0.000    0.043    0.000 utils.py:489(ndim)\n",
-       "     1000    0.013    0.000    0.032    0.000 {pandas._libs.lib.clean_index_list}\n",
-       "     3000    0.013    0.000    0.858    0.000 dataset.py:3411(update)\n",
-       "    16000    0.013    0.000    0.034    0.000 common.py:1743(is_extension_array_dtype)\n",
-       "     1000    0.013    0.000    0.033    0.000 managers.py:216(_rebuild_blknos_and_blklocs)\n",
-       "     4000    0.013    0.000    0.030    0.000 numpy_.py:39(__init__)\n",
-       "     4000    0.012    0.000    0.022    0.000 dataset.py:164(calculate_dimensions)\n",
-       "     4000    0.012    0.000    0.081    0.000 base.py:831(array)\n",
-       "     1000    0.012    0.000    0.082    0.000 base.py:277(__new__)\n",
-       "     6000    0.012    0.000    0.038    0.000 dataset.py:867(_replace)\n",
-       "    62000    0.012    0.000    0.012    0.000 {method 'rpartition' of 'str' objects}\n",
-       "     5000    0.011    0.000    0.055    0.000 base.py:1390(set_names)\n",
-       "    11000    0.011    0.000    0.097    0.000 variable.py:284(__init__)\n",
-       "    48000    0.011    0.000    0.025    0.000 abc.py:137(__instancecheck__)\n",
-       "     1000    0.011    0.000    0.019    0.000 managers.py:1854(_stack_arrays)\n",
-       "    16000    0.011    0.000    0.016    0.000 dtypes.py:83(find)\n",
-       "    64000    0.010    0.000    0.010    0.000 {built-in method builtins.issubclass}\n",
-       "     4000    0.010    0.000    0.010    0.000 {built-in method numpy.empty}\n",
-       "    36000    0.010    0.000    0.014    0.000 range.py:652(__len__)\n",
-       "    11000    0.010    0.000    0.029    0.000 variable.py:482(_parse_dimensions)\n",
-       "     6000    0.010    0.000    0.015    0.000 range.py:148(_simple_new)\n",
-       "    42000    0.010    0.000    0.010    0.000 {built-in method __new__ of type object at 0x556de02cf3c0}\n",
-       "    28000    0.010    0.000    0.029    0.000 variable.py:317(shape)\n",
-       "    17000    0.010    0.000    0.018    0.000 {pandas._libs.lib.is_list_like}\n",
-       "    17000    0.010    0.000    0.044    0.000 base.py:231(is_dtype)\n",
-       "     6000    0.009    0.000    0.017    0.000 generic.py:5181(__setattr__)\n",
-       "     9000    0.009    0.000    0.024    0.000 numerictypes.py:365(issubdtype)\n",
-       "    18000    0.009    0.000    0.014    0.000 numerictypes.py:293(issubclass_)\n",
-       "     2000    0.009    0.000    0.035    0.000 managers.py:971(iget)\n",
-       "     9000    0.009    0.000    0.017    0.000 common.py:1886(_is_dtype_type)\n",
-       "     3000    0.008    0.000    0.068    0.000 blocks.py:3195(get_block_type)\n",
-       "     4000    0.008    0.000    0.037    0.000 coordinates.py:205(variables)\n",
-       "     1000    0.008    0.000    0.034    0.000 dataset.py:1140(_construct_dataarray)\n",
-       "     5000    0.008    0.000    0.076    0.000 variable.py:2085(to_index)\n",
-       "    78000    0.008    0.000    0.008    0.000 {method 'items' of 'dict' objects}\n",
-       "     9000    0.008    0.000    0.018    0.000 dataset.py:548(variables)\n",
-       "     2000    0.007    0.000    0.042    0.000 construction.py:630(sanitize_array)\n",
-       "    15000    0.007    0.000    0.012    0.000 _collections_abc.py:742(__iter__)\n",
-       "     1000    0.007    0.000    1.221    0.001 dataset.py:4340(from_dataframe)\n",
-       "     3000    0.007    0.000    0.027    0.000 blocks.py:120(__init__)\n",
-       "     1000    0.007    0.000    0.011    0.000 {pandas._libs.lib.infer_dtype}\n",
-       "    24000    0.007    0.000    0.023    0.000 indexing.py:1369(shape)\n",
-       "     3000    0.006    0.000    0.088    0.000 dataset.py:970(copy)\n",
-       "     4000    0.006    0.000    0.121    0.000 merge.py:391(_get_priority_vars_and_indexes)\n",
-       "    10000    0.006    0.000    0.006    0.000 range.py:342(dtype)\n",
-       "     1000    0.006    0.000    0.024    0.000 construction.py:331(extract_index)\n",
-       "     4000    0.006    0.000    0.009    0.000 base.py:4262(__getitem__)\n",
-       "     3000    0.006    0.000    0.014    0.000 dataset.py:831(_construct_direct)\n",
-       "     4000    0.006    0.000    0.034    0.000 indexing.py:1339(__init__)\n",
-       "     7000    0.006    0.000    0.041    0.000 {method 'update' of 'set' objects}\n",
-       "     9000    0.006    0.000    0.009    0.000 copy.py:66(copy)\n",
-       "     5000    0.006    0.000    0.014    0.000 base.py:1358(_set_names)\n",
-       "     3000    0.006    0.000    0.006    0.000 __init__.py:426(_asdict)\n",
-       "     4000    0.006    0.000    0.042    0.000 variable.py:1955(__init__)\n",
-       "     6000    0.006    0.000    0.006    0.000 generic.py:5162(__getattr__)\n",
-       "     4000    0.006    0.000    0.006    0.000 {method 'get_loc' of 'pandas._libs.index.IndexEngine' objects}\n",
-       "    17000    0.006    0.000    0.010    0.000 utils.py:235(is_dict_like)\n",
-       "     1000    0.006    0.000    0.835    0.001 dataset.py:4327(_set_numpy_data_from_dataframe)\n",
-       "     2000    0.006    0.000    0.013    0.000 version.py:307(parse)\n",
-       "    11000    0.006    0.000    0.008    0.000 merge.py:145(_assert_compat_valid)\n",
-       "     2000    0.005    0.000    0.013    0.000 cast.py:866(maybe_castable)\n",
-       "     1000    0.005    0.000    0.428    0.000 frame.py:1511(from_records)\n",
-       "     3000    0.005    0.000    0.059    0.000 blocks.py:3241(make_block)\n",
-       "     3000    0.005    0.000    0.017    0.000 merge.py:248(append_all)\n",
-       "     8000    0.005    0.000    0.122    0.000 base.py:5707(ensure_index)\n",
-       "    42000    0.005    0.000    0.005    0.000 variable.py:472(dims)\n",
-       "     4000    0.005    0.000    0.014    0.000 coordinates.py:208(<dictcomp>)\n",
-       "     3000    0.005    0.000    0.015    0.000 blocks.py:243(mgr_locs)\n",
-       "     4000    0.005    0.000    0.036    0.000 numpy_.py:122(__init__)\n",
-       "     8000    0.005    0.000    0.007    0.000 dataset.py:1339(indexes)\n",
-       "     2000    0.005    0.000    0.005    0.000 {method 'split' of 're.Pattern' objects}\n",
-       "     2000    0.005    0.000    0.099    0.000 series.py:886(__array__)\n",
-       "     5000    0.005    0.000    0.018    0.000 range.py:410(_shallow_copy)\n",
-       "     7000    0.005    0.000    0.044    0.000 coordinates.py:61(__iter__)\n",
-       "     1000    0.005    0.000    0.005    0.000 {method 'reduce' of 'numpy.ufunc' objects}\n",
-       "     2000    0.005    0.000    0.008    0.000 <frozen importlib._bootstrap>:157(_get_module_lock)\n",
-       "     2000    0.005    0.000    0.099    0.000 generic.py:3265(_get_item_cache)\n",
-       "    45000    0.005    0.000    0.005    0.000 {method 'append' of 'list' objects}\n",
-       "     1000    0.005    0.000    0.013    0.000 {method 'format' of 'str' objects}\n",
-       "     6000    0.005    0.000    0.013    0.000 dataset.py:1354(data_vars)\n",
-       "     9000    0.005    0.000    0.008    0.000 merge.py:244(append)\n",
-       "18000/16000    0.005    0.000    0.009    0.000 {built-in method builtins.iter}\n",
-       "     1000    0.005    0.000    0.010    0.000 construction.py:440(to_arrays)\n",
-       "     2000    0.005    0.000    0.042    0.000 variable.py:2028(copy)\n",
-       "     1000    0.005    0.000    0.086    0.000 dataset.py:436(__init__)\n",
-       "     1000    0.005    0.000    0.013    0.000 base.py:1803(is_unique)\n",
-       "     1000    0.005    0.000    0.068    0.000 managers.py:1837(_multi_blockify)\n",
-       "14000/10000    0.005    0.000    0.127    0.000 _asarray.py:16(asarray)\n",
-       "     3000    0.004    0.000    0.125    0.000 frame.py:832(items)\n",
-       "    11000    0.004    0.000    0.026    0.000 variable.py:146(_maybe_wrap_data)\n",
-       "     2000    0.004    0.000    0.006    0.000 managers.py:1470(__init__)\n",
-       "     2000    0.004    0.000    0.024    0.000 series.py:194(__init__)\n",
-       "     3000    0.004    0.000    0.864    0.000 dataset.py:1240(__setitem__)\n",
-       "     3000    0.004    0.000    0.011    0.000 managers.py:167(shape)\n",
-       "     2000    0.004    0.000    0.049    0.000 managers.py:942(get)\n",
-       "     4000    0.004    0.000    0.015    0.000 dtypes.py:1092(is_dtype)\n",
-       "     3000    0.004    0.000    0.004    0.000 generic.py:162(__init__)\n",
-       "     1000    0.004    0.000    0.024    0.000 <frozen importlib._bootstrap>:978(_find_and_load)\n",
-       "     3000    0.004    0.000    0.009    0.000 common.py:255(is_sparse)\n",
-       "     4000    0.004    0.000    0.010    0.000 dataset.py:1347(coords)\n",
-       "     4000    0.004    0.000    0.054    0.000 _collections_abc.py:760(__iter__)\n",
-       "     8000    0.004    0.000    0.061    0.000 {built-in method builtins.all}\n",
-       "     2000    0.004    0.000    0.010    0.000 dataset.py:583(dims)\n",
-       "     2000    0.004    0.000    0.004    0.000 {built-in method numpy.arange}\n",
-       "     1000    0.004    0.000    0.009    0.000 range.py:83(__new__)\n",
-       "     2000    0.004    0.000    0.038    0.000 frame.py:3444(_box_item_values)\n",
-       "     1000    0.004    0.000    0.009    0.000 _asarray.py:223(require)\n",
-       "    23000    0.004    0.000    0.004    0.000 {method 'get' of 'dict' objects}\n",
-       "    13000    0.004    0.000    0.010    0.000 utils.py:386(__iter__)\n",
-       "     9000    0.004    0.000    0.005    0.000 common.py:1850(_get_dtype)\n",
-       "     6000    0.004    0.000    0.039    0.000 utils.py:84(safe_cast_to_index)\n",
-       "     4000    0.003    0.000    0.006    0.000 common.py:1203(is_datetime64_ns_dtype)\n",
-       "     1000    0.003    0.000    0.066    0.000 managers.py:126(__init__)\n",
-       "     2000    0.003    0.000    0.004    0.000 <frozen importlib._bootstrap>:78(acquire)\n",
-       "     2000    0.003    0.000    0.027    0.000 frame.py:3451(_box_col_values)\n",
-       "     1000    0.003    0.000    0.047    0.000 _optional.py:52(import_optional_dependency)\n",
-       "     2000    0.003    0.000    0.004    0.000 {method 'view' of 'numpy.ndarray' objects}\n",
-       "     1000    0.003    0.000    0.021    0.000 base.py:1185(__iter__)\n",
-       "     6000    0.003    0.000    0.003    0.000 dataset.py:350(__iter__)\n",
-       "    11000    0.003    0.000    0.011    0.000 alignment.py:359(is_alignable)\n",
-       "     1000    0.003    0.000    0.211    0.000 managers.py:1691(create_block_manager_from_arrays)\n",
-       "     4000    0.003    0.000    0.013    0.000 dtypes.py:912(is_dtype)\n",
-       "     2000    0.003    0.000    0.003    0.000 {method 'reshape' of 'numpy.ndarray' objects}\n",
-       "     1000    0.003    0.000    0.006    0.000 frame.py:397(__init__)\n",
-       "    12000    0.003    0.000    0.057    0.000 alignment.py:418(<genexpr>)\n",
-       "     1000    0.003    0.000    0.007    0.000 cast.py:1239(construct_1d_object_array_from_listlike)\n",
-       "     7000    0.003    0.000    0.004    0.000 _collections_abc.py:676(items)\n",
-       "     1000    0.003    0.000    0.010    0.000 managers.py:340(_verify_integrity)\n",
-       "     2000    0.003    0.000    0.023    0.000 variable.py:451(to_index_variable)\n",
-       "     1000    0.003    0.000    0.008    0.000 _dtype.py:46(__str__)\n",
-       "     7000    0.003    0.000    0.003    0.000 base.py:700(_reset_identity)\n",
-       "     1000    0.003    0.000    0.078    0.000 merge.py:450(merge_data_and_coords)\n",
-       "     3000    0.003    0.000    0.003    0.000 alignment.py:20(_get_joiner)\n",
-       "     4000    0.003    0.000    0.003    0.000 dataset.py:172(<setcomp>)\n",
-       "     5000    0.003    0.000    0.004    0.000 common.py:2020(pandas_dtype)\n",
-       "     2000    0.003    0.000    0.005    0.000 series.py:453(name)\n",
-       "     2000    0.003    0.000    0.018    0.000 blocks.py:267(make_block_same_class)\n",
-       "     1000    0.003    0.000    0.047    0.000 construction.py:300(_homogenize)\n",
-       "     4000    0.003    0.000    0.008    0.000 base.py:2888(get_loc)\n",
-       "    11000    0.003    0.000    0.003    0.000 utils.py:392(__contains__)\n",
-       "     4000    0.003    0.000    0.004    0.000 managers.py:1585(internal_values)\n",
-       "     7000    0.002    0.000    0.004    0.000 inference.py:386(is_hashable)\n",
-       "     3000    0.002    0.000    0.050    0.000 dataset.py:1064(<dictcomp>)\n",
-       "     2000    0.002    0.000    0.003    0.000 <frozen importlib._bootstrap>:103(release)\n",
-       "     2000    0.002    0.000    0.004    0.000 series.py:416(_set_axis)\n",
-       "     1000    0.002    0.000    0.005    0.000 base.py:569(_simple_new)\n",
-       "     5000    0.002    0.000    0.014    0.000 common.py:678(is_categorical_dtype)\n",
-       "     1000    0.002    0.000    0.285    0.000 construction.py:69(arrays_to_mgr)\n",
-       "     5000    0.002    0.000    0.016    0.000 common.py:539(is_datetime64tz_dtype)\n",
-       "     8000    0.002    0.000    0.002    0.000 dataset.py:352(<genexpr>)\n",
-       "    15000    0.002    0.000    0.002    0.000 utils.py:380(__init__)\n",
-       "     3000    0.002    0.000    0.049    0.000 variable.py:2103(level_names)\n",
-       "     2000    0.002    0.000    0.010    0.000 common.py:508(is_datetime64_dtype)\n",
-       "     1000    0.002    0.000    1.271    0.001 generic.py:2831(to_xarray)\n",
-       "     2000    0.002    0.000    0.002    0.000 _internal.py:865(npy_ctypes_check)\n",
-       "     4000    0.002    0.000    0.006    0.000 series.py:559(_values)\n",
-       "     5000    0.002    0.000    0.017    0.000 common.py:642(is_interval_dtype)\n",
-       "     1000    0.002    0.000    0.007    0.000 common.py:240(asarray_tuplesafe)\n",
-       "     1000    0.002    0.000    0.012    0.000 base.py:5801(default_index)\n",
-       "     1000    0.002    0.000    0.017    0.000 managers.py:654(_consolidate_check)\n",
-       "     1000    0.002    0.000    0.004    0.000 dataarray.py:277(__init__)\n",
-       "     4000    0.002    0.000    0.004    0.000 common.py:1825(_is_dtype)\n",
-       "     2000    0.002    0.000    0.002    0.000 blocks.py:369(iget)\n",
-       "     6000    0.002    0.000    0.003    0.000 base.py:723(__len__)\n",
-       "     4000    0.002    0.000    0.006    0.000 common.py:1253(is_timedelta64_ns_dtype)\n",
-       "     5000    0.002    0.000    0.003    0.000 variable.py:2121(name)\n",
-       "     3000    0.002    0.000    0.003    0.000 _collections_abc.py:657(get)\n",
-       "     9000    0.002    0.000    0.007    0.000 managers.py:169(<genexpr>)\n",
-       "     2000    0.002    0.000    0.002    0.000 version.py:312(<listcomp>)\n",
-       "    10000    0.002    0.000    0.002    0.000 _collections_abc.py:698(__init__)\n",
-       "     1000    0.002    0.000    0.008    0.000 base.py:710(_engine)\n",
-       "     1000    0.002    0.000    0.006    0.000 variable.py:797(copy)\n",
-       "     2000    0.002    0.000    0.003    0.000 <frozen importlib._bootstrap>:176(cb)\n",
-       "     2000    0.002    0.000    0.002    0.000 <frozen importlib._bootstrap>:58(__init__)\n",
-       "     9000    0.002    0.000    0.002    0.000 {method 'setdefault' of 'dict' objects}\n",
-       "     2000    0.002    0.000    0.015    0.000 indexing.py:1418(copy)\n",
-       "     2000    0.002    0.000    0.005    0.000 generic.py:3279(_set_as_cached)\n",
-       "     3000    0.002    0.000    0.005    0.000 {built-in method builtins.any}\n",
-       "     7000    0.002    0.000    0.003    0.000 common.py:211(<lambda>)\n",
-       "    10000    0.002    0.000    0.002    0.000 utils.py:383(__getitem__)\n",
-       "     4000    0.002    0.000    0.015    0.000 common.py:608(is_period_dtype)\n",
-       "     7000    0.002    0.000    0.002    0.000 common.py:209(classes)\n",
-       "     2000    0.002    0.000    0.002    0.000 {built-in method builtins.sorted}\n",
-       "     2000    0.002    0.000    0.007    0.000 common.py:577(is_timedelta64_dtype)\n",
-       "     3000    0.002    0.000    0.012    0.000 dataset.py:1203(__iter__)\n",
-       "     7000    0.002    0.000    0.002    0.000 indexes.py:35(__getitem__)\n",
-       "     2000    0.002    0.000    0.004    0.000 common.py:225(is_object_dtype)\n",
-       "     6000    0.002    0.000    0.002    0.000 merge.py:187(<listcomp>)\n",
-       "     4000    0.002    0.000    0.003    0.000 alignment.py:284(<genexpr>)\n",
-       "     3000    0.002    0.000    0.014    0.000 common.py:357(is_categorical)\n",
-       "     8000    0.002    0.000    0.002    0.000 coordinates.py:197(_names)\n",
-       "     2000    0.002    0.000    0.002    0.000 {method 'fill' of 'numpy.ndarray' objects}\n",
-       "     2000    0.002    0.000    0.002    0.000 dataset.py:579(encoding)\n",
-       "     3000    0.001    0.000    0.002    0.000 _collections_abc.py:680(values)\n",
-       "     2000    0.001    0.000    0.004    0.000 managers.py:1857(_asarray_compat)\n",
-       "     2000    0.001    0.000    0.003    0.000 series.py:460(name)\n",
-       "     4000    0.001    0.000    0.002    0.000 common.py:150(cast_scalar_indexer)\n",
-       "     2000    0.001    0.000    0.003    0.000 missing.py:128(_isna_new)\n",
-       "     8000    0.001    0.000    0.001    0.000 indexes.py:16(__init__)\n",
-       "     1000    0.001    0.000    0.036    0.000 dataset.py:1225(__getitem__)\n",
-       "     4000    0.001    0.000    0.003    0.000 <string>:1(__new__)\n",
-       "     8000    0.001    0.000    0.001    0.000 {pandas._libs.lib.is_scalar}\n",
-       "     1000    0.001    0.000    0.006    0.000 version.py:331(_cmp)\n",
-       "     1000    0.001    0.000    0.006    0.000 common.py:1619(is_bool_dtype)\n",
-       "     5000    0.001    0.000    0.001    0.000 managers.py:236(items)\n",
-       "     2000    0.001    0.000    0.015    0.000 construction.py:759(_try_cast)\n",
-       "     2000    0.001    0.000    0.003    0.000 numpy_.py:165(__array__)\n",
-       "     2000    0.001    0.000    0.002    0.000 common.py:180(ensure_python_int)\n",
-       "     7000    0.001    0.000    0.001    0.000 {method 'copy' of 'dict' objects}\n",
-       "     1000    0.001    0.000    0.027    0.000 __init__.py:109(import_module)\n",
-       "     3000    0.001    0.000    0.001    0.000 blocks.py:131(_check_ndim)\n",
-       "     8000    0.001    0.000    0.001    0.000 {built-in method builtins.hash}\n",
-       "     3000    0.001    0.000    0.002    0.000 merge.py:80(unique_variable)\n",
-       "     1000    0.001    0.000    0.014    0.000 blocks.py:347(ftype)\n",
-       "     4000    0.001    0.000    0.001    0.000 {method 'intersection' of 'set' objects}\n",
-       "     2000    0.001    0.000    0.001    0.000 range.py:467(equals)\n",
-       "     2000    0.001    0.000    0.005    0.000 arrays.py:7(extract_array)\n",
-       "     9000    0.001    0.000    0.001    0.000 {method 'values' of 'dict' objects}\n",
-       "     1000    0.001    0.000    0.015    0.000 common.py:814(is_datetimelike)\n",
-       "     3000    0.001    0.000    0.002    0.000 indexes.py:29(__len__)\n",
-       "     4000    0.001    0.000    0.001    0.000 managers.py:1523(_block)\n",
-       "     1000    0.001    0.000    0.001    0.000 _asarray.py:300(<setcomp>)\n",
-       "     6000    0.001    0.000    0.001    0.000 dataset.py:347(__init__)\n",
-       "     1000    0.001    0.000    0.001    0.000 construction.py:483(<listcomp>)\n",
-       "     3000    0.001    0.000    0.001    0.000 {method 'copy' of 'set' objects}\n",
-       "     5000    0.001    0.000    0.001    0.000 blocks.py:239(mgr_locs)\n",
-       "     1000    0.001    0.000    0.008    0.000 <frozen importlib._bootstrap>:147(__enter__)\n",
-       "     2000    0.001    0.000    0.003    0.000 utils.py:423(__iter__)\n",
-       "     1000    0.001    0.000    0.002    0.000 managers.py:132(<listcomp>)\n",
-       "     1000    0.001    0.000    0.002    0.000 common.py:1006(is_signed_integer_dtype)\n",
-       "     1000    0.001    0.000    0.001    0.000 generic.py:185(_init_mgr)\n",
-       "     2000    0.001    0.000    0.002    0.000 inference.py:120(is_iterator)\n",
-       "     1000    0.001    0.000    0.007    0.000 version.py:51(__lt__)\n",
-       "     2000    0.001    0.000    0.014    0.000 version.py:302(__init__)\n",
-       "     1000    0.001    0.000    0.006    0.000 base.py:1012(_ndarray_values)\n",
-       "     4000    0.001    0.000    0.001    0.000 coordinates.py:194(__init__)\n",
-       "     1000    0.001    0.000    0.006    0.000 <frozen importlib._bootstrap>:194(_lock_unlock_module)\n",
-       "     4000    0.001    0.000    0.001    0.000 variable.py:2257(<listcomp>)\n",
-       "     1000    0.001    0.000    0.026    0.000 <frozen importlib._bootstrap>:994(_gcd_import)\n",
-       "     2000    0.001    0.000    0.001    0.000 dataset.py:571(encoding)\n",
-       "     2000    0.001    0.000    0.001    0.000 utils.py:288(is_valid_numpy_dtype)\n",
-       "     2000    0.001    0.000    0.001    0.000 series.py:443(_set_subtyp)\n",
-       "     1000    0.001    0.000    0.006    0.000 {method 'any' of 'numpy.ndarray' objects}\n",
-       "     2000    0.001    0.000    0.003    0.000 missing.py:48(isna)\n",
-       "     1000    0.001    0.000    0.002    0.000 common.py:1585(is_float_dtype)\n",
-       "     1000    0.001    0.000    0.002    0.000 common.py:1063(is_unsigned_integer_dtype)\n",
-       "     1000    0.001    0.000    0.015    0.000 managers.py:655(<listcomp>)\n",
-       "     2000    0.001    0.000    0.001    0.000 managers.py:171(ndim)\n",
-       "     2000    0.001    0.000    0.001    0.000 {built-in method pandas._libs.missing.checknull}\n",
-       "     2000    0.001    0.000    0.001    0.000 managers.py:342(<genexpr>)\n",
-       "     5000    0.001    0.000    0.001    0.000 base.py:1524(nlevels)\n",
-       "     1000    0.001    0.000    0.002    0.000 {built-in method builtins.sum}\n",
-       "     4000    0.001    0.000    0.001    0.000 blocks.py:207(internal_values)\n",
-       "     1000    0.001    0.000    0.009    0.000 common.py:1163(is_datetime64_any_dtype)\n",
-       "     4000    0.001    0.000    0.001    0.000 {pandas._libs.lib.is_float}\n",
-       "     1000    0.001    0.000    0.001    0.000 base.py:681(is_)\n",
-       "     4000    0.001    0.000    0.001    0.000 {built-in method _imp.acquire_lock}\n",
-       "     4000    0.001    0.000    0.001    0.000 base.py:3923(_values)\n",
-       "     4000    0.001    0.000    0.001    0.000 {built-in method _thread.allocate_lock}\n",
-       "     5000    0.001    0.000    0.001    0.000 copy.py:111(_copy_immutable)\n",
-       "     5000    0.001    0.000    0.001    0.000 variable.py:2079(to_index_variable)\n",
-       "     1000    0.001    0.000    0.001    0.000 base.py:3901(values)\n",
-       "     1000    0.001    0.000    0.001    0.000 generic.py:510(ndim)\n",
-       "     4000    0.001    0.000    0.001    0.000 common.py:1281(<lambda>)\n",
-       "     1000    0.001    0.000    0.001    0.000 <frozen importlib._bootstrap>:929(_sanity_check)\n",
-       "     1000    0.001    0.000    0.001    0.000 merge.py:460(_extract_indexes_from_coords)\n",
-       "     1000    0.001    0.000    0.001    0.000 managers.py:935(_consolidate_inplace)\n",
-       "     3000    0.001    0.000    0.001    0.000 merge.py:215(<listcomp>)\n",
-       "     1000    0.001    0.000    0.001    0.000 managers.py:1863(_shape_compat)\n",
-       "     3000    0.001    0.000    0.001    0.000 {method 'add' of 'set' objects}\n",
-       "     1000    0.001    0.000    0.001    0.000 _internal.py:470(_view_is_safe)\n",
-       "     2000    0.001    0.000    0.001    0.000 common.py:219(<lambda>)\n",
-       "     2000    0.001    0.000    0.001    0.000 utils.py:411(__init__)\n",
-       "     4000    0.001    0.000    0.001    0.000 {built-in method _imp.release_lock}\n",
-       "     3000    0.000    0.000    0.000    0.000 utils.py:36(_check_inplace)\n",
-       "     1000    0.000    0.000    0.000    0.000 common.py:185(_all_none)\n",
-       "     1000    0.000    0.000    0.001    0.000 base.py:4377(equals)\n",
-       "     2000    0.000    0.000    0.000    0.000 managers.py:1841(<lambda>)\n",
-       "     1000    0.000    0.000    0.002    0.000 <frozen importlib._bootstrap>:151(__exit__)\n",
-       "     4000    0.000    0.000    0.000    0.000 {built-in method _thread.get_ident}\n",
-       "     1000    0.000    0.000    0.006    0.000 _methods.py:44(_any)\n",
-       "     2000    0.000    0.000    0.000    0.000 alignment.py:328(<dictcomp>)\n",
-       "     2000    0.000    0.000    0.000    0.000 indexes.py:32(__contains__)\n",
-       "     2000    0.000    0.000    0.000    0.000 common.py:214(classes_and_not_datetimelike)\n",
-       "     1000    0.000    0.000    0.000    0.000 dataset.py:1162(<dictcomp>)\n",
-       "     1000    0.000    0.000    0.001    0.000 _optional.py:41(_get_version)\n",
-       "     1000    0.000    0.000    0.001    0.000 utils.py:587(hashable)\n",
-       "     1000    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap>:143(__init__)\n",
-       "     1000    0.000    0.000    0.000    0.000 blocks.py:339(shape)\n",
-       "     1000    0.000    0.000    0.000    0.000 {method 'startswith' of 'str' objects}\n",
-       "     1000    0.000    0.000    0.000    0.000 merge.py:468(assert_valid_explicit_coords)\n",
-       "     1000    0.000    0.000    0.000    0.000 {method 'upper' of 'str' objects}\n",
-       "     1000    0.000    0.000    0.000    0.000 base.py:747(dtype)\n",
-       "     1000    0.000    0.000    0.001    0.000 range.py:658(size)\n",
-       "     2000    0.000    0.000    0.000    0.000 numeric.py:134(is_all_dates)\n",
-       "     1000    0.000    0.000    0.000    0.000 managers.py:646(is_consolidated)\n",
-       "     1000    0.000    0.000    0.000    0.000 {method 'extend' of 'list' objects}\n",
-       "     1000    0.000    0.000    0.000    0.000 blocks.py:343(dtype)\n",
-       "     1000    0.000    0.000    0.000    0.000 range.py:170(_validate_dtype)\n",
-       "     1000    0.000    0.000    0.000    0.000 {method 'keys' of 'dict' objects}\n",
-       "     1000    0.000    0.000    0.000    0.000 base.py:717(<lambda>)\n",
-       "        1    0.000    0.000    1.715    1.715 {built-in method builtins.exec}\n",
-       "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%%prun -stime\n",
-    "for _ in range(1000):\n",
-    "    pd.DataFrame.from_records(y_vals.view(state_dtype)[:, 0]).to_xarray()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([((0.4, 0.5), (0.02,))],\n",
-       "      dtype={'names':['deriv_params','params'], 'formats':[[('mu_max', '<f8'), ('Y_XS', '<f8')],[('K_S', '<f8')]], 'offsets':[0,16], 'itemsize':24, 'aligned':True})"
-      ]
-     },
-     "execution_count": 61,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "user_data.reshape((1,))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f6115096198>]"
-      ]
-     },
-     "execution_count": 46,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, y_vals[:, 0])\n",
-    "plt.plot(tvals, y_vals[:, 1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fbb10da17f0>]"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, np.exp(np.array(y_vals)[:, 0]))\n",
-    "plt.plot(tvals, np.exp(np.array(y_vals)[:, 1]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "IndexError",
-     "evalue": "too many indices for array",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-31-da5157cf271f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msens_vals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msens_vals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtvals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msens_vals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mIndexError\u001b[0m: too many indices for array"
-     ]
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, np.array(sens_vals)[:, 0, 0])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 0, 1])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 0, 2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 97,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f9589932630>]"
-      ]
-     },
-     "execution_count": 97,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, np.array(sens_vals)[:, 1, 0])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 1, 1])\n",
-    "plt.plot(tvals, np.array(sens_vals)[:, 1, 2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 98,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "num_evals_p = ffi.new('long*')\n",
-    "num_evals_p[0] = 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 99,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "331"
-      ]
-     },
-     "execution_count": 99,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeGetNumRhsEvals(ode, num_evals_p)\n",
-    "num_evals_p[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 100,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "158"
-      ]
-     },
-     "execution_count": 100,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lib.CVodeGetNumSteps(ode, num_evals_p)\n",
-    "num_evals_p[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 101,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "10.0"
-      ]
-     },
-     "execution_count": 101,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "time_p[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 102,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from scipy import integrate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 103,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rhs_(t, y):\n",
-    "    out = np.empty_like(y)\n",
-    "    assert rhs(t, y, out, user_data) == 0\n",
-    "    return out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 104,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def jac_(t, y):\n",
-    "    out = np.empty((ndim, ndim))\n",
-    "    assert jacobian(t, y, None, out, user_data) == 0\n",
-    "    return out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 105,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from scipy import integrate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 106,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "46.6 ms ± 185 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit\n",
-    "out = integrate.solve_ivp(\n",
-    "    rhs_,\n",
-    "    jac=jac_,\n",
-    "    t_span=(0, tvals.max()),\n",
-    "    t_eval=tvals, y0=np.array([0.5, 0.6]), method='BDF',\n",
-    "    rtol=reltol, atol=abstol.data.copy())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 107,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "out = integrate.solve_ivp(\n",
-    "    rhs_,\n",
-    "    jac=jac_,\n",
-    "    t_span=(0, tvals.max()),\n",
-    "    t_eval=tvals, y0=np.array([0.5, 0.6]), method='BDF',\n",
-    "    rtol=reltol, atol=abstol.data.copy())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f95890abeb8>]"
-      ]
-     },
-     "execution_count": 108,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(tvals, out.y[0, :])\n",
-    "plt.plot(tvals, out.y[1, :])\n",
-    "\n",
-    "plt.plot(tvals, np.array(y_vals)[:, 0], '.-.')\n",
-    "plt.plot(tvals, np.array(y_vals)[:, 1], '.-.')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  message: 'The solver successfully reached the end of the integration interval.'\n",
-       "     nfev: 414\n",
-       "     njev: 1\n",
-       "      nlu: 36\n",
-       "      sol: None\n",
-       "   status: 0\n",
-       "  success: True\n",
-       "        t: array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,\n",
-       "        1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,\n",
-       "        2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,\n",
-       "        3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,\n",
-       "        4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,\n",
-       "        5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,\n",
-       "        6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,\n",
-       "        7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,\n",
-       "        8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,\n",
-       "        9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])\n",
-       " t_events: None\n",
-       "        y: array([[ 0.5       ,  0.59330775,  0.6558635 ,  0.68691887,  0.68730437,\n",
-       "         0.65901042,  0.60470768,  0.52735582,  0.42997359,  0.31557878,\n",
-       "         0.18726967,  0.04840153, -0.09720291, -0.24508888, -0.39014637,\n",
-       "        -0.52681342, -0.64953166, -0.75337261, -0.83465121, -0.89132052,\n",
-       "        -0.92303038, -0.93087671, -0.91697523, -0.88401334, -0.83488646,\n",
-       "        -0.77245968, -0.69944732, -0.61838069, -0.53163038, -0.44145466,\n",
-       "        -0.35005157, -0.25959857, -0.172268  , -0.09021141, -0.01551158,\n",
-       "         0.0498925 ,  0.10429556,  0.14631476,  0.17496078,  0.18967952,\n",
-       "         0.19036044,  0.17731603,  0.15124244,  0.11317357,  0.06443882,\n",
-       "         0.0066299 , -0.05842347, -0.12867506, -0.20189037, -0.27569338],\n",
-       "       [ 0.6       ,  0.24269343, -0.10330376, -0.42727928, -0.71978789,\n",
-       "        -0.97303477, -1.18103599, -1.33959005, -1.44613273, -1.49955428,\n",
-       "        -1.5000435 , -1.44900144, -1.34904174, -1.20406567, -1.0193672 ,\n",
-       "        -0.80169251, -0.55916445, -0.30100268, -0.03703116,  0.22295627,\n",
-       "         0.4698444 ,  0.69572922,  0.89425338,  1.06073041,  1.19209685,\n",
-       "         1.28675424,  1.3443617 ,  1.36562446,  1.35210615,  1.30607714,\n",
-       "         1.23040031,  1.12844806,  1.0040396 ,  0.86138545,  0.70502601,\n",
-       "         0.53975302,  0.37050806,  0.20225772,  0.03985218, -0.11212185,\n",
-       "        -0.24948055, -0.36856378, -0.4663299 , -0.54042293, -0.5892147 ,\n",
-       "        -0.61182775, -0.60814451, -0.57880707, -0.52520765, -0.44946602]])"
-      ]
-     },
-     "execution_count": 71,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}