diff --git a/.github/workflows/Linux_CI.yml b/.github/workflows/Linux_CI.yml
index 3f211d96c..0c8984036 100644
--- a/.github/workflows/Linux_CI.yml
+++ b/.github/workflows/Linux_CI.yml
@@ -28,7 +28,7 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         python -m pip install flake8 pytest
-#        python -m pip install https://github.com/google/jax/archive/refs/tags/jax-v0.3.14.tar.gz
+        # python -m pip install https://github.com/google/jax/archive/refs/tags/jax-v0.3.14.tar.gz
         if [ -f requirements-dev.txt ]; then pip install -r requirements-dev.txt; fi
         python setup.py install
     - name: Lint with flake8
@@ -36,7 +36,7 @@ jobs:
         # stop the build if there are Python syntax errors or undefined names
         flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
         # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-#        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        # flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
     - name: Test with pytest
       run: |
         pytest brainpy/
diff --git a/.github/workflows/MacOS_CI.yml b/.github/workflows/MacOS_CI.yml
index 8549e5d35..cdb3b4c7a 100644
--- a/.github/workflows/MacOS_CI.yml
+++ b/.github/workflows/MacOS_CI.yml
@@ -28,7 +28,7 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         python -m pip install flake8 pytest
-#        python -m pip install https://github.com/google/jax/archive/refs/tags/jax-v0.3.14.tar.gz
+        # python -m pip install https://github.com/google/jax/archive/refs/tags/jax-v0.3.14.tar.gz
         if [ -f requirements-dev.txt ]; then pip install -r requirements-dev.txt; fi
         python setup.py install
     - name: Lint with flake8
@@ -36,7 +36,7 @@ jobs:
         # stop the build if there are Python syntax errors or undefined names
         flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
         # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-#        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        # flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
     - name: Test with pytest
       run: |
         pytest brainpy/
diff --git a/.github/workflows/Windows_CI.yml b/.github/workflows/Windows_CI.yml
index 76b24dcca..9043c2ff0 100644
--- a/.github/workflows/Windows_CI.yml
+++ b/.github/workflows/Windows_CI.yml
@@ -39,7 +39,7 @@ jobs:
         # stop the build if there are Python syntax errors or undefined names
         flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
         # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-#        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        # flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
     - name: Test with pytest
       run: |
         pytest brainpy/
diff --git a/brainpy/integrators/ode/tests/test_delay_ode.py b/brainpy/integrators/ode/tests/test_delay_ode.py
index 657c1371a..18bdef8bd 100644
--- a/brainpy/integrators/ode/tests/test_delay_ode.py
+++ b/brainpy/integrators/ode/tests/test_delay_ode.py
@@ -44,7 +44,8 @@ def __init__(self, *args, **kwargs):
     self.ref2 = delay_odeint(20., self.eq1, args={'xdelay': case2_delay}, state_delays={'x': case2_delay}, method='euler')
 
   @parameterized.named_parameters(
-    {'testcase_name': f'constant_delay_{name}', 'method': name}
+    {'testcase_name': f'constant_delay_{name}',
+     'method': name}
     for name in get_supported_methods()
   )
   def test1(self, method):
@@ -54,8 +55,8 @@ def test1(self, method):
     case1 = delay_odeint(20., self.eq1, args={'xdelay': case1_delay}, state_delays={'x': case1_delay}, method=method)
     case2 = delay_odeint(20., self.eq1, args={'xdelay': case2_delay}, state_delays={'x': case2_delay}, method=method)
 
-    self.assertTrue((case1.x - self.ref1.x).mean() < 1e-3)
-    self.assertTrue((case2.x - self.ref2.x).mean() < 1e-3)
+    self.assertTrue((case1['x'] - self.ref1['x']).mean() < 1e-3)
+    self.assertTrue((case2['x'] - self.ref2['x']).mean() < 1e-3)
 
     # fig, axs = plt.subplots(2, 1)
     # fig.tight_layout(rect=[0, 0, 1, 0.95], pad=3.0)
@@ -90,7 +91,7 @@ def test1(self, method):
     case1 = delay_odeint(4., self.eq, args={'xdelay': delay1}, state_delays={'x': delay1}, dt=0.01, method=method)
     case2 = delay_odeint(4., self.eq, args={'xdelay': delay2}, state_delays={'x': delay2}, dt=0.01, method=method)
 
-    self.assertTrue((case1.x - self.ref1.x).mean() < 1e-1)
-    self.assertTrue((case2.x - self.ref2.x).mean() < 1e-1)
+    self.assertTrue((case1['x'] - self.ref1['x']).mean() < 1e-1)
+    self.assertTrue((case2['x'] - self.ref2['x']).mean() < 1e-1)
 
 
diff --git a/docs/index.rst b/docs/index.rst
index 7154ae4f7..29632b6dc 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -47,7 +47,7 @@ The code of BrainPy is open-sourced at GitHub:
    :maxdepth: 2
    :caption: BDP Tutorials
 
-   tutorial_basics/index
+   tutorial_math/index
    tutorial_building/index
    tutorial_simulation/index
    tutorial_training/index
@@ -76,13 +76,13 @@ The code of BrainPy is open-sourced at GitHub:
    :maxdepth: 1
    :caption: Advanced Tutorials
 
-   tutorial_math/variables
-   tutorial_math/base
-   tutorial_math/compilation
-   tutorial_math/differentiation
-   tutorial_math/control_flows
-   tutorial_math/low-level_operator_customization
-   tutorial_math/interoperation
+   tutorial_advanced/variables
+   tutorial_advanced/base
+   tutorial_advanced/compilation
+   tutorial_advanced/differentiation
+   tutorial_advanced/control_flows
+   tutorial_advanced/low-level_operator_customization
+   tutorial_advanced/interoperation
 
 
 .. toctree::
diff --git a/docs/tutorial_advanced/adavanced_lowdim_analysis.ipynb b/docs/tutorial_advanced/adavanced_lowdim_analysis.ipynb
new file mode 100644
index 000000000..9778449c3
--- /dev/null
+++ b/docs/tutorial_advanced/adavanced_lowdim_analysis.ipynb
@@ -0,0 +1,766 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# How does low-dimensional analyzers work?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "@[Chaoming Wang](https://github.com/chaoming0625)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "As is known to us all, dynamics analysis is necessary in neurodynamics. This is because blind simulation of nonlinear systems is likely to produce few results or misleading results. BrainPy has well supports for low-dimensional systems, no matter how nonlinear your defined system is. Specifically, BrainPy provides the following methods for the analysis of low-dimensional systems:\n",
+    "\n",
+    "1. phase plane analysis;\n",
+    "2. codimension 1 or codimension 2 bifurcation analysis;\n",
+    "3. bifurcation analysis of the fast-slow system. \n",
+    "\n",
+    "BrainPy will help you probe the dynamical mechanism of your defined systems rapidly. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2021-03-25T03:10:39.678453Z",
+     "start_time": "2021-03-25T03:10:36.763061Z"
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import brainpy as bp\n",
+    "import brainpy.math as bm\n",
+    "\n",
+    "bp.math.set_platform('cpu')\n",
+    "bp.math.enable_x64()  # It's better to enable x64 when performing analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "In this section, we provide a basic tutorial to understand how the ``brainpy.analysis.LowDimAnalyzer`` works."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Terminology"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Given the FitzHugh-Nagumo model, we define an analyzer,"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "outputs": [],
+   "source": [
+    "class FitzHughNagumoModel(bp.dyn.DynamicalSystem):\n",
+    "  def __init__(self, method='exp_auto'):\n",
+    "    super(FitzHughNagumoModel, self).__init__()\n",
+    "\n",
+    "    # parameters\n",
+    "    self.a = 0.7\n",
+    "    self.b = 0.8\n",
+    "    self.tau = 12.5\n",
+    "\n",
+    "    # variables\n",
+    "    self.V = bm.Variable(bm.zeros(1))\n",
+    "    self.w = bm.Variable(bm.zeros(1))\n",
+    "    self.Iext = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "    # functions\n",
+    "    def dV(V, t, w, Iext=0.):\n",
+    "        return V - V * V * V / 3 - w + Iext\n",
+    "    def dw(w, t, V, a=0.7, b=0.8):\n",
+    "        return (V + a - b * w) / self.tau\n",
+    "    self.int_V = bp.odeint(dV, method=method)\n",
+    "    self.int_w = bp.odeint(dw, method=method)\n",
+    "\n",
+    "  def update(self, _t, _dt):\n",
+    "    self.V.value = self.int_V(self.V, _t, self.w, self.Iext, _dt)\n",
+    "    self.w.value = self.int_w(self.w, _t, self.V, self.a, self.b, _dt)\n",
+    "    self.Iext[:] = 0."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "outputs": [],
+   "source": [
+    "model = FitzHughNagumoModel()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "outputs": [],
+   "source": [
+    "analyzer = bp.analysis.PhasePlane2D(\n",
+    "  [model.int_V, model.int_w],\n",
+    "  target_vars={'V': [-3, 3], 'w': [-3., 3.]},\n",
+    "  resolutions={'V': 0.01, 'w': 0.01},\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In this instance of ``brainpy.analysis.LowDimAnalyzer``, we use the following terminologies."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "- **x_var** and **y_var** are defined by the order of the user setting. If the user sets the \"target_vars\" as \"{'V': ..., 'w': ...}\",  ``x_var`` and ``y_var`` will be \"V\" and \"w\" respectively. Otherwise, if \"target_vars\"=\"{'w': ..., 'V': ...}\", ``x_var`` and ``y_var`` will be \"w\" and \"V\" respectively."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('V', 'w')"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "analyzer.x_var, analyzer.y_var"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "- **fx** and **fy** are defined as differential equations of ``x_var`` and ``y_var`` respectively, i.e.,\n",
+    "\n",
+    "``fx`` is\n",
+    "\n",
+    "```python\n",
+    "def dV(V, t, w, Iext=0.):\n",
+    "    return V - V * V * V / 3 - w + Iext\n",
+    "```\n",
+    "\n",
+    "``fy`` is\n",
+    "\n",
+    "```\n",
+    "def dw(w, t, V, a=0.7, b=0.8):\n",
+    "    return (V + a - b * w) / self.tau\n",
+    "```"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(<function brainpy.math.jit._make_jit_without_vars.<locals>.call(*args, **kwargs)>,\n",
+       " <function brainpy.math.jit._make_jit_without_vars.<locals>.call(*args, **kwargs)>)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "analyzer.F_fx, analyzer.F_fy"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "- **int_x** and **int_y** are defined as integral functions of the differential equations for ``x_var`` and ``y_var`` respectively."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(functools.partial(<function std_derivative.<locals>.inner.<locals>.call at 0x000001D5BF806550>),\n",
+       " functools.partial(<function std_derivative.<locals>.inner.<locals>.call at 0x000001D5B6C8B430>))"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "analyzer.F_int_x, analyzer.F_int_y"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "- **x_by_y_in_fx** and **y_by_x_in_fx**: They denote that ``x_var`` and ``y_var`` can be separated from each other in \"fx\" nullcline function. Specifically, ``x_by_y_in_fx`` or ``y_by_x_in_fx`` denotes $x = F(y)$ or $y = F(x)$ accoording to $f_x=0$ equation. For example, in the above FitzHugh-Nagumo model, $w$ can be easily represented by $V$ when $\\mathrm{dV(V, t, w, I_{ext})} = 0$, i.e., ``y_by_x_in_fx`` is $w= V - V ^3  / 3 + I_{ext}$."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "\n",
+    "- Similarly, **x_by_y_in_fy** ($x=F(y)$) and **y_by_x_in_fy** ($y=F(x)$) denote ``x_var`` and ``y_var`` can be separated from each other in \"fy\" nullcline function. For example, in the above FitzHugh-Nagumo model, ``y_by_x_in_fy`` is $w= \\frac{V + a}{b}$, and ``x_by_y_in_fy`` is $V= b * w - a$."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "- ``x_by_y_in_fx``, ``y_by_x_in_fx``, ``x_by_y_in_fy`` and ``y_by_x_in_fy`` can be set in the ``options`` argument."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Mechanism for 1D system analysis"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In order to understand the adavantages and disadvantages of BrainPy's analysis toolkit, it is better to know the minimal mechanism how ``brainpy.analysis`` works."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The automatic model analysis in BrainPy heavily relies on numerical optimization methods, including [Brent's method](https://en.wikipedia.org/wiki/Brent%27s_method) and [BFGS method](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm). For example, for the above one-dimensional system ($\\frac{dx}{dt} = \\mathrm{sin}(x) + I$), after the user sets the resolution to ``0.001``, we will get the evaluation points according to the variable boundary ``[-10, 10]``."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "JaxArray([-10.   ,  -9.999,  -9.998, ...,   9.997,   9.998,   9.999],            dtype=float64)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bp.math.arange(-10, 10, 0.001)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Then, BrainPy filters out the candidate intervals in which the roots lie in. Specifically, it tries to find all intervals like $[x_1, x_2]$ where $f(x_1) * f(x_2) \\le 0$ for the 1D system $\\frac{dx}{dt} = f(x)$."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "For example, the following two points which have opposite signs are candidate points we want."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "outputs": [],
+   "source": [
+    "def plot_interval(x0, x1, f):\n",
+    "    xs = np.linspace(x0, x1, 100)\n",
+    "    plt.plot(xs, f(xs))\n",
+    "    plt.scatter([x0, x1], f(np.asarray([x0, x1])), edgecolors='r')\n",
+    "    plt.axhline(0)\n",
+    "    plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "outputs": [
+    {
+     "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": [
+    "plot_interval(-0.001, 0.001, lambda x: np.sin(x))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "According to the intermediate value theorem, there must be a solution between $x_1$ and $x_2$ when $f(x_1) * f(x_2) \\le 0$."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Based on these candidate intervals, BrainPy uses Brent's method to find roots $f(x) = 0$. Further, after obtain the value of the root, BrainPy uses automatic differentiation to evaluate the stability of each root solution."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Overall, BrainPy's analysis toolkit shows significant advantages and disadvantages.\n",
+    "\n",
+    "**Pros**: BrainPy uses numerical methods to find roots and evaluate their stabilities, it does not case about how complex your function is. Therefore, it can apply to general problems, including any 1D and 2D dynamical systems, and some part of low-dimensional ($\\ge 3$) dynamical systems (see later sections). Especially, BrainPy's analysis toolkit is highly useful when the mathematical equations are too complex to get analytical solutions (the example please refer to the tutorial [Anlysis of A Decision Making Model](./decision_making_model.ipynb)).\n",
+    "\n",
+    "**Cons**: However, numerical methods used in BrainPy are hard to find fixed points only exist at a moment. Moreover, when ``resolution`` is small, there will be large amount of calculating. Users should pay attention to designing suitable resolution settings."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Mechanism for 2D system analysis"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "**plot_vector_field()**\n",
+    "\n",
+    "Plotting vector field is simple. We just need to evaluate the values of each differential equation."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "**plot_nullcline()**\n",
+    "\n",
+    "Nullclines are evaluated through the Brent's methods. In order to get all $(x, y)$ values that satisfy ``fx=0`` (i.e., $f_x(x, y) = 0$), we first fix $y=y_0$, then apply Brent optimization to get all $x'$ that satisfy $f_x(x', y_0) = 0$ (alternatively, we can fix $x$ then optimize $y$). Therefore, we will perform Brent optimization many times, because we will iterate over all $y$ value according to the resolution setting."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "**plot_fixed_points()**\n",
+    "\n",
+    "The fixed point finding in BrainPy relies on BFGS method. First, we define an auxiliary function $L(x, t)$:\n",
+    "\n",
+    "$$\n",
+    "L(x, y) = f_x^2(x, y) + f_y^2(x, y).\n",
+    "$$\n",
+    "\n",
+    "$L(x, t)$ is always bigger than 0. We use BFGS optimization to get all local minima. Finally, we filter out the minima whose losses are smaller than $1e^{-8}$, and we choose them as fixed points.\n",
+    "\n",
+    "For this method, how to choose the initial points to perform optimization is the challege, especially when the parameter resolutions are small. Generally, there are four methods provided in BrainPy.\n",
+    "\n",
+    "- **fx-nullcline**: Choose the points in \"fx\" nullcline as the initial points for optimization.\n",
+    "- **fy-nullcline**: Choose the points in \"fy\" nullcline as the initial points for optimization.\n",
+    "- **nullclines**: Choose both the points in \"fx\" nullcline and \"fy\" nullcline as the initial points for optimization.\n",
+    "- **aux_rank**: For a given set of parameters, we evaluate loss function at each point according to the resolution setting. Then we choose the first ``num_rank`` (default is 100)  points which have the smallest losses.\n",
+    "\n",
+    "However, if users provide one of functions of ``x_by_y_in_fx``, ``y_by_x_in_fx``, ``x_by_y_in_fy`` and ``y_by_x_in_fy``. Things will become very simple, because we can change the 2D system as a 1D system, then we only need to optimzie the fixed points by using our favoriate Brent optimization.\n",
+    "\n",
+    "For the given FitzHugh-Nagumo model, we can set"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "I am making bifurcation analysis ...\n",
+      "I am trying to find fixed points by brentq optimization ...\n",
+      "I am trying to filter out duplicate fixed points ...\n",
+      "\tFound 5000 fixed points.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "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": [
+    "analyzer = bp.analysis.Bifurcation2D(\n",
+    "    model,\n",
+    "    target_vars=dict(V=[-3, 3], w=[-3., 3.]),\n",
+    "    target_pars=dict(a=[0.5, 1.], Iext=[0., 1.]),\n",
+    "    resolutions={'a': 0.01, 'Iext': 0.01},\n",
+    "    options={bp.analysis.C.y_by_x_in_fy: (lambda V, a=0.7, b=0.8: (V + a) / b)}\n",
+    ")\n",
+    "analyzer.plot_bifurcation()\n",
+    "analyzer.show_figure()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## References\n",
+    "\n",
+    "[1] Rinzel, John. \"Bursting oscillations in an excitable membrane model.\" In Ordinary and partial differential  equations, pp. 304-316. Springer, Berlin, Heidelberg, 1985.\n",
+    "           \n",
+    "[2] Rinzel, John , and Y. S. Lee . On Different Mechanisms for Membrane Potential Bursting. Nonlinear Oscillations in Biology and Chemistry. Springer Berlin Heidelberg, 1986.\n",
+    "\n",
+    "[3] Rinzel, John. \"A formal classification of bursting mechanisms in excitable systems.\" In Mathematical topics in population biology, morphogenesis and neurosciences, pp. 267-281. Springer, Berlin, Heidelberg, 1987.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "hide_input": false,
+  "jupytext": {
+   "encoding": "# -*- coding: utf-8 -*-"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.9.7"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autoclose": false,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {
+    "height": "211px",
+    "width": "348px"
+   },
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "243.057px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
\ No newline at end of file
diff --git a/docs/tutorial_math/base.ipynb b/docs/tutorial_advanced/base.ipynb
similarity index 100%
rename from docs/tutorial_math/base.ipynb
rename to docs/tutorial_advanced/base.ipynb
diff --git a/docs/tutorial_math/compilation.ipynb b/docs/tutorial_advanced/compilation.ipynb
similarity index 100%
rename from docs/tutorial_math/compilation.ipynb
rename to docs/tutorial_advanced/compilation.ipynb
diff --git a/docs/tutorial_advanced/control_flows.ipynb b/docs/tutorial_advanced/control_flows.ipynb
new file mode 100644
index 000000000..b96d1ee67
--- /dev/null
+++ b/docs/tutorial_advanced/control_flows.ipynb
@@ -0,0 +1,852 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "254bbbf2",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Control Flows"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "355bb9b6",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "@[Chaoming Wang](https://github.com/chaoming0625)\n",
+    "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "465bd161",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "In this section, we are going to talk about how to build structured control flows with the BrainPy data structure ``JaxArray``. These control flows include \n",
+    "\n",
+    "- the *for loop* syntax, \n",
+    "- the *while loop* syntax,  \n",
+    "- and the *condition* syntax. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "38a2bb50",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import brainpy as bp\n",
+    "import brainpy.math as bm\n",
+    "\n",
+    "bp.math.set_platform('cpu')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5bc0144f",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "In JAX, the control flow syntax must be defined as [structured control flows](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#structured-control-flow-primitives). the ``JaxArray`` in BrainPy provides an easier syntax to make control flows. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "208c28c6",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "```{note}\n",
+    "All the control flow syntax below is not re-implementations of JAX's API for control flows. We only gurantee the following APIs are useful and intuitive when you use ``brainpy.math.JaxArray``. \n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ae453ca",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## ``brainpy.math.make_loop()``"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cba23344",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "``brainpy.math.make_loop()`` is used to generate a for-loop function when you use ``JaxArray``. \n",
+    "\n",
+    "Suppose that you are using several JaxArrays (grouped as ``dyn_vars``) to implement your body function \"body\\_fun\", and you want to gather the history values of several of them (grouped as ``out_vars``). Sometimes the body function already returns something, and you also want to gather the returned values. With the Python syntax, it can be realized as \n",
+    "\n",
+    "```python\n",
+    "\n",
+    "def for_loop_function(body_fun, dyn_vars, out_vars, xs):\n",
+    "  ys = []\n",
+    "  for x in xs:\n",
+    "    # 'dyn_vars' and 'out_vars' are updated in 'body_fun()'\n",
+    "    results = body_fun(x)\n",
+    "    ys.append([out_vars, results])\n",
+    "  return ys\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4cbe47d3",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "In BrainPy, you can define this logic using ``brainpy.math.make_loop()``:\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=False)\n",
+    "\n",
+    "hist_of_out_vars = loop_fun(xs)\n",
+    "```\n",
+    "\n",
+    "Or, \n",
+    "\n",
+    "```python\n",
+    "\n",
+    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=True)\n",
+    "\n",
+    "hist_of_out_vars, hist_of_return_vars = loop_fun(xs)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b34396d6",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Let's implement a recurrent network to illustrate how to use this function. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "dd570c81",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class RNN(bp.dyn.DynamicalSystem):\n",
+    "  def __init__(self, n_in, n_h, n_out, n_batch, g=1.0, **kwargs):\n",
+    "    super(RNN, self).__init__(**kwargs)\n",
+    "\n",
+    "    # parameters\n",
+    "    self.n_in = n_in\n",
+    "    self.n_h = n_h\n",
+    "    self.n_out = n_out\n",
+    "    self.n_batch = n_batch\n",
+    "    self.g = g\n",
+    "\n",
+    "    # weights\n",
+    "    self.w_ir = bm.TrainVar(bm.random.normal(scale=1 / n_in ** 0.5, size=(n_in, n_h)))\n",
+    "    self.w_rr = bm.TrainVar(bm.random.normal(scale=g / n_h ** 0.5, size=(n_h, n_h)))\n",
+    "    self.b_rr = bm.TrainVar(bm.zeros((n_h,)))\n",
+    "    self.w_ro = bm.TrainVar(bm.random.normal(scale=1 / n_h ** 0.5, size=(n_h, n_out)))\n",
+    "    self.b_ro = bm.TrainVar(bm.zeros((n_out,)))\n",
+    "\n",
+    "    # variables\n",
+    "    self.h = bm.Variable(bm.random.random((n_batch, n_h)))\n",
+    "\n",
+    "    # function\n",
+    "    self.predict = bm.make_loop(self.cell,\n",
+    "                                dyn_vars=self.vars(),\n",
+    "                                out_vars=self.h,\n",
+    "                                has_return=True)\n",
+    "\n",
+    "  def cell(self, x):\n",
+    "    self.h.value = bm.tanh(self.h @ self.w_rr + x @ self.w_ir + self.b_rr)\n",
+    "    o = self.h @ self.w_ro + self.b_ro\n",
+    "    return o\n",
+    "\n",
+    "\n",
+    "rnn = RNN(n_in=10, n_h=100, n_out=3, n_batch=5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa61848e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "In the above `RNN` model, we define a body function ``RNN.cell`` for later for-loop over input values. The loop function is defined as ``self.predict`` with ``bm.make_loop()``. We care about the history values of \"self.h\" and the readout value \"o\", so we set ``out_vars=self.h`` and ``has_return=True``.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0bd5330a",
+   "metadata": {
+    "lines_to_next_cell": 2,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "xs = bm.random.random((100, rnn.n_in))\n",
+    "hist_h, hist_o = rnn.predict(xs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "18b8d270",
+   "metadata": {
+    "scrolled": true,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(100, 5, 100)"
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hist_h.shape  # the shape should be (num_time,) + h.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "3424de49",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(100, 5, 3)"
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hist_o.shape  # the shape should be (num_time, ) + o.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3328d9aa",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "If you have multiple input values, you should wrap them as a container and call the loop function with ``loop_fun(xs)``, where \"xs\" can be a JaxArray or a list/tuple/dict of JaxArray. For example: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c4159b0b",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n          [ 3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.],\n          [ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n          [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n          [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n          [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n          [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n          [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n          [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n          [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]],            dtype=float32)"
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = bm.Variable(bm.zeros(10))\n",
+    "\n",
+    "def body(x):\n",
+    "    x1, x2 = x  # \"x\" is a tuple/list of JaxArray\n",
+    "    a.value += (x1 + x2)\n",
+    "\n",
+    "loop = bm.make_loop(body, dyn_vars=[a], out_vars=a)\n",
+    "loop(xs=[bm.arange(10), bm.ones(10)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "65c1c1e7",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n          [ 3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.],\n          [ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n          [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n          [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n          [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n          [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n          [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n          [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n          [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]],            dtype=float32)"
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = bm.Variable(bm.zeros(10))\n",
+    "\n",
+    "def body(x):  # \"x\" is a dict of JaxArray\n",
+    "    a.value += x['a'] + x['b']\n",
+    "\n",
+    "loop = bm.make_loop(body, dyn_vars=[a], out_vars=a)\n",
+    "loop(xs={'a': bm.arange(10), 'b': bm.ones(10)})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3d07cc8",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "``dyn_vars``, ``out_vars``, ``xs`` and the body function returns can be arrays with the container structure like tuple/list/dict. The history output values will preserve the container structure of ``out_vars``and body function returns. If ``has_return=True``, the loop function will return a tuple of ``(hist_of_out_vars, hist_of_fun_returns)``. If no values are interested, please set ``out_vars=None``, and the loop function only returns ``hist_of_out_vars``. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34b56543",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## ``brainpy.math.make_while()``"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f39450ce",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "``brainpy.math.make_while()`` is used to generate a while-loop function when you use ``JaxArray``. It supports the following loop logic:\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "while condition:\n",
+    "    statements\n",
+    "```\n",
+    "\n",
+    "When using ``brainpy.math.make_while()`` , *condition* should be wrapped as a ``cond_fun`` function which returns a boolean value, and *statements* should be packed as a ``body_fun`` function which does not support returned values: \n",
+    "\n",
+    "```python\n",
+    "\n",
+    "while cond_fun(x):\n",
+    "    body_fun(x)\n",
+    "```\n",
+    "\n",
+    "where ``x`` is the external input that is not iterated. All the iterated variables should be marked as ``JaxArray``. All ``JaxArray``s used in ``cond_fun`` and ``body_fun`` should be declared as ``dyn_vars`` variables. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "276775fd",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Let's look an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "21056150",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "i = bm.Variable(bm.zeros(1))\n",
+    "counter = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "def cond_f(x): \n",
+    "    return i[0] < 10\n",
+    "\n",
+    "def body_f(x):\n",
+    "    i.value += 1.\n",
+    "    counter.value += i\n",
+    "\n",
+    "loop = bm.make_while(cond_f, body_f, dyn_vars=[i, counter])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e68a758d",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "In the above example, we try to implement a sum from 0 to 10 by using two JaxArrays ``i`` and ``counter``. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5e23e1bd",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "loop()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3ad97ccb",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([55.], dtype=float32)"
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "counter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "1025f8e2",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([10.], dtype=float32)"
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "i"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57b6f203",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## ``brainpy.math.make_cond()``"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1de2b36",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "``brainpy.math.make_cond()`` is used to generate a condition function you use ``JaxArray``. It supports the following conditional logic:\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "if True:\n",
+    "    true statements \n",
+    "else: \n",
+    "    false statements\n",
+    "```\n",
+    "\n",
+    "When using ``brainpy.math.make_cond()`` , *true statements* should be wrapped as a ``true_fun`` function which implements logics under true assertion, and *false statements* should be wrapped as a ``false_fun`` function which implements logics under false assertion. Neither function supports returning values.\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "if True:\n",
+    "    true_fun(x)\n",
+    "else:\n",
+    "    false_fun(x)\n",
+    "```\n",
+    "\n",
+    "All the ``JaxArray``s used in ``true_fun`` and ``false_fun`` should be declared in the ``dyn_vars`` argument. ``x`` is used to receive the external input value. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "149d3dc6",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Let's make a try:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "6291da01",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "a = bm.Variable(bm.zeros(2))\n",
+    "b = bm.Variable(bm.ones(2))\n",
+    "\n",
+    "def true_f(x):  a.value += 1\n",
+    "\n",
+    "def false_f(x): b.value -= 1\n",
+    "\n",
+    "cond = bm.make_cond(true_f, false_f, dyn_vars=[a, b])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c60e61c0",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Here, we have two tensors. If true, tensor ``a`` is added by 1; if false, tensor ``b`` is subtracted by 1. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "838bde45",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(Variable([1., 1.], dtype=float32), Variable([1., 1.], dtype=float32))"
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cond(pred=True)\n",
+    "\n",
+    "a, b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "8bda2e64",
+   "metadata": {
+    "scrolled": true,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(Variable([2., 2.], dtype=float32), Variable([1., 1.], dtype=float32))"
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cond(True)\n",
+    "\n",
+    "a, b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "302b7342",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(Variable([2., 2.], dtype=float32), Variable([0., 0.], dtype=float32))"
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cond(False)\n",
+    "\n",
+    "a, b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "320ef7f9",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(Variable([2., 2.], dtype=float32), Variable([-1., -1.], dtype=float32))"
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cond(False)\n",
+    "\n",
+    "a, b"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f3dff74",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Or, we define a conditional case which depends on the external input. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "a07844d5",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "a = bm.Variable(bm.zeros(2))\n",
+    "b = bm.Variable(bm.ones(2))\n",
+    "\n",
+    "def true_f(x):  a.value += x\n",
+    "\n",
+    "def false_f(x): b.value -= x\n",
+    "\n",
+    "cond = bm.make_cond(true_f, false_f, dyn_vars=[a, b])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "d1219455",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(Variable([10., 10.], dtype=float32), Variable([1., 1.], dtype=float32))"
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cond(True, 10.)\n",
+    "\n",
+    "a, b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "d6098980",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(Variable([10., 10.], dtype=float32), Variable([-4., -4.], dtype=float32))"
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cond(False, 5.)\n",
+    "\n",
+    "a, b"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "main_language": "python"
+  },
+  "kernelspec": {
+   "name": "python3",
+   "language": "python",
+   "display_name": "Python 3 (ipykernel)"
+  },
+  "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.8.8"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autoclose": false,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "279.273px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/docs/tutorial_math/differentiation.ipynb b/docs/tutorial_advanced/differentiation.ipynb
similarity index 100%
rename from docs/tutorial_math/differentiation.ipynb
rename to docs/tutorial_advanced/differentiation.ipynb
diff --git a/docs/tutorial_math/interoperation.ipynb b/docs/tutorial_advanced/interoperation.ipynb
similarity index 100%
rename from docs/tutorial_math/interoperation.ipynb
rename to docs/tutorial_advanced/interoperation.ipynb
diff --git a/docs/tutorial_math/low-level_operator_customization.ipynb b/docs/tutorial_advanced/low-level_operator_customization.ipynb
similarity index 100%
rename from docs/tutorial_math/low-level_operator_customization.ipynb
rename to docs/tutorial_advanced/low-level_operator_customization.ipynb
diff --git a/docs/tutorial_math/variables.ipynb b/docs/tutorial_advanced/variables.ipynb
similarity index 100%
rename from docs/tutorial_math/variables.ipynb
rename to docs/tutorial_advanced/variables.ipynb
diff --git a/docs/tutorial_analysis/decision_making_model.ipynb b/docs/tutorial_analysis/decision_making_model.ipynb
index d1ac230e3..37e8c754e 100644
--- a/docs/tutorial_analysis/decision_making_model.ipynb
+++ b/docs/tutorial_analysis/decision_making_model.ipynb
@@ -3,7 +3,11 @@
   {
    "cell_type": "markdown",
    "id": "9b3d868b",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "# Analysis of a Decision-making Model"
    ]
@@ -11,7 +15,11 @@
   {
    "cell_type": "markdown",
    "id": "d0758752",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "@[Chaoming Wang](https://github.com/chaoming0625)"
    ]
@@ -19,7 +27,11 @@
   {
    "cell_type": "markdown",
    "id": "533d47d1",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "In this section, we are going to use the [low-dimensional analyzers](./lowdim_analysis.ipynb) to make phase plane and bifurcation analysis for the decision making model proposed by (Wong & Wang) [1]. "
    ]
@@ -27,7 +39,11 @@
   {
    "cell_type": "markdown",
    "id": "5cfa074d",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Decision making model"
    ]
@@ -35,7 +51,11 @@
   {
    "cell_type": "markdown",
    "id": "9f3268e0",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "This model considers two excitatory neural assemblies, populations  1  and  2 , that compete with each other through a shared pool of inhibitory neurons. In our analysis, we use the following model equations. \n",
     "\n",
@@ -76,7 +96,11 @@
    "cell_type": "code",
    "execution_count": 1,
    "id": "2a73eb21",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "import brainpy as bp\n",
@@ -89,7 +113,11 @@
   {
    "cell_type": "markdown",
    "id": "6430d1b0",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Parameters"
    ]
@@ -98,7 +126,11 @@
    "cell_type": "code",
    "execution_count": 3,
    "id": "4a6c0a75",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "gamma = 0.641  # Saturation factor for gating variable\n",
@@ -117,7 +149,11 @@
   {
    "cell_type": "markdown",
    "id": "a7453f5e",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Model implementation"
    ]
@@ -126,7 +162,11 @@
    "cell_type": "code",
    "execution_count": 4,
    "id": "61f19c7f",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "@bp.odeint\n",
@@ -145,7 +185,11 @@
   {
    "cell_type": "markdown",
    "id": "07f6669b",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Phase plane analysis"
    ]
@@ -153,7 +197,11 @@
   {
    "cell_type": "markdown",
    "id": "21577116",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "The advantage of the reduced model is that we can understand what dynamical behaviors the model generate for a particular parmeter set using phase-plane analysis and the explore how this behavior changed when the model parameters are variaed (bifurcation analysis). \n",
     "\n",
@@ -163,7 +211,11 @@
   {
    "cell_type": "markdown",
    "id": "f7874ee8",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We construct the phase portraits of the reduced model for different stimulus inputs (see Figure 4 and Figure 5 in (Wong & Wang, 2006) [1]). "
    ]
@@ -171,7 +223,11 @@
   {
    "cell_type": "markdown",
    "id": "b733d379",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**No stimulus**: $\\mu_0 =0$ Hz. In the absence of a stimulus, the two nullclines intersect with\n",
     "each other five times, producing five steady states, of which three\n",
@@ -182,7 +238,11 @@
    "cell_type": "code",
    "execution_count": 5,
    "id": "d41349ff",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -234,7 +294,11 @@
   {
    "cell_type": "markdown",
    "id": "0ac9a527",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Symmetric stimulus**: $\\mu_0=30$ Hz, $c'=0$. When a stimulus  is\n",
     "applied, the phase space of the model is reconfigured. The spontaneous\n",
@@ -246,7 +310,11 @@
    "cell_type": "code",
    "execution_count": 8,
    "id": "e517846e",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -296,7 +364,11 @@
   {
    "cell_type": "markdown",
    "id": "fb48db58",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Biased stimulus**: $\\mu_0=30$ Hz, $c' = 0.14$ (14 % coherence). The phase space changes\n",
     "when a weak motion stimulus is presented. The phase space is no longer symmetrical: the attractor state s1 (correct\n",
@@ -307,7 +379,11 @@
    "cell_type": "code",
    "execution_count": 9,
    "id": "7a06bd7b",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -357,7 +433,11 @@
   {
    "cell_type": "markdown",
    "id": "e8b0eab9",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Stimulus to one population only**: $\\mu_0=30$ Hz, $c'=1.$ (100 % coherence). When $c'$ is sufficiently large, the\n",
     "saddle steady state annihilates with the less favored attractor, leaving only one choice attractor. "
@@ -367,7 +447,11 @@
    "cell_type": "code",
    "execution_count": 10,
    "id": "7cc96eac",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -415,7 +499,11 @@
   {
    "cell_type": "markdown",
    "id": "86c8d4f0",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Bifurcation analysis"
    ]
@@ -423,7 +511,11 @@
   {
    "cell_type": "markdown",
    "id": "b34282a5",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "To see how the ohase portrait of the system changed when we chang the stimulus current, we will generate a bifucation diagram for the reduced model. On the bifurcation diagram the fixed points of the model are shown as a function of a changing parameter. \n",
     "\n",
@@ -433,7 +525,11 @@
   {
    "cell_type": "markdown",
    "id": "6b543dd8",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Fix the coherence $c'=0$, vary the stimulus strength $\\mu_0$**. See Figure 10 in (Wong & Wang, 2006) [1]. "
    ]
@@ -442,7 +538,11 @@
    "cell_type": "code",
    "execution_count": 12,
    "id": "c3205443",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -492,7 +592,11 @@
   {
    "cell_type": "markdown",
    "id": "04a38444",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Fix the stimulus strength $\\mu_0 = 30$ Hz, vary the coherence $c'$**. "
    ]
@@ -501,7 +605,11 @@
    "cell_type": "code",
    "execution_count": 15,
    "id": "99ac4954",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -551,7 +659,11 @@
   {
    "cell_type": "markdown",
    "id": "064a7728",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## References\n",
     "\n",
diff --git a/docs/tutorial_analysis/highdim_analysis.ipynb b/docs/tutorial_analysis/highdim_analysis.ipynb
index 48b234724..74b69cc64 100644
--- a/docs/tutorial_analysis/highdim_analysis.ipynb
+++ b/docs/tutorial_analysis/highdim_analysis.ipynb
@@ -3,7 +3,11 @@
   {
    "cell_type": "markdown",
    "id": "fc06efc0",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "# High-dimensional Analyzers"
    ]
@@ -11,7 +15,11 @@
   {
    "cell_type": "markdown",
    "id": "068c7d67",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "@[Chaoming Wang](https://github.com/chaoming0625)"
    ]
@@ -19,7 +27,11 @@
   {
    "cell_type": "markdown",
    "id": "83374185",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "It's hard to analyze high-dimensional systems. However, we have to analyze high-dimensional systems."
    ]
@@ -27,16 +39,24 @@
   {
    "cell_type": "markdown",
    "id": "b102eccd",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Here, based on numerical optimization methods, BrainPy provides [brainpy.analysis.SlowPointFinder](../apis/auto/analysis/generated/brainpy.analysis.highdim.SlowPointFinder.rst) to help users find **slow points** (or **fixed points**) [1] for your high-dimensional dynamical systems."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "id": "07a97a76",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "import brainpy as bp\n",
@@ -45,22 +65,14 @@
     "bp.math.set_platform('cpu')"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "1cd21a77",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.decomposition import PCA\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "c95effe7",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## What are slow points?"
    ]
@@ -68,7 +80,11 @@
   {
    "cell_type": "markdown",
    "id": "2f0d5511",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "For the given system,\n",
     "\n",
@@ -91,7 +107,11 @@
   {
    "cell_type": "markdown",
    "id": "feb0f208",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## How to find slow points?"
    ]
@@ -99,7 +119,11 @@
   {
    "cell_type": "markdown",
    "id": "ad0c6854",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "In order to find slow points, we can first define an auxiliary scalar function for your continous system $\\dot{x} = f(x)$, \n",
     "\n",
@@ -121,21 +145,54 @@
   {
    "cell_type": "markdown",
    "id": "9b15ec21",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
-    "Here, BrainPy provides [brainpy.analysis.SlowPointFinder](../apis/auto/analysis/generated/brainpy.analysis.highdim.SlowPointFinder.rst). It receives a function which ``f_cell`` defines $f(x)$, and ``f_type`` which specify the type of the function (it can be \"continuous\" or \"discrete\"). Then, ``brainpy.analysis.SlowPointFinder`` can help you:\n",
+    "Here, BrainPy provides [brainpy.analysis.SlowPointFinder](../apis/auto/analysis/generated/brainpy.analysis.highdim.SlowPointFinder.rst). It receives ``f_cell`` to specify the target function/object to analyze.\n",
+    "\n",
+    "If the provided ``f_cell`` is a function, ``SlowPointFinder`` can supports to specify:\n",
+    "\n",
+    "- ``f_type``: the type of the function (it can be \"continuous\" or \"discrete\").\n",
+    "- ``f_loss``: the loss function to minimize the optimization error.\n",
+    "- ``args``: extra arguments passed into the function when performing fixed point optimization.\n",
+    "\n",
+    "If the provided ``f_cell`` is an instance of ``DynamicalSystem``, ``SlowPointFinder`` can supports to specify:\n",
+    "\n",
+    "- ``f_loss``: the loss function to minimize the optimization error.\n",
+    "- ``args``: extra arguments passed into the defined ``update()`` function when performing fixed point optimization.\n",
+    "- ``inputs`` and ``fun_inputs``: inputs to this dynamical system. Similar to the inputs of ``DSRunner`` and ``DSTrainer``.\n",
+    "- ``target_vars``: the selected variables which are used to optimize fixed points. Other variables like \"input\" and \"spike\" can be ignored."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Then, ``brainpy.analysis.SlowPointFinder`` can help you:\n",
     "\n",
     "- optimize to find the fixed/slow points with gradient descent algorithms (``find_fps_with_gd_method()``) or nonlinear optimization solver (``find_fps_with_opt_solver()``)\n",
     "- exclude any fixed points whose losses are above threshold: ``filter_loss()``\n",
     "- exclude any non-unique fixed points according to a tolerance: ``keep_unique()``\n",
     "- exclude any far-away \"outlier\" fixed points: ``exclude_outliers()``\n",
     "- computing the jacobian matrix for the given fixed/slow points: ``compute_jacobians()``"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
    "id": "22297b70",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Example 1: Decision Making Model"
    ]
@@ -143,7 +200,11 @@
   {
    "cell_type": "markdown",
    "id": "92a9f293",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "``brainpy.analysis.SlowPointFinder`` is aimed to find slow/fixed points of high-dimensional systems. Of course, it can optimize to find fixed points of low-dimensional systems. We take the 2D decision making system as an example. "
    ]
@@ -152,7 +213,11 @@
    "cell_type": "code",
    "execution_count": 2,
    "id": "423e768f",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "# parameters\n",
@@ -175,9 +240,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
    "id": "eb220677",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "@bp.odeint\n",
@@ -195,22 +264,30 @@
     "def step(s):\n",
     "    ds1 = int_s1.f(s[0], 0., s[1])\n",
     "    ds2 = int_s2.f(s[1], 0., s[0])\n",
-    "    return bm.asarray([ds1.value, ds2.value])"
+    "    return bm.asarray([ds1, ds2])"
    ]
   },
   {
    "cell_type": "markdown",
    "id": "46266662",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We first use [brainpy.analysis.PhasePlane2D](./lowdim_analysis.ipynb) to get the standard answer. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "id": "6b9a2473",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -222,9 +299,9 @@
       "\tThere are 100 candidates\n",
       "I am trying to filter out duplicate fixed points ...\n",
       "\tFound 3 fixed points.\n",
-      "\t#1 s1=0.28276315331459045, s2=0.40635165572166443 is a saddle node.\n",
+      "\t#1 s1=0.2827633321285248, s2=0.40635180473327637 is a saddle node.\n",
       "\t#2 s1=0.013946513645350933, s2=0.6573889851570129 is a stable node.\n",
-      "\t#3 s1=0.7004519104957581, s2=0.004864314571022987 is a stable node.\n"
+      "\t#3 s1=0.7004518508911133, s2=0.004864312242716551 is a stable node.\n"
      ]
     }
    ],
@@ -240,43 +317,51 @@
   {
    "cell_type": "markdown",
    "id": "4d497cac",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Then, let's check whether the high-dimensional analyzer also works. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "75ddba03",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Optimizing with Adam to find fixed points:\n",
-      "    Batches 1-200 in 0.52 sec, Training loss 0.0576312058\n",
-      "    Batches 201-400 in 0.52 sec, Training loss 0.0049517932\n",
-      "    Batches 401-600 in 0.53 sec, Training loss 0.0007580096\n",
-      "    Batches 601-800 in 0.52 sec, Training loss 0.0001687836\n",
-      "    Batches 801-1000 in 0.51 sec, Training loss 0.0000421500\n",
-      "    Batches 1001-1200 in 0.52 sec, Training loss 0.0000108371\n",
-      "    Batches 1201-1400 in 0.52 sec, Training loss 0.0000027990\n",
-      "    Stop optimization as mean training loss 0.0000027990 is below tolerance 0.0000100000.\n",
+      "Optimizing with Adam(lr=ExponentialDecay(0.01, decay_steps=1, decay_rate=0.9999), beta1=0.9, beta2=0.999, eps=1e-08) to find fixed points:\n",
+      "    Batches 1-200 in 0.25 sec, Training loss 0.0569946170\n",
+      "    Batches 201-400 in 0.24 sec, Training loss 0.0050025512\n",
+      "    Batches 401-600 in 0.24 sec, Training loss 0.0007303259\n",
+      "    Batches 601-800 in 0.24 sec, Training loss 0.0001501544\n",
+      "    Batches 801-1000 in 0.24 sec, Training loss 0.0000339000\n",
+      "    Batches 1001-1200 in 0.25 sec, Training loss 0.0000077679\n",
+      "    Stop optimization as mean training loss 0.0000077679 is below tolerance 0.0000100000.\n",
       "Excluding fixed points with squared speed above tolerance 1e-05:\n",
-      "    Kept 962/1000 fixed points with tolerance under 1e-05.\n",
+      "    Kept 948/1000 fixed points with tolerance under 1e-05.\n",
       "Excluding non-unique fixed points:\n",
-      "    Kept 3/962 unique fixed points with uniqueness tolerance 0.025.\n"
+      "    Kept 3/948 unique fixed points with uniqueness tolerance 0.025.\n"
      ]
     }
    ],
    "source": [
-    "finder = bp.analysis.SlowPointFinder(f_cell=step)\n",
+    "finder = bp.analysis.SlowPointFinder(f_cell=step, f_type=\"continuous\")\n",
     "finder.find_fps_with_gd_method(\n",
-    "    candidates=bm.random.random((1000, 2)), tolerance=1e-5, num_batch=200,\n",
-    "    opt_setting=dict(method=bm.optimizers.Adam,\n",
-    "                     lr=bm.optimizers.ExponentialDecay(0.01, 1, 0.9999)),\n",
+    "    candidates=bm.random.random((1000, 2)),\n",
+    "    tolerance=1e-5,\n",
+    "    num_batch=200,\n",
+    "    optimizer=bp.optimizers.Adam(bp.optimizers.ExponentialDecay(0.01, 1, 0.9999))\n",
     ")\n",
     "finder.filter_loss(1e-5)\n",
     "finder.keep_unique()"
@@ -284,19 +369,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "5a9d31ff",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([[0.7004518 , 0.00486438],\n",
-       "       [0.28276336, 0.40635186],\n",
-       "       [0.01394662, 0.65738887]], dtype=float32)"
-      ]
+      "text/plain": "array([[0.28276306, 0.40635154],\n       [0.7004519 , 0.00486432],\n       [0.01394648, 0.657389  ]], dtype=float32)"
      },
-     "execution_count": 10,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -308,7 +393,11 @@
   {
    "cell_type": "markdown",
    "id": "a43baa44",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Yeah, the fixed points found by ``brainpy.analysis.PhasePlane2D`` and ``brainpy.analysis.SlowPointFinder`` are nearly the same. "
    ]
@@ -316,7 +405,11 @@
   {
    "cell_type": "markdown",
    "id": "fd0a2308",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Example 2: Continuous-attractor Neural Network"
    ]
@@ -324,7 +417,11 @@
   {
    "cell_type": "markdown",
    "id": "52c78c8c",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Continuous-attractor neural network [2] proposed by Si Wu is a special model which has a line of attractors. "
    ]
@@ -333,12 +430,16 @@
    "cell_type": "code",
    "execution_count": 12,
    "id": "ce20c839",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
-    "class CANN1D(bp.NeuGroup):\n",
-    "  def __init__(self, num, tau=1., k=8.1, a=0.5, A=10., J0=4., z_min=-bm.pi, z_max=bm.pi, name=None):\n",
-    "    super(CANN1D, self).__init__(size=num, name=name)\n",
+    "class CANN1D(bp.dyn.NeuGroup):\n",
+    "  def __init__(self, num, tau=1., k=8.1, a=0.5, A=10., J0=4., z_min=-bm.pi, z_max=bm.pi):\n",
+    "    super(CANN1D, self).__init__(size=num)\n",
     "\n",
     "    # parameters\n",
     "    self.tau = tau  # The synaptic time constant\n",
@@ -389,108 +490,121 @@
     "  def get_stimulus_by_pos(self, pos):\n",
     "    return self.A * bm.exp(-0.25 * bm.square(self.dist(self.x - pos) / self.a))\n",
     "\n",
-    "  def update(self, _t, _dt):\n",
-    "    self.u[:] = self.integral(self.u, _t, self.input)\n",
+    "  def update(self, tdi):\n",
+    "    self.u.value = self.integral(self.u, tdi.t, self.input, tdi.dt)\n",
     "    self.input[:] = 0.\n",
     "\n",
     "  def cell(self, u):\n",
     "    return self.derivative(u, 0., 0.)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "633bac92",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def visualize_fixed_points(fps, plot_ids=(0,), xs=None):\n",
-    "  for i in plot_ids:\n",
-    "    if xs is None:\n",
-    "      plt.plot(fps[i], label=f'FP-{i}')\n",
-    "    else:\n",
-    "      plt.plot(xs, fps[i], label=f'FP-{i}')\n",
-    "  plt.legend()\n",
-    "  plt.show()"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 13,
-   "id": "2b1c0e62",
-   "metadata": {},
    "outputs": [],
    "source": [
     "cann = CANN1D(num=512, k=0.1, A=30)"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "8347ec53",
-   "metadata": {},
    "source": [
-    "These attractors is a series of bumps. Therefore we can initialize our candidate points with noisy bumps. "
-   ]
+    "The following code demonstrates how to use ``SlowPointFinder`` to find fixed points of a continous-attractor neural network."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
   },
   {
    "cell_type": "code",
    "execution_count": 14,
-   "id": "eae6a570",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "candidates = cann.get_stimulus_by_pos(bm.arange(-bm.pi, bm.pi, 0.01).reshape((-1, 1)))\n",
-    "candidates += bm.random.normal(0., 0.01, candidates.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
    "id": "24737b1e",
    "metadata": {
-    "scrolled": false
+    "scrolled": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Optimizing to find fixed points:\n",
+      "Optimizing with BFGS to find fixed points:\n",
       "    Found 629 fixed points from 629 initial points.\n",
       "Excluding fixed points with squared speed above tolerance 1e-06:\n",
-      "    Kept 357/629 fixed points with tolerance under 1e-06.\n",
+      "    Kept 356/629 fixed points with tolerance under 1e-06.\n",
       "Excluding non-unique fixed points:\n",
-      "    Kept 357/357 unique fixed points with uniqueness tolerance 0.025.\n"
+      "    Kept 356/356 unique fixed points with uniqueness tolerance 0.025.\n"
      ]
     }
    ],
    "source": [
-    "finder = bp.analysis.SlowPointFinder(f_cell=cann.cell)\n",
-    "finder.find_fps_with_opt_solver(candidates)\n",
+    "# initialize an instance of slow point finder\n",
+    "finder = bp.analysis.SlowPointFinder(\n",
+    "    f_cell=cann,\n",
+    "    target_vars={'u': cann.u},\n",
+    "    dt=1.,\n",
+    ")\n",
+    "\n",
+    "# we can initialize our candidate points with noisy bumps.\n",
+    "candidates = cann.get_stimulus_by_pos(bm.arange(-bm.pi, bm.pi, 0.01).reshape((-1, 1)))\n",
+    "candidates += bm.random.normal(0., 0.01, candidates.shape)\n",
+    "\n",
+    "# optimize to find fixed points\n",
+    "finder.find_fps_with_opt_solver({'u': candidates})\n",
     "finder.filter_loss(1e-6)\n",
     "finder.keep_unique()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The found fixed points are a series of attractor. We can visualized this line of attractors on a 2D space."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "id": "032c9bb8",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
      },
-     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
+    "from sklearn.decomposition import PCA\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
     "pca = PCA(2)\n",
-    "fp_pcs = pca.fit_transform(finder.fixed_points)\n",
+    "fp_pcs = pca.fit_transform(finder.fixed_points['u'])\n",
     "plt.plot(fp_pcs[:, 0], fp_pcs[:, 1], 'x', label='fixed points')\n",
     "plt.xlabel('PC 1')\n",
     "plt.ylabel('PC 2')\n",
@@ -499,91 +613,119 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "These fixed points can also be plotted on the feature space. In the following, we plot the selected points."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 16,
+   "outputs": [],
+   "source": [
+    "def visualize_fixed_points(fps, plot_ids=(0,), xs=None):\n",
+    "  for i in plot_ids:\n",
+    "    if xs is None:\n",
+    "      plt.plot(fps[i], label=f'FP-{i}')\n",
+    "    else:\n",
+    "      plt.plot(xs, fps[i], label=f'FP-{i}')\n",
+    "  plt.legend()\n",
+    "  plt.xlabel('Feature')\n",
+    "  plt.ylabel('Bump activity')\n",
+    "  plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
    "id": "bad2cab4",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
      },
-     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
-    "visualize_fixed_points(finder.fixed_points, plot_ids=(10, 20, 30, 40, 50, 60, 70, 80), xs=cann.x)"
+    "visualize_fixed_points(finder.fixed_points['u'],\n",
+    "                       plot_ids=(10, 20, 30, 40, 50, 60, 70, 80),\n",
+    "                       xs=cann.x)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Let's find the linear part or the Jacobian matrix around the fixed points. We decompose Jacobian matrix and then visualize its stability."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 19,
    "id": "73fa353f",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
+      "text/plain": "<Figure size 432x720 with 10 Axes>",
+      "image/png": "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\n"
      },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
+     "metadata": {
+      "needs_background": "light"
      },
-     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
-    "num = 4\n",
-    "J = finder.compute_jacobians(finder.fixed_points[:num])\n",
-    "for i in range(num):\n",
-    "    eigval, eigvec = np.linalg.eig(np.asarray(J[i]))\n",
-    "    plt.figure()\n",
-    "    plt.scatter(np.real(eigval), np.imag(eigval))\n",
-    "    plt.plot([0, 0], [-1, 1], '--')\n",
-    "    plt.xlabel('Real')\n",
-    "    plt.ylabel('Imaginary')\n",
-    "    plt.show()"
+    "from jax import tree_map\n",
+    "\n",
+    "# select the first ten fixed points\n",
+    "fps = tree_map(lambda a: a[:10], finder._fixed_points)\n",
+    "\n",
+    "# compute jacobian and visualize the decomposed jacobian matrix\n",
+    "J = finder.compute_jacobians(fps, plot=True, num_col=2)"
    ]
   },
   {
    "cell_type": "markdown",
    "id": "75422875",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "More examples of dynamics analysis, for example, analyzing the fixed points in a recurrent neural network, please see [BrainPy Examples](https://brainpy-examples.readthedocs.io/). "
    ]
@@ -591,7 +733,11 @@
   {
    "cell_type": "markdown",
    "id": "5e838d4a",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## References"
    ]
@@ -599,7 +745,11 @@
   {
    "cell_type": "markdown",
    "id": "2fd4cedf",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "[1] Sussillo, D. , and  O. Barak . \"Opening the Black Box: Low-Dimensional Dynamics in High-Dimensional Recurrent Neural Networks.\" Neural computation 25.3(2013):626-649.\n",
     "\n",
@@ -609,9 +759,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python [conda env:root] *",
+   "name": "python3",
    "language": "python",
-   "name": "conda-root-py"
+   "display_name": "Python 3 (ipykernel)"
   },
   "language_info": {
    "codemirror_mode": {
@@ -659,4 +809,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
\ No newline at end of file
diff --git a/docs/tutorial_analysis/lowdim_analysis.ipynb b/docs/tutorial_analysis/lowdim_analysis.ipynb
index 84fbe6c30..ad86ecd60 100644
--- a/docs/tutorial_analysis/lowdim_analysis.ipynb
+++ b/docs/tutorial_analysis/lowdim_analysis.ipynb
@@ -2,28 +2,44 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "# Low-dimensional Analyzers"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "@[Chaoming Wang](https://github.com/chaoming0625)"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We have talked about model [simulation](../tutorial_simulation/index.rst) and [training](../tutorial_training/index.rst) for dynamical systems with BrainPy. In this tutorial, we are going to dive into how to perform automatic analysis for your defined systems.  "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "As is known to us all, dynamics analysis is necessary in neurodynamics. This is because blind simulation of nonlinear systems is likely to produce few results or misleading results. BrainPy has well supports for low-dimensional systems, no matter how nonlinear your defined system is. Specifically, BrainPy provides the following methods for the analysis of low-dimensional systems:\n",
     "\n",
@@ -41,6 +57,9 @@
     "ExecuteTime": {
      "end_time": "2021-03-25T03:10:39.678453Z",
      "start_time": "2021-03-25T03:10:36.763061Z"
+    },
+    "pycharm": {
+     "name": "#%%\n"
     }
    },
    "outputs": [],
@@ -55,7 +74,11 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "import numpy as np\n",
@@ -64,14 +87,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## A simple case"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Here we test BrainPy with a simple case:\n",
     "\n",
@@ -84,7 +115,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "As known to us all, this functuon has multiple fixed points ($\\frac{dx}{dt} = 0$) when $I=0$."
    ]
@@ -92,7 +127,11 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -119,14 +158,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "According to the dynamical theory, at the red hollow points, they are unstable; and for the solid ones, they are stable points. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Now let's come back to BrainPy, and test whether BrainPy can give us the right answer. \n",
     "\n",
@@ -136,7 +183,11 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "@bp.odeint\n",
@@ -146,7 +197,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "This is a one-dimensional dynamical system. So we are trying to use [brainpy.analysis.PhasePlane1D](../apis/auto/analysis/generated/brainpy.analysis.lowdim.PhasePlane1D.rst) for phase plane analysis. The usage of phase plane analysis  will be detailed in the following section. Now, we just focus on the following four arguments:\n",
     "\n",
@@ -161,7 +216,11 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -204,14 +263,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Yeah, absolutelty, ``brainpy.analysis.PhasePlane1D`` gives us the right fixed points, and correctly evalutes the stability of these fixed points.  "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Phase plane is important, because it give us the intuitive understanding how the system evolves with the given parameters. However, in most cases where we care about how the parameters affect the system behaviors, we should make bifurcation analysis. [brainpy.analysis.Bifurcation1D](../apis/auto/analysis/generated/brainpy.analysis.lowdim.Bifurcation1D.rst) is a convenient interface to help you get the insights of how the dynamics of a 1D system changes with parameters. \n",
     "\n",
@@ -220,7 +287,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Here, we systematically change the parameter \"Iext\" from 0 to 1.5. According to the bifurcation theory, we know this simple system has a fold bifurcation when $I=1.0$. Because at $I=1.0$, two fixed points collide with each other into a saddle point and then disappear. Does BrainPy's analysis toolkit ``brainpy.analysis.Bifurcation1D`` is capable of performing these analysis? Let's make a try."
    ]
@@ -229,7 +300,10 @@
    "cell_type": "code",
    "execution_count": 18,
    "metadata": {
-    "scrolled": false
+    "scrolled": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
    },
    "outputs": [
     {
@@ -264,35 +338,55 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Once again, BrainPy analysis toolkit gives the right answer. It tells us how does the fixed points evolve when the parameter $I$ is increasing. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "It is worthy to note that bifurcation analysis in BrainPy is hard to find out the saddle point (when $I=0$ for this system). This is because the saddle point at the bifurcation just exists at a moment. While the numerical method used in BrainPy analysis toolkit is almost impossible to evaluate the point exactly at the saddle. However, if the user has the minimal knowledge about the bifurcation theory, saddle point (the collision point of two fixed points) can be easily infered from the fixed point evolution."
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "BrainPy's analysis toolkit is highly useful, especially when the mathematical equations are too complex to get analytical solutions. The example please refer to the tutorial [Anlysis of A Decision Making Model](./decision_making_model.ipynb). "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Phase plane analysis"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Phase plane analysis is one of the most important techniques for studying the behavior of nonlinear systems, since there is usually no analytical solution for a nonlinear system. BrainPy can help users to plot phase plane of 1D systems or 2D systems. Specifically, we provides [brainpy.analysis.PhasePlane1D](../apis/auto/analysis/generated/brainpy.analysis.lowdim.PhasePlane1D.rst) and [brainpy.analysis.PhasePlane2D](../apis/auto/analysis/generated/brainpy.analysis.lowdim.PhasePlane2D.rst). It can help to plot:\n",
     "\n",
@@ -305,14 +399,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We have talked about ``brainpy.analysis.PhasePlane1D`` in above. Now we focus on ``brainpy.analysis.PhasePlane2D`` by using a well-known neuron model FitzHugh-Nagumo model. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "The FitzHugh-Nagumo model is given by:\n",
     "\n",
@@ -326,7 +428,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "For the system to analyze, users can define it by using the pure ``brainpy.odeint`` or define it as a class of ``DynamicalSystem``. For this FitzHugh-Nagumo model, we define it as a class because later we will perform simulation to verify the analysis results. "
    ]
@@ -334,7 +440,11 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "class FitzHughNagumoModel(bp.DynamicalSystem):\n",
@@ -368,7 +478,11 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "model = FitzHughNagumoModel()"
@@ -376,7 +490,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Here we perform a phase plane analysis with parameters $a=0.7, b=0.8, \\tau=12.5$, and input $I_{ext} = 0.8$."
    ]
@@ -384,7 +502,11 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "pp = bp.analysis.PhasePlane2D(\n",
@@ -403,7 +525,10 @@
      "end_time": "2021-03-24T11:58:24.172655Z",
      "start_time": "2021-03-24T11:58:18.870967Z"
     },
-    "scrolled": false
+    "scrolled": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
    },
    "outputs": [
     {
@@ -463,7 +588,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We can see an unstable-node at the point ($V=-0.27, w=0.53$) inside a limit cycle. \n",
     "\n",
@@ -478,7 +607,10 @@
      "end_time": "2021-03-24T11:58:24.378721Z",
      "start_time": "2021-03-24T11:58:24.172655Z"
     },
-    "scrolled": false
+    "scrolled": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
    },
    "outputs": [
     {
@@ -518,35 +650,55 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Understanding settings"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "There are several key settings needed to understand. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "### ``resolutions``"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "``resolutions`` is one of the most important parameters in PhasePlane and Bifurcation analysis toolkits of BrainPy. It is very important because it has a profound impact on the efficiency of model analysis. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We can set ``resolutions`` with the following ways.\n",
     "\n",
@@ -564,7 +716,11 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "r1 = bm.arange(0.00, 0.95, 0.01)\n",
@@ -575,63 +731,99 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Tips**: For bifurcation analysis, usually we need set a small resolution for parameters, leaving the resolutions of variables as the default. Please see in the following examples."
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "### ``vars`` and ``pars``"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "What can be set as variables ``*_vars`` or parameters ``*_pars`` (such as ``target_vars`` or ``target_pars``) for further analysis? Actually, the variables and parameters are recognized as the same with the programming paradigm of [ODE numerical integrators](../tutorial_intg/ode_numerical_solvers.ipynb). Simply speaking, the arguments before ``t`` will be defined as variables, while arguments after ``t`` will be parameters.  "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "BrainPy's analysis toolkit only support one variable in one differential equation. It cannot analyze the joint differential equation in which multiple variables are defined in the same function. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Moreover, the low-dimensional analyzers in BrainPy cannot analyze dynamical system depends on time $t$."
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Bifurcation analysis"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "Nonlinear dynamical systems are characterized by its parameters. When the parameter changes, the system's behavior will change qualitatively. Therefore, we take care of how the system changes with the smooth change of parameters. "
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Codimension 1 bifurcation analysis**"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We will first see the codimension 1 bifurcation anlysis of the model. For example, we vary the input $I_{ext}$ between 0 to 1 and see how the system change it's stability."
    ]
@@ -644,7 +836,10 @@
      "end_time": "2021-03-24T11:58:26.557712Z",
      "start_time": "2021-03-24T11:58:24.381727Z"
     },
-    "scrolled": false
+    "scrolled": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
    },
    "outputs": [
     {
@@ -702,14 +897,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "**Codimension 2 bifurcation analysis**"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We simulaneously change $I_{ext}$ and parameter $a$."
    ]
@@ -717,7 +920,11 @@
   {
    "cell_type": "code",
    "execution_count": 25,
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -769,14 +976,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "## Fast-slow system bifurcation"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "BrainPy also provides a tool for fast-slow system bifurcation analysis by using [brainpy.analysis.FastSlow1D](../apis/auto/analysis/generated/brainpy.analysis.lowdim.FastSlow1D.rst) and [brainpy.analysis.FastSlow2D](../apis/auto/analysis/generated/brainpy.analysis.lowdim.FastSlow2D.rst). This method is proposed by John Rinzel [1, 2, 3]. (J Rinzel, 1985, 1986, 1987) proposed that in a fast-slow dynamical system, we can treat the slow variables as the bifurcation parameters, and then study how the different value of slow variables affect the bifurcation of the fast sub-system.\n",
     "\n",
@@ -794,7 +1009,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "First of all, let's define the Hindmarsh–Rose model with BrainPy. "
    ]
@@ -806,6 +1025,9 @@
     "ExecuteTime": {
      "end_time": "2021-03-24T11:58:29.650571Z",
      "start_time": "2021-03-24T11:58:29.637572Z"
+    },
+    "pycharm": {
+     "name": "#%%\n"
     }
    },
    "outputs": [],
@@ -835,7 +1057,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "We now can start to analysis the underlying bifurcation mechanism."
    ]
@@ -844,7 +1070,10 @@
    "cell_type": "code",
    "execution_count": 27,
    "metadata": {
-    "scrolled": false
+    "scrolled": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
    },
    "outputs": [
     {
@@ -898,393 +1127,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Advanced tutorial: how does the analyzer work?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this section, we provide a basic tutorial to understand how the ``brainpy.analysis.LowDimAnalyzer`` works."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Terminology"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Given the above FitzHugh-Nagumo model, we define an analyzer,"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "analyzer = bp.analysis.PhasePlane2D(\n",
-    "  [model.int_V, model.int_w],\n",
-    "  target_vars={'V': [-3, 3], 'w': [-3., 3.]},\n",
-    "  resolutions={'V': 0.01, 'w': 0.01},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this instance of ``brainpy.analysis.LowDimAnalyzer``, we use the following terminologies."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **x_var** and **y_var** are defined by the order of the user setting. If the user sets the \"target_vars\" as \"{'V': ..., 'w': ...}\",  ``x_var`` and ``y_var`` will be \"V\" and \"w\" respectively. Otherwise, if \"target_vars\"=\"{'w': ..., 'V': ...}\", ``x_var`` and ``y_var`` will be \"w\" and \"V\" respectively."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "('V', 'w')"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "analyzer.x_var, analyzer.y_var"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **fx** and **fy** are defined as differential equations of ``x_var`` and ``y_var`` respectively, i.e., \n",
-    "\n",
-    "``fx`` is \n",
-    "\n",
-    "```python\n",
-    "def dV(V, t, w, Iext=0.): \n",
-    "    return V - V * V * V / 3 - w + Iext\n",
-    "```\n",
-    "\n",
-    "``fy`` is \n",
-    "\n",
-    "```\n",
-    "def dw(w, t, V, a=0.7, b=0.8): \n",
-    "    return (V + a - b * w) / self.tau\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(<function brainpy.math.jit._make_jit_without_vars.<locals>.call(*args, **kwargs)>,\n",
-       " <function brainpy.math.jit._make_jit_without_vars.<locals>.call(*args, **kwargs)>)"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "analyzer.F_fx, analyzer.F_fy"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **int_x** and **int_y** are defined as integral functions of the differential equations for ``x_var`` and ``y_var`` respectively. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(functools.partial(<function std_derivative.<locals>.inner.<locals>.call at 0x000001D5BF806550>),\n",
-       " functools.partial(<function std_derivative.<locals>.inner.<locals>.call at 0x000001D5B6C8B430>))"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "analyzer.F_int_x, analyzer.F_int_y"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- **x_by_y_in_fx** and **y_by_x_in_fx**: They denote that ``x_var`` and ``y_var`` can be separated from each other in \"fx\" nullcline function. Specifically, ``x_by_y_in_fx`` or ``y_by_x_in_fx`` denotes $x = F(y)$ or $y = F(x)$ accoording to $f_x=0$ equation. For example, in the above FitzHugh-Nagumo model, $w$ can be easily represented by $V$ when $\\mathrm{dV(V, t, w, I_{ext})} = 0$, i.e., ``y_by_x_in_fx`` is $w= V - V ^3  / 3 + I_{ext}$. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "- Similarly, **x_by_y_in_fy** ($x=F(y)$) and **y_by_x_in_fy** ($y=F(x)$) denote ``x_var`` and ``y_var`` can be separated from each other in \"fy\" nullcline function. For example, in the above FitzHugh-Nagumo model, ``y_by_x_in_fy`` is $w= \\frac{V + a}{b}$, and ``x_by_y_in_fy`` is $V= b * w - a$."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- ``x_by_y_in_fx``, ``y_by_x_in_fx``, ``x_by_y_in_fy`` and ``y_by_x_in_fy`` can be set in the ``options`` argument. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Mechanism for 1D system analysis"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In order to understand the adavantages and disadvantages of BrainPy's analysis toolkit, it is better to know the minimal mechanism how ``brainpy.analysis`` works."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The automatic model analysis in BrainPy heavily relies on numerical optimization methods, including [Brent's method](https://en.wikipedia.org/wiki/Brent%27s_method) and [BFGS method](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm). For example, for the above one-dimensional system ($\\frac{dx}{dt} = \\mathrm{sin}(x) + I$), after the user sets the resolution to ``0.001``, we will get the evaluation points according to the variable boundary ``[-10, 10]``."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "JaxArray([-10.   ,  -9.999,  -9.998, ...,   9.997,   9.998,   9.999],            dtype=float64)"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "bp.math.arange(-10, 10, 0.001)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then, BrainPy filters out the candidate intervals in which the roots lie in. Specifically, it tries to find all intervals like $[x_1, x_2]$ where $f(x_1) * f(x_2) \\le 0$ for the 1D system $\\frac{dx}{dt} = f(x)$. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For example, the following two points which have opposite signs are candidate points we want. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_interval(x0, x1, f):\n",
-    "    xs = np.linspace(x0, x1, 100)\n",
-    "    plt.plot(xs, f(xs))\n",
-    "    plt.scatter([x0, x1], f(np.asarray([x0, x1])), edgecolors='r')\n",
-    "    plt.axhline(0)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAD4CAYAAAA6j0u4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxcklEQVR4nO3deXxU9dX48c8hEDbZN0NCWIMYFhWGTetWqSwuqMhPKBWwKtJqfarPowQRxaUVtHWhohatFloVKWsUEQF3RSEoZoNACFsgQNiXQEgy5/fH3NghTpIJmclkOe/Xa15zl+9y7s3NnNwl3xFVxRhjjAmmWqEOwBhjTPVnycYYY0zQWbIxxhgTdJZsjDHGBJ0lG2OMMUFXO9QBhFrLli21Q4cOoQ7DGGOqlPXr1x9Q1Vb+lq/xyaZDhw4kJCSEOgxjjKlSRGRHWcrbZTRjjDFBZ8nGGGNM0FmyMcYYE3SWbIwxxgSdJRtjjDFBF5BkIyJDRCRNRNJFJM7HehGRmc76RBHpXVpdERkpIiki4hYRV5H2Jjvl00RksNfyPiKS5KybKSISiO0zxpjqxP32O5yI6YY7LMzz/vY7Qe+z3MlGRMKAWcBQIBYYLSKxRYoNBWKc1wTgVT/qJgO3AF8U6S8WGAV0B4YArzjt4LQ7wauvIeXdPmOMqU7cb7/DwQce4m7XOLo+uIi7XeM4+MBDQU84gTiz6Qekq2qGqp4B5gHDi5QZDsxVj2+BpiISUVJdVd2oqmk++hsOzFPVXFXdBqQD/Zz2GqvqGvV8b8Jc4KYAbJ8xxlQbOdOe5N5Bf2BN+17kh9VmTfte3H/NfeRMezKo/QYi2UQCu7zmM51l/pTxp66//UU606W2JSITRCRBRBKys7NL6c4YY6qPH/PqsbZdj7OWrYuKpUHGlqD2G4hk4+u+SNFvZCuujD91/e3P77ZUdbaqulTV1aqV36MtGGNMlXXsdB6TFyUyZtSfqJd/5qx1fTNTyekUE9T+A5FsMoF2XvNRwB4/y/hT19/+Mp3psrRljDHV3srUffzq+c95b90uJrTMZeU7/8vAHYnULshn4I5EZq5+mQbTHgtqDIEYG20dECMiHYHdeG7e/7pImXjgPhGZB/QHjqpqlohk+1G3qHjgHRF5HmiL50GAtapaICLHRWQA8B0wFvhbALbPGGOqpAMncpkWn8IHiVl0O78Rr4910SuqKe6I07w+7UkazN9CTqcYGrzwHLXGlPbRWz7lTjaqmi8i9wErgDDgTVVNEZGJzvrXgA+BYXhu5ucAd5RUF0BEbsaTLFoBy0Rkg6oOdtqeD6QC+cC9qlrghPM74J9AfWC58zLGmBpFVVmyYTdPvJ/Kydx8HvxVVyZe2Znw2p6LWbXG/JrznORyXgXFJJ4Ht2oul8ulNuqzMaa62HPkFFMWJ/FpWjaXRDfl2RG9iGnTKOD9iMh6VXWVXtKjxn/FgDHGVAdut/L22p3MWL6JArcy9fpYxl/agbBaleN/2y3ZGGNMFbftwEkmLUxk7bZD/KJLS565pSftmjcIdVhnsWRjjDFVVH6Bmze+2sYLKzcTXrsWz47oxUhXFJVxpC5LNsYYUwWl7jnGpIWJJO0+yrWxbXjqph60aVwv1GEVy5KNMcZUIbn5Bbz8STqvfraVpg3qMOvXvRnW8/xKeTbjzZKNMcZUEet3HGbSwkTS95/glt6RTL0ulmYNw0Mdll8s2RhjTCV3Mjef51akMWfNdto2qc8/7+jLVRe0DnVYZWLJxhhjKrEvt2QzeVESmYdPMW5gex4a0o3z6la9j+6qF7ExxtQAR3PyeHpZKv9Zn0mnlg35z8SB9O3QPNRhnTNLNsYYU8msSNnLo0uSOXTyDL+/qjP3XxNDvTphpVesxCzZGGNMJZF93DNw5rKkLGIjGvPW+L70iGwS6rACwpKNMcaEmKqy6PvdPPlBKqfyCnho8AVMuKITdcIC8S0wlYMlG2OMCaHMwzk8sjiZLzZn06d9M2aM6EWX1hU1FnPFsWRjjDEh4HYr//5uBzOWb0KBJ27szu0D2lOrkgycGWiWbIwxpoJtzT5B3MJE1m0/zOUxnoEzo5pVroEzA82SjTHGVJC8Ajezv8jgpdVbqF8njL+MvIgRvSMr/VAzgRCQu08iMkRE0kQkXUTifKwXEZnprE8Ukd6l1RWR5iKyUkS2OO/NnOVjRGSD18stIhc76z5z2ipcV7X+xdYYU20l7z7KTbO+5rkVaVzTrTUrH7yCW/tUzhGag6HcyUZEwoBZwFAgFhgtIrFFig0FYpzXBOBVP+rGAatVNQZY7cyjqm+r6sWqejFwO7BdVTd49TWmcL2q7i/v9hljTHmczivg2Y82MXzW1+w7lstrv+nNq7/pQ+tGlXeE5mAIxGW0fkC6qmYAiMg8YDiQ6lVmODBXPd9B/a2INBWRCKBDCXWHA1c59ecAnwGTivQ9Gng3ANtgjDEBt277ISYtTCQj+yS39oli6nWxNGlQJ9RhhUQgkk0ksMtrPhPo70eZyFLqtlHVLABVzSrmkthteJKSt7dEpABYCDztJLiziMgEPGdYREdHF79lxhhzDk7k5vPcR5uY++0OIpvW51939uPymFahDiukApFsfF1wLPoBX1wZf+r67lSkP5Cjqslei8eo6m4RaYQn2dwOzP1ZB6qzgdkALpfLr/6MMcYfn2/O5pFFSew5eopxAzvw0OALaFgFB84MtEDsgUygndd8FLDHzzLhJdTdJyIRzllNBFD0/ssoilxCU9XdzvtxEXkHzyW+nyUbY4wJtCM5Z3jqg40s/D6Tzq0asmDiQPq0r7oDZwZaIJ5GWwfEiEhHEQnHkwTii5SJB8Y6T6UNAI46l8hKqhsPjHOmxwFLCxsTkVrASGCe17LaItLSma4DXA94n/UYY0xQLE/KYtDzX7Bkw27uu7oLy+6/3BJNEeU+s1HVfBG5D1gBhAFvqmqKiEx01r8GfAgMA9KBHOCOkuo6TU8H5ovIncBOPMml0BVAZuGDBY66wAon0YQBq4DXy7t9xhhTnP3HT/PYkhQ+StlLj8jGzPltX7q3rR4DZwaa+Lh/XqO4XC5NSEgIdRjGmCpEVVmwPpOnPkjldL6bBwZ15e7LO1K7Gg2cWRoRWa+qLn/L210rY4wpg12HcnhkcRJfbjlAvw7NmT6iJ51aVb+BMwPNko0xxvihwK3MXbOd51akIcBTw7szpn/1HTgz0CzZGGNMKdL3H2fSwiTW7zjMVRe04k839ySyaf1Qh1WlWLIxxphi5BW4+fvnW5m5Op0GdcN44baLuOnimjFwZqBZsjHGGB+SMo/y8MJENmYd47peETxxY3danlc31GFVWZZsjDHGy+m8Al5ctYXXv8ygRcNw/n57HwZ3Pz/UYVV5lmyMMcbxXcZB4hYlse3ASUb1bcfkYRfSpH7NHDgz0CzZGGNqvOOn85jx0Sb+/e1O2jWvz9t39eeyLi1DHVa1YsnGGFOjfZq2nymLksg6dpo7f9GR/722Kw3C7aMx0GyPGmNqpMMnz/DkB6ks/mE3Ma3PY+HvLqV3dLNQh1VtWbIxxtQoqsqypCweX5rC0VN53H9NDPde3Zm6tcNCHVq1ZsnGGFNj7Dt2mqlLkvk4dR+9oprw77v6c2FE41CHVSNYsjHGVHuqyvyEXTy9bCNn8t08Mqwbv72sZg2cGWqWbIwx1drOgznELUrkm60H6d+xOTNG9KJDy4ahDqvGsWRjjKmWCtzKP7/Zzl9WpBFWS/jTzT0Y3TfaBs4MEUs2xphqZ/O+4zy8IJENu47wy26t+dPNPYhoYgNnhlJALliKyBARSRORdBGJ87FeRGSmsz5RRHqXVldEmovIShHZ4rw3c5Z3EJFTIrLBeb3mVaePiCQ5bc0UGy3PmBrlTL6bl1Zt4bqZX7LzUA4vjbqYf4xzWaKpBMqdbEQkDJgFDAVigdEiEluk2FAgxnlNAF71o24csFpVY4DVznyhrap6sfOa6LX8Vaf9wr6GlHf7jDFVw4+7jnDjy1/xwqrNDOkRwcoHrmC4jdBcaQTiMlo/IF1VMwBEZB4wHEj1KjMcmKue76D+VkSaikgE0KGEusOBq5z6c4DPgEnFBeG011hV1zjzc4GbgOUB2EZjTCV16kwBL6zazBtfZtC6UT3eGOtiUGybUIdlighEsokEdnnNZwL9/SgTWUrdNqqaBaCqWSLS2qtcRxH5ATgGPKqqXzptZfro42dEZAKeMyCio6NL2z5jTCW1ZutB4hYlsuNgDqP7eQbObFzPBs6sjAKRbHydo6qfZfypW1QWEK2qB0WkD7BERLqXpS1VnQ3MBnC5XKX1Z4ypZI6dzuOZDzfx7tqdtG/RgHfu7s+lnW3gzMosEMkmE2jnNR8F7PGzTHgJdfeJSIRzVhMB7AdQ1Vwg15leLyJbga5OH1GlxGGMqeJWpe5jypIkso/ncvflHXnwVxdQP9yGmqnsAvE02jogRkQ6ikg4MAqIL1ImHhjrPJU2ADjqXCIrqW48MM6ZHgcsBRCRVs6DBYhIJzwPAmQ47R0XkQHOU2hjC+sYY6q+gydyuf/dH7hrbgJN64ez6PeXMeW6WEs0VUS5z2xUNV9E7gNWAGHAm6qaIiITnfWvAR8Cw4B0IAe4o6S6TtPTgfkiciewExjpLL8CeFJE8oECYKKqHnLW/Q74J1Afz4MB9nCAMVWcqhL/4x6mxadwIjefPw6K4fdXdSG8tg01U5WI5wGxmsvlcmlCQkKowzDG+JB19BSPLk5m9ab9XNSuKc+O6MUF5zcKdVgGEJH1quryt7yNIGCMqXTcbmXeul088+FG8txuHr3uQu64rCNhNtRMlWXJxhhTqWw/cJK4RYl8m3GIgZ1aMH1ET9q3sIEzqzpLNsaYSiG/wM2bX2/jrx9vJjysFs/c0pNRfdvZCADVhCUbY0zIbdp7jEkLEvkx8yiDLmzD0zf14Pwm9UIdlgkgSzbGmJDJzS9g1qdbeeXTdJrUr8PfRl/C9b0i7GymGrJkY4wJiR92HubhBYls2X+Cmy+J5LHrY2nWMDzUYZkgsWRjjKlQOWfy+evHm3nz622c37geb43vy9XdWpde0VRplmyMMRXm6/QDxC1KZNehU9w+oD0PD7mARjZwZo1gycYYE3RHT+Xx52UbeS9hFx1bNuS9CQPo36lFqMMyFciSjTEmqD5O2cujS5I5ePIME6/szB8HxVCvjo1nVtNYsjHGBMWBE7k8Hp/CssQsup3fiH+M60vPqCahDsuEiCUbY0xAqSpLN+zhifdTOJlbwP9d25V7ruxMnTAbOLMms2RjjAmYPUdOMWVxEp+mZXNJtGfgzJg2NnCmsWRjjAkAt1t5e+1OZizfRIFbefyGWMYO7GADZ5qfWLIxxpRLRvYJ4hYmsXb7IX7RpSXP3NKTds0bhDosU8kE5CKqiAwRkTQRSReROB/rRURmOusTRaR3aXVFpLmIrBSRLc57M2f5r0RkvYgkOe+/9KrzmdPWBudl/ylmTJDkF7h57fOtDH3pSzbtPcazt/biX3f2s0RjfCr3mY3zFc2zgF8BmcA6EYlX1VSvYkPxfH1zDNAfeBXoX0rdOGC1qk53klAcMAk4ANygqntEpAeeb/mM9OprjKrat6EZE0Spe47x8MIfSd59jMHd2/DU8B60bmwDZ5riBeIyWj8gXVUzAERkHjAc8E42w4G56vla0G9FpKmIRAAdSqg7HLjKqT8H+AyYpKo/eLWbAtQTkbqqmhuAbTHGlCA3v4CXP0nn1c+20rRBOK+O6c3QnhGhDstUAYFINpHALq/5TDxnL6WViSylbhtVzQJQ1axiLomNAH4okmjeEpECYCHwtPr43msRmQBMAIiOji5564wxAKzfcYiHFySyNfskt/T2DJzZtIENnGn8E4hk4+txk6If8MWV8aeu705FugMzgGu9Fo9R1d0i0ghPsrkdmPuzDlRnA7MBXC6XX/0ZU1OdzM3nuRVpzFmznbZN6jPnt/24smurUIdlqphAJJtMoJ3XfBSwx88y4SXU3SciEc5ZTQSwv7CQiEQBi4Gxqrq1cLmq7nbej4vIO3gu8f0s2Rhj/PPF5mwmL0piz9HCgTO7cV5de4jVlF0gnkZbB8SISEcRCQdGAfFFysQDY52n0gYAR51LZCXVjQfGOdPjgKUAItIUWAZMVtWvCzsQkdoi0tKZrgNcDyQHYPuMqXGO5uTx0H9+ZOyba6lbpxbz7xnIk8N7WKIx56zcR46q5ovIfXieCgsD3lTVFBGZ6Kx/DfgQGAakAznAHSXVdZqeDswXkTuBncBIZ/l9QBdgqohMdZZdC5wEVjiJJgxYBbxe3u0zpqb5KDmLqUtTOHTyDL+/qjP3X2MDZ5ryEx/3z2sUl8ulCQn2pLQx+4+f5vGlKSxP3ktsRGOevbUXPSJt4Ezjm4isV1WXv+XtnNiYGk5VWfj9bp76IJVTeQU8NPgCJlzRyQbONAFlycaYGizzcA5TFifz+eZs+rRvxowRvejS+rxQh2WqIUs2xtRAbrfy7+92MGP5JhSY5gycWcsGzjRBYsnGmBpma/YJ4hYmsm77Ya7o2oo/39yDqGY2npkJLks2xtQQeQVuZn+RwUurt1C/Thh/GXkRI3pHImJnMyb4LNkYUwMk7z7KpIWJpOw5xrCe5zPtxu60bmQDZ5qKY8nGmGrsdF4BM1dv4e9fZNC8YTiv/aY3Q3rYwJmm4lmyMaaaWrf9EJMWJpKRfZKRfaJ49LpYmjSoE+qwTA1lycaYauZEbj7PfrSJuWt2ENm0Pv+6sx+Xx9jAmSa0LNkYU418vjmbR5yBM++4rAP/d+0FNLTxzEwlYEehMdXA4ZNneGpZKou+303nVg1ZMHEgfdo3D3VYxvzEko0xVZiqsjx5L48tTeZITh5/+GUX7vtlF+rWtoEzTeViycaYKmr/sdNMXZrMipR99IhszNzf9ie2beNQh2WMT5ZsjKliVJX/rM/k6Q9Syc13Eze0G3f9oiO1beBMU4lZsjGmCtl1KIdHFifx5ZYD9OvQnOkjetKplQ2caSo/SzbGVAEFbmXumu08tyINAZ66qQdj+kXbwJmmygjIebeIDBGRNBFJF5E4H+tFRGY66xNFpHdpdUWkuYisFJEtznszr3WTnfJpIjLYa3kfEUly1s0UG/TJVAPp+48z8rVveOL9VPp1bM7HD17J7QPaW6IxVUq5k42IhAGzgKFALDBaRGKLFBsKxDivCcCrftSNA1aragyw2pnHWT8K6A4MAV5x2sFpd4JXX0PKu33GhEpegZuXP9nCsJe+IuPASV647SLeGt+XyKb1Qx2aMWUWiMto/YB0Vc0AEJF5wHAg1avMcGCuer6D+lsRaSoiEUCHEuoOB65y6s8BPgMmOcvnqWousE1E0oF+IrIdaKyqa5y25gI3ActLCj4j+yS3/X1NOTbfmMA7mZvP1uyTnMoroHnDcDq0aMC8tbuYt3ZXqEMz5pwE4jJaJOD9G5DpLPOnTEl126hqFoDz3tqPtjJLiQMAEZkgIgkikpCXl1fixhlTkdyq7DyUQ/KeY+S73XRtcx4xrc+zr2g2VV4gzmx8XThWP8v4U9ff/vxuS1VnA7MBXC6XvnfPwFK6NCb4vs04yORFSWQdPc1trnY8ct2FNKlvA2eaymn+xLKVD0SyyQTaec1HAXv8LBNeQt19IhKhqlnOJbf9pbSV6UyXFIcxlc7x03lMX76Jt7/bSbvm9Xn7rv5c1qVlqMMyJqACcW6+DogRkY4iEo7n5n18kTLxwFjnqbQBwFHn0lhJdeOBcc70OGCp1/JRIlJXRDrieRBgrdPecREZ4DyFNtarjjGV0qeb9nPtC1/wztqd/Payjqz44xWWaEy1VO4zG1XNF5H7gBVAGPCmqqaIyERn/WvAh8AwIB3IAe4oqa7T9HRgvojcCewERjp1UkRkPp6HCPKBe1W1wKnzO+CfQH08DwaU+HCAMaFy6OQZnnw/hSUb9hDT+jwW/e5SLoluVnpFY6oo8TwgVnO5XC5NSEgIdRimhlBV3k/MYlp8CsdO5fH7q7tw79WdbeBMU+WIyHpVdflb3kYQMKaC7D16mkeXJLNq4z56RTXh2bv70+18GzjT1AyWbIwJMlVl3rpd/HnZRs4UuJk8tBt32sCZpoaxZGNMEO08mEPcokS+2XqQ/h2bM2NELzq0bBjqsIypcJZsjAmCArfy1tfb+MvHadSpVYs/3dyD0X1t4ExTc1myMSbA0vYeZ9LCRDbsOsI13Vrz9M09iGhi45mZms2SjTEBcibfzSufpTPr03Qa1avDS6Mu5saL2mKDjxtjycaYgPhx1xEeXpBI2r7jDL+4LY9dH0uL8+qGOixjKg1LNsaUw6kzBTy/Mo1/fLWN1o3q8cZYF4Ni24Q6LGMqHUs2xpyjb7YeYPKiJHYczOHX/aOJG9qNxvVs4ExjfLFkY0wZHTudxzMfbuLdtTtp36IB7949gIGdW4Q6LGMqNUs2xpTBqtR9TFmSRPbxXO65ohN/HNSV+uE21IwxpbFkY4wfDp7I5Yn3U4n/cQ/dzm/E7NtdXNSuaajDMqbKsGRjTAlUlfgf9zAtPoUTufk8+KuuTLyyM+G1bagZY8rCko0xxcg6eoopi5P5ZNN+Lm7XlGdv7UXXNo1CHZYxVZIlG2OKcLs9A2c+8+FG8t3K1OtjGX9pB8JsqBljzpklG2O8bD9wkrhFiXybcYhLO7dg+i29iG7RINRhGVPllevCs4g0F5GVIrLFeff5VYMiMkRE0kQkXUTi/KkvIpOd8mkiMthZ1kBElonIJhFJEZHpXuXHi0i2iGxwXneVZ9tMzZJf4Gb2F1sZ/OIXpOw5xowRPXn7rv6WaIwJkPLe5YwDVqtqDLDamT+LiIQBs4ChQCwwWkRiS6rvrB8FdAeGAK847QD8RVW7AZcAl4nIUK/u3lPVi53XG+XcNlNDbMw6xi2vfsOfP9zE5TGtWPXgldzWN9rGNDMmgMqbbIYDc5zpOcBNPsr0A9JVNUNVzwDznHol1R8OzFPVXFXdBqQD/VQ1R1U/BXDa+h6IKuc2mBoqN7+A51du5oa/fcXuw6d4+deX8PrYPrRpXC/UoRlT7ZT3nk0bVc0CUNUsEWnto0wksMtrPhPoX0r9SODbInUivRsVkabADcBLXotHiMgVwGbgAVX17te77gRgAkB0dHRp22iqoe93HmbSgkS27D/BzZdE8tj1sTRrGB7qsIyptkpNNiKyCjjfx6opfvbh61qElqeOiNQG3gVmqmqGs/h94F1VzRWRiXjOlH7pq3FVnQ3MBnC5XKXFYqqRnDP5/PXjzbz59TYiGtfjrfF9ubqbr7+RjDGBVGqyUdVBxa0TkX0iEuGclUQA+30UywTaec1HAXuc6eLql1QHPIlii6q+6BXnQa/1rwMzSt4yU9N8nX6AuEWJ7Dp0it8MiGbSkG40soEzjakQ5b1nEw+Mc6bHAUt9lFkHxIhIRxEJx3PjP76U+vHAKBGpKyIdgRhgLYCIPA00Af7o3YmTrArdCGw8980y1cnRU3lMWpDImDe+o3atWrw3YQBP39TTEo0xFai892ymA/NF5E5gJzASQETaAm+o6jBVzReR+4AVQBjwpqqmlFRfVVNEZD6QCuQD96pqgYhE4bl8twn43nla6GXnybP7ReRGp/whYHw5t81UAx+n7OXRJckcPHmGe67sxAODulKvjg2caUxFE9WafcvC5XJpQkJCqMMwAZZ9PJdp76ewLDGLCyMa8+yIXvSMahLqsIypNkRkvaq6/C1vIwiYakVVWfzDbp78IJWc3AL+79qu3HNlZ+qE2cCZxoSSJRtTbew+coopi5P4LC2b3tGegTO7tLaBM42pDCzZmCrP7Vbe/m4H05dvwq3w2PWxjLOBM42pVCzZmCotI/sEcYuSWLvtEL/o0pJnbulJu+Y2npkxlY0lG1Ml5Re4eeOrbbywcjN1a9fi2RG9GOmKsvHMjKmkLNmYKid1zzEmLUwkafdRBndvw1PDe9DaxjMzplKzZGOqjNN5Bbz8STqvfb6Vpg3q8MqY3gzrGVF6RWNMyFmyMVXC+h2HmLQwifT9JxjRO4qp119I0wY2cKYxVYUlG1OpnczN57kVacxZs522Teoz57f9uLJrq1CHZYwpI0s2ptL6cks2kxclsfvIKcYOaM9DQ7pxXl07ZI2piuw311Q6R3PyeGpZKgvWZ9KpVUPm3zOQvh2ahzosY0w5WLIxlcpHyVlMXZrCoZNn+P1Vnbn/mhgbONOYasCSjakU9h8/zeNLU1ievJfubRvz1vi+9Ii0gTONqS4s2ZiQUlUWfr+bpz5I5VReAQ8PuYC7L+9kA2caU81YsjEhk3k4h0cWJ/PF5mxc7Zsx49ZedG51XqjDMsYEQbn+fBSR5iKyUkS2OO/Niik3RETSRCRdROL8qS8ik53yaSIy2Gv5Z86yDc6rtbO8roi859T5TkQ6lGfbTPC43cqcb7Zz7QtfkLD9EE8O7878ewZaojGmGivvtYo4YLWqxgCrnfmziEgYMAsYCsQCo0UktqT6zvpRQHdgCPCK006hMap6sfPa7yy7Ezisql2AF4AZ5dw2EwRbs0/w//6+hsfjU+jTvhkfP3AFYwd2oJaN0GxMtVbeZDMcmONMzwFu8lGmH5CuqhmqegaY59Qrqf5wYJ6q5qrqNiDdacffWBYA14iNylhp5BW4mfVpOkNf+pIt+0/w15EXMfe3/YhqZiM0G1MTlPeeTRtVzQJQ1azCS1pFRAK7vOYzgf6l1I8Evi1SJ9Jr/i0RKQAWAk+r57utf+pHVfNF5CjQAjhQNCARmQBMAIiOji7D5ppzkbz7KA8vSCQ16xjDep7PEzf2oFWjuqEOyxhTgUpNNiKyCjjfx6opfvbh6+xCy1FnjKruFpFGeJLN7cDcsvSjqrOB2QAul6u0WMw5Op1XwEurtzD7iwyaNwzntd/0ZkgPGzjTmJqo1GSjqoOKWyci+0QkwjkriQD2+yiWCbTzmo8C9jjTxdUvto6q7nbej4vIO3gur831qpMpIrWBJsCh0rbPBMe67YeYtCCRjAMnGdknikevi6VJgzqhDssYEyLlvWcTD4xzpscBS32UWQfEiEhHEQnHc+M/vpT68cAo5wmzjkAMsFZEaotISwARqQNcDyT7aOtW4BPn8pqpQCdy83lsaTIjX1vDmQI3/7qzH8+NvMgSjTE1XHnv2UwH5ovIncBOYCSAiLQF3lDVYc79k/uAFUAY8KaqppRUX1VTRGQ+kArkA/eqaoGINARWOIkmDFgFvO609Q/gXyKSjueMZlQ5t82U0adp+5myKImsY6cZf2kHHhp8AQ1t4ExjDCA1/Y9/l8ulCQkJoQ6jSjt88gxPfZDKoh9206X1ecwY0Ys+7X3+y5UxppoQkfWq6vK3vP3Zac6ZqvJh0l4ej0/mSE4e913dhT9c04W6tW3gTGPM2SzZmHOy79hppi5J5uPUffSMbMLc3/Yntm3jUIdljKmkLNmYMlFV5ifs4ullGzmT7yZuaDfu+kVHatvAmcaYEliyMX7beTCHyYsT+Tr9IP06NmfGiF50bNkw1GEZY6oASzamVAVu5Z/fbOcvK9KoJfDUTT0Y0y/axjMzxvjNko0p0ZZ9x5m0MJHvdx7hqgta8eebe9K2af1Qh2WMqWIs2Rif8grcvPbZVv72SToN64bxwm0XcdPFkdjYpsaYc2HJxvxMYuYRHl6QyKa9x7nhorY8fkMsLc+zgTONMefOko35yem8Al5YuZnXv8ygVaO6zL69D9d29zUGqzHGlI0lGwPAtxkHmbwoiW0HTjK6Xzvihl5Ik/o2npkxJjAs2dRwx0/nMX35Jt7+bifRzRvwzl39ubRLy1CHZYypZizZ1GCfbNrHlMXJ7Dt2mrt+0ZH/vfYC6ofbUDPGmMCzZFMDHTp5hiffT2HJhj10bXMer4y5lEuibeBMY0zwWLKpQVSVDxKzmBafwrHTefzPNTHce3UXwmvbUDPGmOCyZFND7D16mkeXJLNq4z4uimrCjFv70+18GzjTGFMxLNlUc6rKvHW7+POyjeS53Tx63YXccVlHwmyoGWNMBSrX9RMRaS4iK0Vki/Pu88K/iAwRkTQRSReROH/qi8hkp3yaiAx2ljUSkQ1erwMi8qKzbryIZHutu6s821Yd7Dh4kl+//h2TFyXRPbIxH/3PFdx1eSdLNMaYClfei/VxwGpVjQFWO/NnEZEwYBYwFIgFRotIbEn1nfWjgO7AEOAVEQlT1eOqenHhC9gBLPLq7j2v9W+Uc9uqrAK38saXGQx+8QuSdx/lmVt68u7dA+hgIzQbY0KkvJfRhgNXOdNzgM+ASUXK9APSVTUDQETmOfVSS6g/HJinqrnANhFJd9pZU9ioiMQArYEvy7kN1Ura3uM8vDCRH3cd4ZpurXn65h5ENLGBM40xoVXeZNNGVbMAVDVLRFr7KBMJ7PKazwT6l1I/Evi2SJ3IIu2OxnMmo17LRojIFcBm4AFV3YUPIjIBmAAQHR1dyiZWDWfy3bzyWTqzPk2nUb06vDTqYm68qK0NnGmMqRRKTTYisgrwNUDWFD/78PVppz6WlbXOKOB2r/n3gXdVNVdEJuI5U/qlr8ZVdTYwG8DlcpUWS6W3YdcRJi1IJG3fcW50Bs5sYQNnGmMqkVKTjaoOKm6diOwTkQjnrCQC2O+jWCbQzms+CtjjTBdXv6Q6iMhFQG1VXe8V50Gv8q8DM0rbtqru1JkCnl+Zxj++2kbrRvX4xzgX11zYJtRhGWPMz5T3AYF4YJwzPQ5Y6qPMOiBGRDqKSDieM5L4UurHA6NEpK6IdARigLVebY4G3vXuxElWhW4ENp7TFlUR32w9wOAXv+D1L7cxql80Hz94hSUaY0ylVd57NtOB+SJyJ7ATGAkgIm2BN1R1mKrmi8h9wAogDHhTVVNKqq+qKSIyH89DBPnAvapa4NXv/wOGFYnlfhG50Sl/CBhfzm2rlI6dzuOZDzfx7tqddGjRgHfvHsDAzi1CHZYxxpRIzr6/XvO4XC5NSEgIdRh+WZW6jylLksg+nstdl3figUFdbeBMY0xIiMh6VXX5W95GEKgCDp7IZdr7qbz/4x66nd+I18e66BXVNNRhGWOM3yzZVGKqSvyPe5gWn8KJ3HweGNSV313V2QbONMZUOZZsKqk9R07x6JJkPtm0n0uimzJjRC+6tmkU6rCMMeacWLKpZNxu5Z21O5m+fBMFbmXq9bGMv7SDjWdmjKnSLNlUItsOnCRuYSLfbTvEZV1a8MzNvYhu0SDUYRljTLlZsqkE8gvc/OOrbTy/cjPhtWsx/Zae3Na3nQ01Y4ypNizZhNimvceYtCCRHzOP8qvYNjx9Uw/aNK4X6rCMMSagLNmESG5+AbM+3corn6bTpH4d/jb6Eq7vFWFnM8aYasmSTQh8v/MwkxYksmX/CW65JJKp18fSrGF4qMMyxpigsWRTgXLO5POXFZt565ttRDSux1vj+3J1N1/fymCMMdWLJZsK8nX6AeIWJbLr0CluH9Ceh4dcQKN6dUIdljHGVAhLNkF29FQef162kfcSdtGxZUPemzCA/p1s4ExjTM1iySaIVqTsZeqSZA6ePMPvrurM/1wTQ706NnCmMabmsWQTBNnHc5kWn8KypCwujGjMP8b1pWdUk1CHZYwxIWPJJoBUlcU/7ObJD1LJyS3gocEXMOGKTtQJs4EzjTE1myWbANl95BSPLEri883Z9I5uyrO39qJLaxs40xhjoJxfCy0izUVkpYhscd6bFVNuiIikiUi6iMSVVl9EWojIpyJyQkReLtJWHxFJctqaKc5/QTpfIf2es/w7EelQnm0rifvtdzgR0w13WBjHYi5kzswFXPv856zbfohpN8SyYOKllmiMMcZLea/vxAGrVTUGWO3Mn0VEwoBZwFAgFhgtIrGl1D8NTAX+z0efrwITgBjnNcRZfidwWFW7AC8AM8q5bT65336Hgw88xN2uccQ8uIjLrnuCx/fU55Lw06z44xWMv6wjtWyEZmOMOUt5k81wYI4zPQe4yUeZfkC6qmao6hlgnlOv2PqqelJVv8KTdH4iIhFAY1Vdo57vs57r1ad3WwuAawrPegIpZ9qT3H/Nfaxp34uCsNocr9eQzgd28eqcONo1txGajTHGl/ImmzaqmgXgvPv6d/hIYJfXfKazzN/6RdvKLKatn/pR1XzgKODzH1pEZIKIJIhIQnZ2dildnq1BxhbWRcWetWxHswgaZmwpUzvGGFOTlJpsRGSViCT7eA0vrW5hEz6WadnC9Kstv/tR1dmq6lJVV6tWrcoUQE6nGPpmpp61rG9mKjmdYsrUjjHG1CSlJhtVHaSqPXy8lgL7nEtbhZe49vtoIhNo5zUfBexxpv2pX7StqGLa+qkfEakNNAEOlbZ9ZdVg2mPMXP0yA3ckUrsgn4E7Epm5+mUaTHss0F0ZY0y1Ud7LaPHAOGd6HLDUR5l1QIyIdBSRcGCUU8/f+j9xLrUdF5EBzv2YsV51vNu6FfjEua8TULXG/JoWLzzH6wlz2Pz8LbyeMIcWLzxHrTG/DnRXxhhTbUh5Po9FpAUwH4gGdgIjVfWQiLQF3lDVYU65YcCLQBjwpqr+qaT6zrrtQGMgHDgCXKuqqSLiAv4J1AeWA39QVRWResC/gEvwnNGMUtWM0rbB5XJpQkLCOe8DY4ypiURkvaq6/C4fhD/+qxRLNsYYU3ZlTTY2jooxxpigs2RjjDEm6CzZGGOMCTpLNsYYY4Kuxj8gICLZwI5zrN4SOBDAcALF4iobi6vsKmtsFlfZlCeu9qrq93/F1/hkUx4iklCWpzEqisVVNhZX2VXW2CyusqnIuOwymjHGmKCzZGOMMSboLNmUz+xQB1AMi6tsLK6yq6yxWVxlU2Fx2T0bY4wxQWdnNsYYY4LOko0xxpjgU9Ua+QKaAyuBLc57s2LKDQHSgHQgrrT6eL4d9FPgBPBykbb6AElOWzP572XMusB7zvLvgIuCEZuzbrJTPg0Y7CxrBGzweh0AXnTWjQeyneVJQEpFxeUs/8xZVhhbax/7LAH4sgL3VwNgGbDJ2R/Tvcr/FcgHcvF819JdRWIQ52efDiQCvYO034oeaz7bDkZcwK+A9U7/64FflvDzvK0C4+oAnPLq+7VKsr/GcPbvnxu4uLjjP0ixjcRzLLsBV5H2/D3GpMTP3EB9eFe1F/Bs4c4G4oAZPsqEAVuBTni+6uBHILak+kBD4BfARH6ebNYCA52DYTkw1Fn++8IDH8/3/WwMUmyxTrm6QEenfpiPttcDVzjT4wu3I4j7rNi48PyyuXz0473P4oEfKyouPMnmaqdMOJ5EN9RZtx+YW7QPrziGOT97AQYA3wVpvxU91vb4ajtIcV0CtHWmewC7vfr56edZUttBiqsDkFzM50HI9leRdnsCGb72V5D32YXABT76K8sxNrTEz9xAfXhXtReeLB3hTEcAaT7KDARWeM1PBib7Ux+vD2mvMpu85kcDf3emVwADnenaeP4yDnhs3mWK9uu1LAbYxX/Pun7ajmDts5LiKnrwF1MmDTjoHPQVur+c5S8Bdzt9JHntr7PqO8v+DowuehwGMj4fx9pjwC5fbQcjriLtivOzqVv051lS20HaXx3wkWwq2f76M/Anr/mf9lcw91kJ/fl7jP30eVbcqybfs2mjnm/+xHlv7aNMJJ4P3kKZzjJ/6xdtK7OYtn7qR1Xz8fyC5gUhtpLqFBoNvKfOEeQYISKJeP6yqR2CuN4SkQ0iMtX5htaiddrg+YK9FhW9v0SkKXADsNpZd4j/7q+b8fy16E8cgYyv6LHmBtRHuWDF5W0E8IOq5note0tENgD3l9B2sOLqKCI/iMjnInK5Vx+VZX/dBrxbZNlPx38p7ZcntuL4e4yV2lbtUjqq0kRkFXC+j1VT/G3CxzL1sexc2noB6CoiyUAXYJWI5HvFVlo/5xKbP3UeBvaKyBBnPgzPB+hUPL8Ec4BfVmBcY1R1t4h86sR2j4gc4b/7bJKf/QR8f4lIbTz7ZKaqZohIHzzfOHutquaKyFvAID/bDGR8RZeLj7aKzgcyLk+DIt2BGcC1XosLf56NgK+AwxUYVxYQraoHnZ/VEifGyrK/+gM5qprstdh7fy3Ed4IKZmwBa6taJxtVLfqL/hMR2SciEaqaJSIReK61F5UJtPOaj8JzLRfAn/pF24rymv8rcJWq3iMiK4BpqrrG+QBTPNdUCXBsJdVBRC4C9qhqV18bICK7AFdFxqWqu533q0VkPJ5T/PuK7LN9eAYUPFSR+wvPP8RtUdUXvcq39vorfgueM0V/4ggPYHxFjzXh7CdPi25HoONCRKKAxcBYVd1auNzr53lcROKBcRUVl/NzyXWm14vIVqArlWB/OUZR5KymyP56B7gezwM9gY6tOP4eY6W3VdI1tur8Ap7j7Jt1z/ooUxvIwHP5qPCGWnd/6lPkno2zbB2eG3aFN9SGOcvv5ewHBDYFIzagO2ff7MvA6wEBYDrwRJF+IrymlwA7Kyoup62WTpk6wAJgoo999j6QWJH7C3gaz1+atYr0scOrj204Dy54lbmOs2/erg1SfN7H2kd4/qr/WdtBiqupU26Ej5+B989zIZ4nHSsqrlZe+6cTsBtoHur95czXwvMB3qmE/bUAz4MxPtsvT2xedT/j7Hs2/h5jP32eFfuZG+gP8arywvOI8mo8f32u9jro2gIfepUbBmzG8xTGlNLqO+u247n0dMI5gAqf+HAByU5bL/Pfm/D1gP/geYRwLdA7iLFNccqnUeTpEedA6lZk2TN4Hon8Ec9TV2sqKi48T/atx/P4ZgqeG/FhPvbZ98DXFRhXFJ6zz43895HUu5x17+H56zm3cH/ieTKxMEkKMMtpM4mzf7ED9vPk58faz9oOVlzAo8BJzn6ct3UxP8/rKzCuEfz3WP4euKEy7C9n3VXAt0V+93we/0GK7WY8n1W5wD7OfpDA32OsxEefbbgaY4wxQVeTn0YzxhhTQSzZGGOMCTpLNsYYY4LOko0xxpigs2RjjDEm6CzZGGOMCTpLNsYYY4Lu/wOTJNG2O02WOAAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_interval(-0.001, 0.001, lambda x: np.sin(x))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "According to the intermediate value theorem, there must be a solution between $x_1$ and $x_2$ when $f(x_1) * f(x_2) \\le 0$. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Based on these candidate intervals, BrainPy uses Brent's method to find roots $f(x) = 0$. Further, after obtain the value of the root, BrainPy uses automatic differentiation to evaluate the stability of each root solution. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Overall, BrainPy's analysis toolkit shows significant advantages and disadvantages.\n",
-    "\n",
-    "**Pros**: BrainPy uses numerical methods to find roots and evaluate their stabilities, it does not case about how complex your function is. Therefore, it can apply to general problems, including any 1D and 2D dynamical systems, and some part of low-dimensional ($\\ge 3$) dynamical systems (see later sections). Especially, BrainPy's analysis toolkit is highly useful when the mathematical equations are too complex to get analytical solutions (the example please refer to the tutorial [Anlysis of A Decision Making Model](./decision_making_model.ipynb)). \n",
-    "\n",
-    "**Cons**: However, numerical methods used in BrainPy are hard to find fixed points only exist at a moment. Moreover, when ``resolution`` is small, there will be large amount of calculating. Users should pay attention to designing suitable resolution settings."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Mechanism for 2D system analysis"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**plot_vector_field()**\n",
-    "\n",
-    "Plotting vector field is simple. We just need to evaluate the values of each differential equation. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**plot_nullcline()**\n",
-    "\n",
-    "Nullclines are evaluated through the Brent's methods. In order to get all $(x, y)$ values that satisfy ``fx=0`` (i.e., $f_x(x, y) = 0$), we first fix $y=y_0$, then apply Brent optimization to get all $x'$ that satisfy $f_x(x', y_0) = 0$ (alternatively, we can fix $x$ then optimize $y$). Therefore, we will perform Brent optimization many times, because we will iterate over all $y$ value according to the resolution setting. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**plot_fixed_points()**\n",
-    "\n",
-    "The fixed point finding in BrainPy relies on BFGS method. First, we define an auxiliary function $L(x, t)$:\n",
-    "\n",
-    "$$\n",
-    "L(x, y) = f_x^2(x, y) + f_y^2(x, y).\n",
-    "$$\n",
-    "\n",
-    "$L(x, t)$ is always bigger than 0. We use BFGS optimization to get all local minima. Finally, we filter out the minima whose losses are smaller than $1e^{-8}$, and we choose them as fixed points. \n",
-    "\n",
-    "For this method, how to choose the initial points to perform optimization is the challege, especially when the parameter resolutions are small. Generally, there are four methods provided in BrainPy. \n",
-    "\n",
-    "- **fx-nullcline**: Choose the points in \"fx\" nullcline as the initial points for optimization. \n",
-    "- **fy-nullcline**: Choose the points in \"fy\" nullcline as the initial points for optimization. \n",
-    "- **nullclines**: Choose both the points in \"fx\" nullcline and \"fy\" nullcline as the initial points for optimization. \n",
-    "- **aux_rank**: For a given set of parameters, we evaluate loss function at each point according to the resolution setting. Then we choose the first ``num_rank`` (default is 100)  points which have the smallest losses.\n",
-    "\n",
-    "However, if users provide one of functions of ``x_by_y_in_fx``, ``y_by_x_in_fx``, ``x_by_y_in_fy`` and ``y_by_x_in_fy``. Things will become very simple, because we can change the 2D system as a 1D system, then we only need to optimzie the fixed points by using our favoriate Brent optimization. \n",
-    "\n",
-    "For the given FitzHugh-Nagumo model, we can set"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "I am making bifurcation analysis ...\n",
-      "I am trying to find fixed points by brentq optimization ...\n",
-      "I am trying to filter out duplicate fixed points ...\n",
-      "\tFound 5000 fixed points.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
     }
-   ],
-   "source": [
-    "analyzer = bp.analysis.Bifurcation2D(\n",
-    "    model,\n",
-    "    target_vars=dict(V=[-3, 3], w=[-3., 3.]),\n",
-    "    target_pars=dict(a=[0.5, 1.], Iext=[0., 1.]),\n",
-    "    resolutions={'a': 0.01, 'Iext': 0.01},\n",
-    "    options={bp.analysis.C.y_by_x_in_fy: (lambda V, a=0.7, b=0.8: (V + a) / b)}\n",
-    ")\n",
-    "analyzer.plot_bifurcation()\n",
-    "analyzer.show_figure()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
+   },
    "source": [
     "## References\n",
     "\n",
@@ -1294,13 +1141,6 @@
     "\n",
     "[3] Rinzel, John. \"A formal classification of bursting mechanisms in excitable systems.\" In Mathematical topics in population biology, morphogenesis and neurosciences, pp. 267-281. Springer, Berlin, Heidelberg, 1987.\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -1396,4 +1236,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
+}
\ No newline at end of file
diff --git a/docs/tutorial_basics/control_flows.ipynb b/docs/tutorial_basics/control_flows.ipynb
deleted file mode 100644
index 909726b8c..000000000
--- a/docs/tutorial_basics/control_flows.ipynb
+++ /dev/null
@@ -1,1496 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "254bbbf2",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "# Control Flows"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "355bb9b6",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "@[Chaoming Wang](https://github.com/chaoming0625)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Control flow is the core of a program, because it defines the order in which the program's code executes. The control flow of Python is regulated by *conditional statements*, *loops*, and *function calls*.\n",
-    "\n",
-    "Python has two types of control structures:\n",
-    "\n",
-    "- **Selection**: used for decisions and branching.\n",
-    "- **Repetition**: used for looping, i.e., repeating a piece of code multiple times.\n",
-    "\n",
-    "In this section, we are going to talk about how to build effective control flows with BrainPy and JAX."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "id": "465bd161",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "38a2bb50",
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import brainpy as bp\n",
-    "import brainpy.math as bm\n",
-    "\n",
-    "bp.math.set_platform('cpu')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## 1\\. Selection"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "In Python, the selection statements are also known as *Decision control statements* or *branching statements*. The selection statement allows a program to test several conditions and execute instructions based on which condition is true. The commonly used control statements include:\n",
-    "\n",
-    "- if-else\n",
-    "- nested if\n",
-    "- if-elif-else"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### Non-`Variable`-based control statements"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Actually, BrainPy (based on JAX) **allows to write control flows normally like your familiar Python programs, when the conditional statement depends on non-Variable instances**. For example,"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "outputs": [],
-   "source": [
-    "class OddEven(bp.Base):\n",
-    "    def __init__(self, type_=1):\n",
-    "        super(OddEven, self).__init__()\n",
-    "        self.type_ = type_\n",
-    "        self.a = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "    def __call__(self):\n",
-    "        if self.type_ == 1:\n",
-    "            self.a += 1\n",
-    "        elif self.type_ == 2:\n",
-    "            self.a -= 1\n",
-    "        else:\n",
-    "            raise ValueError(f'Unknown type: {self.type_}')\n",
-    "        return self.a"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "In the above example, the target *statement* in ``if (statement)`` syntax relies on a scalar, which is not an instance of [brainpy.math.Variable](./tensors_and_variables.ipynb). In this case, the conditional statements can be arbitrarily complex. You can write your models with normal Python codes. These models will work very well with [JIT compilation](./jit_compilation.ipynb)."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([1.], dtype=float32)"
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model = bm.jit(OddEven(type_=1))\n",
-    "\n",
-    "model()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([-1.], dtype=float32)"
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model = bm.jit(OddEven(type_=2))\n",
-    "\n",
-    "model()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ValueError: Unknown type: 3\n"
-     ]
-    }
-   ],
-   "source": [
-    "try:\n",
-    "    model = bm.jit(OddEven(type_=3))\n",
-    "    model()\n",
-    "except ValueError as e:\n",
-    "    print(f\"ValueError: {str(e)}\")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### `Variable`-based control statements"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "However, if the `statement` target in a ``if ... else ...`` syntax relies on instances of [brainpy.math.Variable](./tensors_and_variables.ipynb), writing Pythonic control flows will cause errors when using JIT compilation."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "outputs": [],
-   "source": [
-    "class OddEvenCauseError(bp.Base):\n",
-    "    def __init__(self):\n",
-    "        super(OddEvenCauseError, self).__init__()\n",
-    "        self.rand = bm.Variable(bm.random.random(1))\n",
-    "        self.a = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "    def __call__(self):\n",
-    "        if self.rand < 0.5:  self.a += 1\n",
-    "        else:  self.a -= 1\n",
-    "        return self.a"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ConcretizationTypeError: This problem may be caused by several ways:\n",
-      "1. Your if-else conditional statement relies on instances of brainpy.math.Variable. \n",
-      "2. Your if-else conditional statement relies on functional arguments which do not set in \"static_argnames\" when applying JIT compilation. More details please see https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError\n",
-      "3. The static variables which set in the \"static_argnames\" are provided as arguments, not keyword arguments, like \"jit_f(v1, v2)\" [<- wrong]. Please write it as \"jit_f(static_k1=v1, static_k2=v2)\" [<- right].\n"
-     ]
-    }
-   ],
-   "source": [
-    "wrong_model = bm.jit(OddEvenCauseError())\n",
-    "\n",
-    "try:\n",
-    "    wrong_model()\n",
-    "except Exception as e:\n",
-    "    print(f\"{e.__class__.__name__}: {str(e)}\")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "To perform conditional statement on [Variable](./tensors_and_variables.ipynb) instances, we need structural control flow syntax. Specifically, BrainPy provides several options (based on JAX):\n",
-    "\n",
-    "- [brainpy.math.where](https://numpy.org/doc/stable/reference/generated/numpy.where.html): return element-wise conditional comparison results.\n",
-    "- [brainpy.math.ifelse](../apis/auto/math/generated/brainpy.math.controls.ifelse.rst): Conditional statements of `if-else`, or `if-elif-else`, ... for a scalar-typed value."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### `brainpy.math.where`"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "``where(condition, x, y)`` function returns elements chosen from *x* or *y* depending on *condition*. It can perform well on scalars, vectors, and high-dimensional arrays."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "JaxArray(1., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = 1.\n",
-    "bm.where(a < 0, 0., 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "JaxArray([1., 0., 0., 1., 1.], dtype=float32, weak_type=True)"
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = bm.random.random(5)\n",
-    "bm.where(a < 0.5, 0., 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "JaxArray([[0., 0., 1.],\n          [1., 1., 0.],\n          [0., 0., 0.]], dtype=float32, weak_type=True)"
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = bm.random.random((3, 3))\n",
-    "bm.where(a < 0.5, 0., 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "For the above example, we can rewrite it by using `where` syntax as:"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "outputs": [],
-   "source": [
-    "class OddEvenWhere(bp.Base):\n",
-    "    def __init__(self):\n",
-    "        super(OddEvenWhere, self).__init__()\n",
-    "        self.rand = bm.Variable(bm.random.random(1))\n",
-    "        self.a = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "    def __call__(self):\n",
-    "        self.a += bm.where(self.rand < 0.5, 1., -1.)\n",
-    "        return self.a"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([-1.], dtype=float32)"
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model = bm.jit(OddEvenWhere())\n",
-    "model()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### `brainpy.math.ifelse`"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Based on JAX's control flow syntax [jax.lax.cond](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.cond.html), BrainPy provides a more general conditional statement enabling multiple branching.\n",
-    "\n",
-    "In its simplest case, `brainpy.math.ifelse(condition, branches, operands, dyn_vars=None)` is equivalent to:\n",
-    "\n",
-    "```python\n",
-    "def ifelse(condition, branches, operands, dyn_vars=None):\n",
-    "  true_fun, false_fun = branches\n",
-    "  if condition:\n",
-    "    return true_fun(operands)\n",
-    "  else:\n",
-    "    return false_fun(operands)\n",
-    "```"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Based on this function, we can rewrite the above example by using `cond` syntax as:"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "outputs": [],
-   "source": [
-    "class OddEvenCond(bp.Base):\n",
-    "    def __init__(self):\n",
-    "        super(OddEvenCond, self).__init__()\n",
-    "        self.rand = bm.Variable(bm.random.random(1))\n",
-    "        self.a = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "    def __call__(self):\n",
-    "        self.a += bm.ifelse(self.rand[0] < 0.5,\n",
-    "                            [lambda _: 1., lambda _: -1.])\n",
-    "        return self.a"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([1.], dtype=float32)"
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model = bm.jit(OddEvenCond())\n",
-    "model()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "If you want to write control flows with multiple branchings, ``brainpy.math.ifelse(conditions, branches, operands, dyn_vars=None)`` can also help you accomplish this easily. Actually, multiple branching case is equivalent to:\n",
-    "\n",
-    "```python\n",
-    "def ifelse(conditions, branches, operands, dyn_vars=None):\n",
-    "  pred1, pred2, ... = conditions\n",
-    "  func1, func2, ..., funcN = branches\n",
-    "  if pred1:\n",
-    "    return func1(operands)\n",
-    "  elif pred2:\n",
-    "    return func2(operands)\n",
-    "  ...\n",
-    "  else:\n",
-    "    return funcN(operands)\n",
-    "```"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "For example, if you have the following code:\n",
-    "\n",
-    "```python\n",
-    "def f(a):\n",
-    "  if a > 10:\n",
-    "    return 1.\n",
-    "  elif a > 5:\n",
-    "    return 2.\n",
-    "  elif a > 0:\n",
-    "    return 3.\n",
-    "  elif a > -5:\n",
-    "    return 4.\n",
-    "  else:\n",
-    "    return 5.\n",
-    "```\n",
-    "\n",
-    "It can be expressed as:"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "outputs": [],
-   "source": [
-    "def f(a):\n",
-    "  return bm.ifelse(conditions=[a > 10, a > 5, a > 0, a > -5],\n",
-    "                   branches=[1., 2., 3., 4., 5.])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(1., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f(11.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f(6.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(3., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f(1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(4., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f(-4.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(5., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f(-6.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "A more complex example is:"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "outputs": [],
-   "source": [
-    "def f2(a, x):\n",
-    "  return bm.ifelse(conditions=[a > 10, a > 5, a > 0, a > -5],\n",
-    "                   branches=[lambda x: x*2,\n",
-    "                             2.,\n",
-    "                             lambda x: x**2 -1,\n",
-    "                             lambda x: x - 4.,\n",
-    "                             5.],\n",
-    "                   operands=x)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f2(11, 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f2(6, 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(0., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f2(1, 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(-3., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f2(-4, 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "DeviceArray(5., dtype=float32, weak_type=True)"
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "f2(-6, 1.)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "If instances of `brainpy.math.Variable` are used in branching functions, you can declare them in the `dyn_vars` argument."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "a: Variable([1., 1.], dtype=float32)\n",
-      "b: Variable([0., 0.], dtype=float32)\n"
-     ]
-    }
-   ],
-   "source": [
-    "a = bm.Variable(bm.zeros(2))\n",
-    "b = bm.Variable(bm.ones(2))\n",
-    "def true_f(x):  a.value += 1\n",
-    "def false_f(x): b.value -= 1\n",
-    "\n",
-    "bm.ifelse(True, [true_f, false_f], dyn_vars=[a, b])\n",
-    "bm.ifelse(False, [true_f, false_f], dyn_vars=[a, b])\n",
-    "\n",
-    "print('a:', a)\n",
-    "print('b:', b)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## 2\\. Repetition"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "A repetition statement is used to repeat a group(block) of programming instructions.\n",
-    "\n",
-    "In Python, we generally have two loops/repetitive statements:\n",
-    "\n",
-    "- **for loop**: Execute a set of statements once for each item in a sequence.\n",
-    "- **while loop**: Execute a block of statements repeatedly until a given condition is satisfied."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### Pythonic loop syntax"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Actually, JAX enables to write Pythonic loops. You just need to iterate over you sequence data and then apply your logic on the iterated items. Such kind of Pythonic loop syntax can be compatible with JIT compilation, but will cause long time to trace and compile. For example,"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "outputs": [],
-   "source": [
-    "class LoopSimple(bp.Base):\n",
-    "    def __init__(self):\n",
-    "        super(LoopSimple, self).__init__()\n",
-    "        rng = bm.random.RandomState(123)\n",
-    "        self.seq = rng.random(1000)\n",
-    "        self.res = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "    def __call__(self):\n",
-    "        for s in self.seq:\n",
-    "            self.res += s\n",
-    "        return self.res.value"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "\n",
-    "def measure_time(f):\n",
-    "    t0 = time.time()\n",
-    "    r = f()\n",
-    "    t1 = time.time()\n",
-    "    print(f'Result: {r}, Time: {t1 - t0}')"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Result: [501.74673], Time: 2.7157142162323\n"
-     ]
-    }
-   ],
-   "source": [
-    "model = bm.jit(LoopSimple())\n",
-    "\n",
-    "# First time will trigger compilation\n",
-    "measure_time(model)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Result: [1003.49347], Time: 0.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Second running\n",
-    "measure_time(model)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "When the model is complex and the iteration is long, the compilation during the first running will become unbearable. For such cases, you need structural loop syntax."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "JAX has provided several important loop syntax, including:\n",
-    "- [jax.lax.fori_loop](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.fori_loop.html)\n",
-    "- [jax.lax.scan](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.scan.html)\n",
-    "- [jax.lax.while_loop](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.while_loop.html)\n",
-    "\n",
-    "BrainPy also provides its own loop syntax, which is especially suitable for the cases where users are using `brainpy.math.Variable`. Specifically, they are:\n",
-    "\n",
-    "- [brainpy.math.make_loop](https://brainpy.readthedocs.io/en/latest/apis/auto/math/generated/brainpy.math.controls.make_loop.html)\n",
-    "- [brainpy.math.make_while](https://brainpy.readthedocs.io/en/latest/apis/auto/math/generated/brainpy.math.controls.make_while.html)\n",
-    "\n",
-    "In this section, we only talk about how to use our provided loop functions."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### ``brainpy.math.make_loop()``"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "``brainpy.math.make_loop()`` is used to generate a for-loop function when you use ``Variable``.\n",
-    "\n",
-    "Suppose that you are using several JaxArrays (grouped as ``dyn_vars``) to implement your body function \"body\\_fun\", and you want to gather the history values of several of them (grouped as ``out_vars``). Sometimes the body function already returns something, and you also want to gather the returned values. With the Python syntax, it can be realized as\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "def for_loop_function(body_fun, dyn_vars, out_vars, xs):\n",
-    "  ys = []\n",
-    "  for x in xs:\n",
-    "    # 'dyn_vars' and 'out_vars' are updated in 'body_fun()'\n",
-    "    results = body_fun(x)\n",
-    "    ys.append([out_vars, results])\n",
-    "  return ys\n",
-    "\n",
-    "```"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "In BrainPy, you can define this logic using ``brainpy.math.make_loop()``:\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=False)\n",
-    "\n",
-    "hist_of_out_vars = loop_fun(xs)\n",
-    "```\n",
-    "\n",
-    "Or,\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=True)\n",
-    "\n",
-    "hist_of_out_vars, hist_of_return_vars = loop_fun(xs)\n",
-    "```\n"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "For the above example, we can rewrite it by using ``brainpy.math.make_loop`` as:"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "outputs": [],
-   "source": [
-    "class LoopStruct(bp.Base):\n",
-    "    def __init__(self):\n",
-    "        super(LoopStruct, self).__init__()\n",
-    "        rng = bm.random.RandomState(123)\n",
-    "        self.seq = rng.random(1000)\n",
-    "        self.res = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "        def add(s): self.res += s\n",
-    "        self.loop = bm.make_loop(add, dyn_vars=[self.res])\n",
-    "\n",
-    "    def __call__(self):\n",
-    "        self.loop(self.seq)\n",
-    "        return self.res.value"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Result: [501.74664], Time: 0.028011560440063477\n"
-     ]
-    }
-   ],
-   "source": [
-    "model = bm.jit(LoopStruct())\n",
-    "\n",
-    "# First time will trigger compilation\n",
-    "measure_time(model)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Result: [1003.4931], Time: 0.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Second running\n",
-    "measure_time(model)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### ``brainpy.math.make_while()``"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "``brainpy.math.make_while()`` is used to generate a while-loop function when you use ``JaxArray``. It supports the following loop logic:\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "while condition:\n",
-    "    statements\n",
-    "```\n",
-    "\n",
-    "When using ``brainpy.math.make_while()`` , *condition* should be wrapped as a ``cond_fun`` function which returns a boolean value, and *statements* should be packed as a ``body_fun`` function which does not support returned values:\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "while cond_fun(x):\n",
-    "    body_fun(x)\n",
-    "```\n",
-    "\n",
-    "where ``x`` is the external input that is not iterated. All the iterated variables should be marked as ``JaxArray``. All ``JaxArray``s used in ``cond_fun`` and ``body_fun`` should be declared as ``dyn_vars`` variables."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Let's look an example:"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "outputs": [],
-   "source": [
-    "i = bm.Variable(bm.zeros(1))\n",
-    "counter = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "def cond_f(x):\n",
-    "    return i[0] < 10\n",
-    "\n",
-    "def body_f(x):\n",
-    "    i.value += 1.\n",
-    "    counter.value += i\n",
-    "\n",
-    "loop = bm.make_while(cond_f, body_f, dyn_vars=[i, counter])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "In the above example, we try to implement a sum from 0 to 10 by using two JaxArrays ``i`` and ``counter``."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "outputs": [],
-   "source": [
-    "loop()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([55.], dtype=float32)"
-     },
-     "execution_count": 58,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "counter"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([10.], dtype=float32)"
-     },
-     "execution_count": 59,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "i"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "main_language": "python"
-  },
-  "kernelspec": {
-   "name": "python3",
-   "language": "python",
-   "display_name": "Python 3 (ipykernel)"
-  },
-  "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.8.8"
-  },
-  "latex_envs": {
-   "LaTeX_envs_menu_present": true,
-   "autoclose": false,
-   "autocomplete": true,
-   "bibliofile": "biblio.bib",
-   "cite_by": "apalike",
-   "current_citInitial": 1,
-   "eqLabelWithNumbers": true,
-   "eqNumInitial": 1,
-   "hotkeys": {
-    "equation": "Ctrl-E",
-    "itemize": "Ctrl-I"
-   },
-   "labels_anchors": false,
-   "latex_user_defs": false,
-   "report_style_numbering": false,
-   "user_envs_cfg": false
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": false,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {
-    "height": "calc(100% - 180px)",
-    "left": "10px",
-    "top": "150px",
-    "width": "279.273px"
-   },
-   "toc_section_display": true,
-   "toc_window_display": true
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
\ No newline at end of file
diff --git a/docs/tutorial_math/control_flows.ipynb b/docs/tutorial_math/control_flows.ipynb
index b96d1ee67..909726b8c 100644
--- a/docs/tutorial_math/control_flows.ipynb
+++ b/docs/tutorial_math/control_flows.ipynb
@@ -21,10 +21,28 @@
     }
    },
    "source": [
-    "@[Chaoming Wang](https://github.com/chaoming0625)\n",
-    "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)"
+    "@[Chaoming Wang](https://github.com/chaoming0625)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Control flow is the core of a program, because it defines the order in which the program's code executes. The control flow of Python is regulated by *conditional statements*, *loops*, and *function calls*.\n",
+    "\n",
+    "Python has two types of control structures:\n",
+    "\n",
+    "- **Selection**: used for decisions and branching.\n",
+    "- **Repetition**: used for looping, i.e., repeating a piece of code multiple times.\n",
+    "\n",
+    "In this section, we are going to talk about how to build effective control flows with BrainPy and JAX."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
   {
    "cell_type": "markdown",
    "id": "465bd161",
@@ -33,17 +51,11 @@
      "name": "#%% md\n"
     }
    },
-   "source": [
-    "In this section, we are going to talk about how to build structured control flows with the BrainPy data structure ``JaxArray``. These control flows include \n",
-    "\n",
-    "- the *for loop* syntax, \n",
-    "- the *while loop* syntax,  \n",
-    "- and the *condition* syntax. "
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "id": "38a2bb50",
    "metadata": {
     "pycharm": {
@@ -60,197 +72,318 @@
   },
   {
    "cell_type": "markdown",
-   "id": "5bc0144f",
+   "source": [
+    "## 1\\. Selection"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "In JAX, the control flow syntax must be defined as [structured control flows](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#structured-control-flow-primitives). the ``JaxArray`` in BrainPy provides an easier syntax to make control flows. "
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "208c28c6",
+   "source": [
+    "In Python, the selection statements are also known as *Decision control statements* or *branching statements*. The selection statement allows a program to test several conditions and execute instructions based on which condition is true. The commonly used control statements include:\n",
+    "\n",
+    "- if-else\n",
+    "- nested if\n",
+    "- if-elif-else"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "```{note}\n",
-    "All the control flow syntax below is not re-implementations of JAX's API for control flows. We only gurantee the following APIs are useful and intuitive when you use ``brainpy.math.JaxArray``. \n",
-    "```"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "5ae453ca",
+   "source": [
+    "### Non-`Variable`-based control statements"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "## ``brainpy.math.make_loop()``"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "cba23344",
+   "source": [
+    "Actually, BrainPy (based on JAX) **allows to write control flows normally like your familiar Python programs, when the conditional statement depends on non-Variable instances**. For example,"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
    "source": [
-    "``brainpy.math.make_loop()`` is used to generate a for-loop function when you use ``JaxArray``. \n",
-    "\n",
-    "Suppose that you are using several JaxArrays (grouped as ``dyn_vars``) to implement your body function \"body\\_fun\", and you want to gather the history values of several of them (grouped as ``out_vars``). Sometimes the body function already returns something, and you also want to gather the returned values. With the Python syntax, it can be realized as \n",
-    "\n",
-    "```python\n",
-    "\n",
-    "def for_loop_function(body_fun, dyn_vars, out_vars, xs):\n",
-    "  ys = []\n",
-    "  for x in xs:\n",
-    "    # 'dyn_vars' and 'out_vars' are updated in 'body_fun()'\n",
-    "    results = body_fun(x)\n",
-    "    ys.append([out_vars, results])\n",
-    "  return ys\n",
+    "class OddEven(bp.Base):\n",
+    "    def __init__(self, type_=1):\n",
+    "        super(OddEven, self).__init__()\n",
+    "        self.type_ = type_\n",
+    "        self.a = bm.Variable(bm.zeros(1))\n",
     "\n",
-    "```"
-   ]
+    "    def __call__(self):\n",
+    "        if self.type_ == 1:\n",
+    "            self.a += 1\n",
+    "        elif self.type_ == 2:\n",
+    "            self.a -= 1\n",
+    "        else:\n",
+    "            raise ValueError(f'Unknown type: {self.type_}')\n",
+    "        return self.a"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "4cbe47d3",
+   "source": [
+    "In the above example, the target *statement* in ``if (statement)`` syntax relies on a scalar, which is not an instance of [brainpy.math.Variable](./tensors_and_variables.ipynb). In this case, the conditional statements can be arbitrarily complex. You can write your models with normal Python codes. These models will work very well with [JIT compilation](./jit_compilation.ipynb)."
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([1.], dtype=float32)"
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "In BrainPy, you can define this logic using ``brainpy.math.make_loop()``:\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=False)\n",
-    "\n",
-    "hist_of_out_vars = loop_fun(xs)\n",
-    "```\n",
-    "\n",
-    "Or, \n",
-    "\n",
-    "```python\n",
+    "model = bm.jit(OddEven(type_=1))\n",
     "\n",
-    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=True)\n",
+    "model()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([-1.], dtype=float32)"
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = bm.jit(OddEven(type_=2))\n",
     "\n",
-    "hist_of_out_vars, hist_of_return_vars = loop_fun(xs)\n",
-    "```\n"
-   ]
+    "model()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ValueError: Unknown type: 3\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    model = bm.jit(OddEven(type_=3))\n",
+    "    model()\n",
+    "except ValueError as e:\n",
+    "    print(f\"ValueError: {str(e)}\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "b34396d6",
+   "source": [
+    "### `Variable`-based control statements"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
-    "Let's implement a recurrent network to illustrate how to use this function. "
-   ]
+    "However, if the `statement` target in a ``if ... else ...`` syntax relies on instances of [brainpy.math.Variable](./tensors_and_variables.ipynb), writing Pythonic control flows will cause errors when using JIT compilation."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "dd570c81",
+   "execution_count": 6,
+   "outputs": [],
+   "source": [
+    "class OddEvenCauseError(bp.Base):\n",
+    "    def __init__(self):\n",
+    "        super(OddEvenCauseError, self).__init__()\n",
+    "        self.rand = bm.Variable(bm.random.random(1))\n",
+    "        self.a = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "    def __call__(self):\n",
+    "        if self.rand < 0.5:  self.a += 1\n",
+    "        else:  self.a -= 1\n",
+    "        return self.a"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ConcretizationTypeError: This problem may be caused by several ways:\n",
+      "1. Your if-else conditional statement relies on instances of brainpy.math.Variable. \n",
+      "2. Your if-else conditional statement relies on functional arguments which do not set in \"static_argnames\" when applying JIT compilation. More details please see https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError\n",
+      "3. The static variables which set in the \"static_argnames\" are provided as arguments, not keyword arguments, like \"jit_f(v1, v2)\" [<- wrong]. Please write it as \"jit_f(static_k1=v1, static_k2=v2)\" [<- right].\n"
+     ]
+    }
+   ],
    "source": [
-    "class RNN(bp.dyn.DynamicalSystem):\n",
-    "  def __init__(self, n_in, n_h, n_out, n_batch, g=1.0, **kwargs):\n",
-    "    super(RNN, self).__init__(**kwargs)\n",
-    "\n",
-    "    # parameters\n",
-    "    self.n_in = n_in\n",
-    "    self.n_h = n_h\n",
-    "    self.n_out = n_out\n",
-    "    self.n_batch = n_batch\n",
-    "    self.g = g\n",
-    "\n",
-    "    # weights\n",
-    "    self.w_ir = bm.TrainVar(bm.random.normal(scale=1 / n_in ** 0.5, size=(n_in, n_h)))\n",
-    "    self.w_rr = bm.TrainVar(bm.random.normal(scale=g / n_h ** 0.5, size=(n_h, n_h)))\n",
-    "    self.b_rr = bm.TrainVar(bm.zeros((n_h,)))\n",
-    "    self.w_ro = bm.TrainVar(bm.random.normal(scale=1 / n_h ** 0.5, size=(n_h, n_out)))\n",
-    "    self.b_ro = bm.TrainVar(bm.zeros((n_out,)))\n",
+    "wrong_model = bm.jit(OddEvenCauseError())\n",
     "\n",
-    "    # variables\n",
-    "    self.h = bm.Variable(bm.random.random((n_batch, n_h)))\n",
-    "\n",
-    "    # function\n",
-    "    self.predict = bm.make_loop(self.cell,\n",
-    "                                dyn_vars=self.vars(),\n",
-    "                                out_vars=self.h,\n",
-    "                                has_return=True)\n",
-    "\n",
-    "  def cell(self, x):\n",
-    "    self.h.value = bm.tanh(self.h @ self.w_rr + x @ self.w_ir + self.b_rr)\n",
-    "    o = self.h @ self.w_ro + self.b_ro\n",
-    "    return o\n",
-    "\n",
-    "\n",
-    "rnn = RNN(n_in=10, n_h=100, n_out=3, n_batch=5)"
-   ]
+    "try:\n",
+    "    wrong_model()\n",
+    "except Exception as e:\n",
+    "    print(f\"{e.__class__.__name__}: {str(e)}\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "aa61848e",
+   "source": [
+    "To perform conditional statement on [Variable](./tensors_and_variables.ipynb) instances, we need structural control flow syntax. Specifically, BrainPy provides several options (based on JAX):\n",
+    "\n",
+    "- [brainpy.math.where](https://numpy.org/doc/stable/reference/generated/numpy.where.html): return element-wise conditional comparison results.\n",
+    "- [brainpy.math.ifelse](../apis/auto/math/generated/brainpy.math.controls.ifelse.rst): Conditional statements of `if-else`, or `if-elif-else`, ... for a scalar-typed value."
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "In the above `RNN` model, we define a body function ``RNN.cell`` for later for-loop over input values. The loop function is defined as ``self.predict`` with ``bm.make_loop()``. We care about the history values of \"self.h\" and the readout value \"o\", so we set ``out_vars=self.h`` and ``has_return=True``.  "
-   ]
+   }
   },
   {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "0bd5330a",
+   "cell_type": "markdown",
+   "source": [
+    "### `brainpy.math.where`"
+   ],
    "metadata": {
-    "lines_to_next_cell": 2,
+    "collapsed": false,
     "pycharm": {
-     "name": "#%%\n"
+     "name": "#%% md\n"
     }
-   },
-   "outputs": [],
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
-    "xs = bm.random.random((100, rnn.n_in))\n",
-    "hist_h, hist_o = rnn.predict(xs)"
-   ]
+    "``where(condition, x, y)`` function returns elements chosen from *x* or *y* depending on *condition*. It can perform well on scalars, vectors, and high-dimensional arrays."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "18b8d270",
+   "execution_count": 8,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "JaxArray(1., dtype=float32, weak_type=True)"
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = 1.\n",
+    "bm.where(a < 0, 0., 1.)"
+   ],
    "metadata": {
-    "scrolled": true,
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "outputs": [
     {
      "data": {
-      "text/plain": "(100, 5, 100)"
+      "text/plain": "JaxArray([1., 0., 0., 1., 1.], dtype=float32, weak_type=True)"
      },
      "execution_count": 10,
      "metadata": {},
@@ -258,22 +391,23 @@
     }
    ],
    "source": [
-    "hist_h.shape  # the shape should be (num_time,) + h.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "3424de49",
+    "a = bm.random.random(5)\n",
+    "bm.where(a < 0.5, 0., 1.)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
    "outputs": [
     {
      "data": {
-      "text/plain": "(100, 5, 3)"
+      "text/plain": "JaxArray([[0., 0., 1.],\n          [1., 1., 0.],\n          [0., 0., 0.]], dtype=float32, weak_type=True)"
      },
      "execution_count": 11,
      "metadata": {},
@@ -281,64 +415,57 @@
     }
    ],
    "source": [
-    "hist_o.shape  # the shape should be (num_time, ) + o.shape"
-   ]
+    "a = bm.random.random((3, 3))\n",
+    "bm.where(a < 0.5, 0., 1.)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "3328d9aa",
+   "source": [
+    "For the above example, we can rewrite it by using `where` syntax as:"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "If you have multiple input values, you should wrap them as a container and call the loop function with ``loop_fun(xs)``, where \"xs\" can be a JaxArray or a list/tuple/dict of JaxArray. For example: "
-   ]
+   }
   },
   {
    "cell_type": "code",
    "execution_count": 12,
-   "id": "c4159b0b",
+   "outputs": [],
+   "source": [
+    "class OddEvenWhere(bp.Base):\n",
+    "    def __init__(self):\n",
+    "        super(OddEvenWhere, self).__init__()\n",
+    "        self.rand = bm.Variable(bm.random.random(1))\n",
+    "        self.a = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "    def __call__(self):\n",
+    "        self.a += bm.where(self.rand < 0.5, 1., -1.)\n",
+    "        return self.a"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n          [ 3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.],\n          [ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n          [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n          [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n          [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n          [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n          [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n          [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n          [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]],            dtype=float32)"
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = bm.Variable(bm.zeros(10))\n",
-    "\n",
-    "def body(x):\n",
-    "    x1, x2 = x  # \"x\" is a tuple/list of JaxArray\n",
-    "    a.value += (x1 + x2)\n",
-    "\n",
-    "loop = bm.make_loop(body, dyn_vars=[a], out_vars=a)\n",
-    "loop(xs=[bm.arange(10), bm.ones(10)])"
-   ]
+   }
   },
   {
    "cell_type": "code",
    "execution_count": 13,
-   "id": "65c1c1e7",
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
    "outputs": [
     {
      "data": {
-      "text/plain": "Variable([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n          [ 3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.,  3.],\n          [ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n          [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n          [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n          [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n          [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n          [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n          [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n          [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]],            dtype=float32)"
+      "text/plain": "Variable([-1.], dtype=float32)"
      },
      "execution_count": 13,
      "metadata": {},
@@ -346,447 +473,964 @@
     }
    ],
    "source": [
-    "a = bm.Variable(bm.zeros(10))\n",
-    "\n",
-    "def body(x):  # \"x\" is a dict of JaxArray\n",
-    "    a.value += x['a'] + x['b']\n",
-    "\n",
-    "loop = bm.make_loop(body, dyn_vars=[a], out_vars=a)\n",
-    "loop(xs={'a': bm.arange(10), 'b': bm.ones(10)})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f3d07cc8",
+    "model = bm.jit(OddEvenWhere())\n",
+    "model()"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
-     "name": "#%% md\n"
+     "name": "#%%\n"
     }
-   },
-   "source": [
-    "``dyn_vars``, ``out_vars``, ``xs`` and the body function returns can be arrays with the container structure like tuple/list/dict. The history output values will preserve the container structure of ``out_vars``and body function returns. If ``has_return=True``, the loop function will return a tuple of ``(hist_of_out_vars, hist_of_fun_returns)``. If no values are interested, please set ``out_vars=None``, and the loop function only returns ``hist_of_out_vars``. "
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "34b56543",
+   "source": [
+    "### `brainpy.math.ifelse`"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "## ``brainpy.math.make_while()``"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "f39450ce",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
    "source": [
-    "``brainpy.math.make_while()`` is used to generate a while-loop function when you use ``JaxArray``. It supports the following loop logic:\n",
-    "\n",
-    "```python\n",
+    "Based on JAX's control flow syntax [jax.lax.cond](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.cond.html), BrainPy provides a more general conditional statement enabling multiple branching.\n",
     "\n",
-    "while condition:\n",
-    "    statements\n",
-    "```\n",
-    "\n",
-    "When using ``brainpy.math.make_while()`` , *condition* should be wrapped as a ``cond_fun`` function which returns a boolean value, and *statements* should be packed as a ``body_fun`` function which does not support returned values: \n",
+    "In its simplest case, `brainpy.math.ifelse(condition, branches, operands, dyn_vars=None)` is equivalent to:\n",
     "\n",
     "```python\n",
-    "\n",
-    "while cond_fun(x):\n",
-    "    body_fun(x)\n",
-    "```\n",
-    "\n",
-    "where ``x`` is the external input that is not iterated. All the iterated variables should be marked as ``JaxArray``. All ``JaxArray``s used in ``cond_fun`` and ``body_fun`` should be declared as ``dyn_vars`` variables. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "276775fd",
+    "def ifelse(condition, branches, operands, dyn_vars=None):\n",
+    "  true_fun, false_fun = branches\n",
+    "  if condition:\n",
+    "    return true_fun(operands)\n",
+    "  else:\n",
+    "    return false_fun(operands)\n",
+    "```"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "Let's look an example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "21056150",
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "i = bm.Variable(bm.zeros(1))\n",
-    "counter = bm.Variable(bm.zeros(1))\n",
-    "\n",
-    "def cond_f(x): \n",
-    "    return i[0] < 10\n",
-    "\n",
-    "def body_f(x):\n",
-    "    i.value += 1.\n",
-    "    counter.value += i\n",
-    "\n",
-    "loop = bm.make_while(cond_f, body_f, dyn_vars=[i, counter])"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "e68a758d",
+   "source": [
+    "Based on this function, we can rewrite the above example by using `cond` syntax as:"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "In the above example, we try to implement a sum from 0 to 10 by using two JaxArrays ``i`` and ``counter``. "
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "5e23e1bd",
+   "execution_count": 39,
+   "outputs": [],
+   "source": [
+    "class OddEvenCond(bp.Base):\n",
+    "    def __init__(self):\n",
+    "        super(OddEvenCond, self).__init__()\n",
+    "        self.rand = bm.Variable(bm.random.random(1))\n",
+    "        self.a = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "    def __call__(self):\n",
+    "        self.a += bm.ifelse(self.rand[0] < 0.5,\n",
+    "                            [lambda _: 1., lambda _: -1.])\n",
+    "        return self.a"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
-   "source": [
-    "loop()"
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "id": "3ad97ccb",
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 40,
    "outputs": [
     {
      "data": {
-      "text/plain": "Variable([55.], dtype=float32)"
+      "text/plain": "Variable([1.], dtype=float32)"
      },
-     "execution_count": 16,
+     "execution_count": 40,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "counter"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "1025f8e2",
+    "model = bm.jit(OddEvenCond())\n",
+    "model()"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "Variable([10.], dtype=float32)"
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "i"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "57b6f203",
+   "source": [
+    "If you want to write control flows with multiple branchings, ``brainpy.math.ifelse(conditions, branches, operands, dyn_vars=None)`` can also help you accomplish this easily. Actually, multiple branching case is equivalent to:\n",
+    "\n",
+    "```python\n",
+    "def ifelse(conditions, branches, operands, dyn_vars=None):\n",
+    "  pred1, pred2, ... = conditions\n",
+    "  func1, func2, ..., funcN = branches\n",
+    "  if pred1:\n",
+    "    return func1(operands)\n",
+    "  elif pred2:\n",
+    "    return func2(operands)\n",
+    "  ...\n",
+    "  else:\n",
+    "    return funcN(operands)\n",
+    "```"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "## ``brainpy.math.make_cond()``"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "b1de2b36",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
    "source": [
-    "``brainpy.math.make_cond()`` is used to generate a condition function you use ``JaxArray``. It supports the following conditional logic:\n",
-    "\n",
-    "```python\n",
-    "\n",
-    "if True:\n",
-    "    true statements \n",
-    "else: \n",
-    "    false statements\n",
-    "```\n",
-    "\n",
-    "When using ``brainpy.math.make_cond()`` , *true statements* should be wrapped as a ``true_fun`` function which implements logics under true assertion, and *false statements* should be wrapped as a ``false_fun`` function which implements logics under false assertion. Neither function supports returning values.\n",
+    "For example, if you have the following code:\n",
     "\n",
     "```python\n",
-    "\n",
-    "if True:\n",
-    "    true_fun(x)\n",
-    "else:\n",
-    "    false_fun(x)\n",
+    "def f(a):\n",
+    "  if a > 10:\n",
+    "    return 1.\n",
+    "  elif a > 5:\n",
+    "    return 2.\n",
+    "  elif a > 0:\n",
+    "    return 3.\n",
+    "  elif a > -5:\n",
+    "    return 4.\n",
+    "  else:\n",
+    "    return 5.\n",
     "```\n",
     "\n",
-    "All the ``JaxArray``s used in ``true_fun`` and ``false_fun`` should be declared in the ``dyn_vars`` argument. ``x`` is used to receive the external input value. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "149d3dc6",
+    "It can be expressed as:"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "Let's make a try:"
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "id": "6291da01",
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 23,
    "outputs": [],
    "source": [
-    "a = bm.Variable(bm.zeros(2))\n",
-    "b = bm.Variable(bm.ones(2))\n",
-    "\n",
-    "def true_f(x):  a.value += 1\n",
-    "\n",
-    "def false_f(x): b.value -= 1\n",
-    "\n",
-    "cond = bm.make_cond(true_f, false_f, dyn_vars=[a, b])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c60e61c0",
+    "def f(a):\n",
+    "  return bm.ifelse(conditions=[a > 10, a > 5, a > 0, a > -5],\n",
+    "                   branches=[1., 2., 3., 4., 5.])"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
-     "name": "#%% md\n"
+     "name": "#%%\n"
     }
-   },
-   "source": [
-    "Here, we have two tensors. If true, tensor ``a`` is added by 1; if false, tensor ``b`` is subtracted by 1. "
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "id": "838bde45",
+   "execution_count": 25,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "DeviceArray(1., dtype=float32, weak_type=True)"
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f(11.)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
    "outputs": [
     {
      "data": {
-      "text/plain": "(Variable([1., 1.], dtype=float32), Variable([1., 1.], dtype=float32))"
+      "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)"
      },
-     "execution_count": 19,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cond(pred=True)\n",
-    "\n",
-    "a, b"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "8bda2e64",
+    "f(6.)"
+   ],
    "metadata": {
-    "scrolled": true,
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
    "outputs": [
     {
      "data": {
-      "text/plain": "(Variable([2., 2.], dtype=float32), Variable([1., 1.], dtype=float32))"
+      "text/plain": "DeviceArray(3., dtype=float32, weak_type=True)"
      },
-     "execution_count": 20,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cond(True)\n",
-    "\n",
-    "a, b"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "302b7342",
+    "f(1.)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
    "outputs": [
     {
      "data": {
-      "text/plain": "(Variable([2., 2.], dtype=float32), Variable([0., 0.], dtype=float32))"
+      "text/plain": "DeviceArray(4., dtype=float32, weak_type=True)"
      },
-     "execution_count": 21,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cond(False)\n",
-    "\n",
-    "a, b"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "320ef7f9",
+    "f(-4.)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
    "outputs": [
     {
      "data": {
-      "text/plain": "(Variable([2., 2.], dtype=float32), Variable([-1., -1.], dtype=float32))"
+      "text/plain": "DeviceArray(5., dtype=float32, weak_type=True)"
      },
-     "execution_count": 22,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cond(False)\n",
-    "\n",
-    "a, b"
-   ]
+    "f(-6.)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "id": "6f3dff74",
+   "source": [
+    "A more complex example is:"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   },
-   "source": [
-    "Or, we define a conditional case which depends on the external input. "
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "id": "a07844d5",
+   "execution_count": 33,
+   "outputs": [],
+   "source": [
+    "def f2(a, x):\n",
+    "  return bm.ifelse(conditions=[a > 10, a > 5, a > 0, a > -5],\n",
+    "                   branches=[lambda x: x*2,\n",
+    "                             2.,\n",
+    "                             lambda x: x**2 -1,\n",
+    "                             lambda x: x - 4.,\n",
+    "                             5.],\n",
+    "                   operands=x)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
-   "source": [
-    "a = bm.Variable(bm.zeros(2))\n",
-    "b = bm.Variable(bm.ones(2))\n",
-    "\n",
-    "def true_f(x):  a.value += x\n",
-    "\n",
-    "def false_f(x): b.value -= x\n",
-    "\n",
-    "cond = bm.make_cond(true_f, false_f, dyn_vars=[a, b])"
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "id": "d1219455",
+   "execution_count": 34,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)"
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f2(11, 1.)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
    "outputs": [
     {
      "data": {
-      "text/plain": "(Variable([10., 10.], dtype=float32), Variable([1., 1.], dtype=float32))"
+      "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)"
      },
-     "execution_count": 24,
+     "execution_count": 35,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cond(True, 10.)\n",
-    "\n",
-    "a, b"
-   ]
+    "f2(6, 1.)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "id": "d6098980",
+   "execution_count": 36,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "DeviceArray(0., dtype=float32, weak_type=True)"
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f2(1, 1.)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
    "outputs": [
     {
      "data": {
-      "text/plain": "(Variable([10., 10.], dtype=float32), Variable([-4., -4.], dtype=float32))"
+      "text/plain": "DeviceArray(-3., dtype=float32, weak_type=True)"
      },
-     "execution_count": 25,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cond(False, 5.)\n",
-    "\n",
-    "a, b"
-   ]
+    "f2(-4, 1.)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "DeviceArray(5., dtype=float32, weak_type=True)"
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f2(-6, 1.)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "If instances of `brainpy.math.Variable` are used in branching functions, you can declare them in the `dyn_vars` argument."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a: Variable([1., 1.], dtype=float32)\n",
+      "b: Variable([0., 0.], dtype=float32)\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = bm.Variable(bm.zeros(2))\n",
+    "b = bm.Variable(bm.ones(2))\n",
+    "def true_f(x):  a.value += 1\n",
+    "def false_f(x): b.value -= 1\n",
+    "\n",
+    "bm.ifelse(True, [true_f, false_f], dyn_vars=[a, b])\n",
+    "bm.ifelse(False, [true_f, false_f], dyn_vars=[a, b])\n",
+    "\n",
+    "print('a:', a)\n",
+    "print('b:', b)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 2\\. Repetition"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "A repetition statement is used to repeat a group(block) of programming instructions.\n",
+    "\n",
+    "In Python, we generally have two loops/repetitive statements:\n",
+    "\n",
+    "- **for loop**: Execute a set of statements once for each item in a sequence.\n",
+    "- **while loop**: Execute a block of statements repeatedly until a given condition is satisfied."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Pythonic loop syntax"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Actually, JAX enables to write Pythonic loops. You just need to iterate over you sequence data and then apply your logic on the iterated items. Such kind of Pythonic loop syntax can be compatible with JIT compilation, but will cause long time to trace and compile. For example,"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "outputs": [],
+   "source": [
+    "class LoopSimple(bp.Base):\n",
+    "    def __init__(self):\n",
+    "        super(LoopSimple, self).__init__()\n",
+    "        rng = bm.random.RandomState(123)\n",
+    "        self.seq = rng.random(1000)\n",
+    "        self.res = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "    def __call__(self):\n",
+    "        for s in self.seq:\n",
+    "            self.res += s\n",
+    "        return self.res.value"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "def measure_time(f):\n",
+    "    t0 = time.time()\n",
+    "    r = f()\n",
+    "    t1 = time.time()\n",
+    "    print(f'Result: {r}, Time: {t1 - t0}')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: [501.74673], Time: 2.7157142162323\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = bm.jit(LoopSimple())\n",
+    "\n",
+    "# First time will trigger compilation\n",
+    "measure_time(model)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: [1003.49347], Time: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Second running\n",
+    "measure_time(model)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "When the model is complex and the iteration is long, the compilation during the first running will become unbearable. For such cases, you need structural loop syntax."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "JAX has provided several important loop syntax, including:\n",
+    "- [jax.lax.fori_loop](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.fori_loop.html)\n",
+    "- [jax.lax.scan](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.scan.html)\n",
+    "- [jax.lax.while_loop](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.while_loop.html)\n",
+    "\n",
+    "BrainPy also provides its own loop syntax, which is especially suitable for the cases where users are using `brainpy.math.Variable`. Specifically, they are:\n",
+    "\n",
+    "- [brainpy.math.make_loop](https://brainpy.readthedocs.io/en/latest/apis/auto/math/generated/brainpy.math.controls.make_loop.html)\n",
+    "- [brainpy.math.make_while](https://brainpy.readthedocs.io/en/latest/apis/auto/math/generated/brainpy.math.controls.make_while.html)\n",
+    "\n",
+    "In this section, we only talk about how to use our provided loop functions."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### ``brainpy.math.make_loop()``"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "``brainpy.math.make_loop()`` is used to generate a for-loop function when you use ``Variable``.\n",
+    "\n",
+    "Suppose that you are using several JaxArrays (grouped as ``dyn_vars``) to implement your body function \"body\\_fun\", and you want to gather the history values of several of them (grouped as ``out_vars``). Sometimes the body function already returns something, and you also want to gather the returned values. With the Python syntax, it can be realized as\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "def for_loop_function(body_fun, dyn_vars, out_vars, xs):\n",
+    "  ys = []\n",
+    "  for x in xs:\n",
+    "    # 'dyn_vars' and 'out_vars' are updated in 'body_fun()'\n",
+    "    results = body_fun(x)\n",
+    "    ys.append([out_vars, results])\n",
+    "  return ys\n",
+    "\n",
+    "```"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In BrainPy, you can define this logic using ``brainpy.math.make_loop()``:\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=False)\n",
+    "\n",
+    "hist_of_out_vars = loop_fun(xs)\n",
+    "```\n",
+    "\n",
+    "Or,\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "loop_fun = brainpy.math.make_loop(body_fun, dyn_vars, out_vars, has_return=True)\n",
+    "\n",
+    "hist_of_out_vars, hist_of_return_vars = loop_fun(xs)\n",
+    "```\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "For the above example, we can rewrite it by using ``brainpy.math.make_loop`` as:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "outputs": [],
+   "source": [
+    "class LoopStruct(bp.Base):\n",
+    "    def __init__(self):\n",
+    "        super(LoopStruct, self).__init__()\n",
+    "        rng = bm.random.RandomState(123)\n",
+    "        self.seq = rng.random(1000)\n",
+    "        self.res = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "        def add(s): self.res += s\n",
+    "        self.loop = bm.make_loop(add, dyn_vars=[self.res])\n",
+    "\n",
+    "    def __call__(self):\n",
+    "        self.loop(self.seq)\n",
+    "        return self.res.value"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: [501.74664], Time: 0.028011560440063477\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = bm.jit(LoopStruct())\n",
+    "\n",
+    "# First time will trigger compilation\n",
+    "measure_time(model)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: [1003.4931], Time: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Second running\n",
+    "measure_time(model)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### ``brainpy.math.make_while()``"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "``brainpy.math.make_while()`` is used to generate a while-loop function when you use ``JaxArray``. It supports the following loop logic:\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "while condition:\n",
+    "    statements\n",
+    "```\n",
+    "\n",
+    "When using ``brainpy.math.make_while()`` , *condition* should be wrapped as a ``cond_fun`` function which returns a boolean value, and *statements* should be packed as a ``body_fun`` function which does not support returned values:\n",
+    "\n",
+    "```python\n",
+    "\n",
+    "while cond_fun(x):\n",
+    "    body_fun(x)\n",
+    "```\n",
+    "\n",
+    "where ``x`` is the external input that is not iterated. All the iterated variables should be marked as ``JaxArray``. All ``JaxArray``s used in ``cond_fun`` and ``body_fun`` should be declared as ``dyn_vars`` variables."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Let's look an example:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "outputs": [],
+   "source": [
+    "i = bm.Variable(bm.zeros(1))\n",
+    "counter = bm.Variable(bm.zeros(1))\n",
+    "\n",
+    "def cond_f(x):\n",
+    "    return i[0] < 10\n",
+    "\n",
+    "def body_f(x):\n",
+    "    i.value += 1.\n",
+    "    counter.value += i\n",
+    "\n",
+    "loop = bm.make_while(cond_f, body_f, dyn_vars=[i, counter])"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In the above example, we try to implement a sum from 0 to 10 by using two JaxArrays ``i`` and ``counter``."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "outputs": [],
+   "source": [
+    "loop()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([55.], dtype=float32)"
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "counter"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Variable([10.], dtype=float32)"
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "i"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   }
  ],
  "metadata": {
diff --git a/docs/tutorial_basics/index.rst b/docs/tutorial_math/index.rst
similarity index 100%
rename from docs/tutorial_basics/index.rst
rename to docs/tutorial_math/index.rst
diff --git a/docs/tutorial_basics/jit_compilation.ipynb b/docs/tutorial_math/jit_compilation.ipynb
similarity index 100%
rename from docs/tutorial_basics/jit_compilation.ipynb
rename to docs/tutorial_math/jit_compilation.ipynb
diff --git a/docs/tutorial_basics/overview.ipynb b/docs/tutorial_math/overview.ipynb
similarity index 100%
rename from docs/tutorial_basics/overview.ipynb
rename to docs/tutorial_math/overview.ipynb
diff --git a/docs/tutorial_basics/tensors.ipynb b/docs/tutorial_math/tensors.ipynb
similarity index 100%
rename from docs/tutorial_basics/tensors.ipynb
rename to docs/tutorial_math/tensors.ipynb
diff --git a/docs/tutorial_basics/tensors_and_variables.ipynb b/docs/tutorial_math/tensors_and_variables.ipynb
similarity index 100%
rename from docs/tutorial_basics/tensors_and_variables.ipynb
rename to docs/tutorial_math/tensors_and_variables.ipynb