CaputoL1Schema#
- class brainpy.integrators.fde.CaputoL1Schema(f, alpha, num_memory, inits, state_delays=None, dt=None, name=None)[source]#
The L1 scheme method for the numerical approximation of the Caputo fractional-order derivative equations [3].
For the fractional order \(0<\alpha<1\), let the fractional derivative of variable \(x(t)\) be
\[\frac{d^{\alpha} x}{d t^{\alpha}}=F(x, t)\]The Caputo definition of the fractional derivative for variable \(x\) is
\[\frac{d^{\alpha} x}{d t^{\alpha}}=\frac{1}{\Gamma(1-\alpha)} \int_{0}^{t} \frac{x^{\prime}(u)}{(t-u)^{\alpha}} d u\]where \(\Gamma\) is the Gamma function.
The fractional-order derivative is capable of integrating the activity of the function over all past activities weighted by a function that follows a power-law. Using one of the numerical methods, the L1 scheme method [3], the numerical approximation of the fractional-order derivative of \(x\) is
\[\frac{d^{\alpha} \chi}{d t^{\alpha}} \approx \frac{(d t)^{-\alpha}}{\Gamma(2-\alpha)}\left[\sum_{k=0}^{N-1}\left[x\left(t_{k+1}\right)- \mathrm{x}\left(t_{k}\right)\right]\left[(N-k)^{1-\alpha}-(N-1-k)^{1-\alpha}\right]\right]\]Therefore, the numerical solution of original system is given by
\[x\left(t_{N}\right) \approx d t^{\alpha} \Gamma(2-\alpha) F(x, t)+x\left(t_{N-1}\right)- \left[\sum_{k=0}^{N-2}\left[x\left(t_{k+1}\right)-x\left(t_{k}\right)\right]\left[(N-k)^{1-\alpha}-(N-1-k)^{1-\alpha}\right]\right]\]Hence, the solution of the fractional-order derivative can be described as the difference between the Markov term and the memory trace. The Markov term weighted by the gamma function is
\[\text { Markov term }=d t^{\alpha} \Gamma(2-\alpha) F(x, t)+x\left(t_{N-1}\right)\]The memory trace (\(x\)-memory trace since it is related to variable \(x\)) is
\[\text { Memory trace }=\sum_{k=0}^{N-2}\left[x\left(t_{k+1}\right)-x\left(t_{k}\right)\right]\left[(N-k)^{1-\alpha}-(N-(k+1))^{1-\alpha}\right]\]The memory trace integrates all the past activity and captures the long-term history of the system. For \(\alpha=1\), the memory trace is 0 for any time \(t\). When the fractional order \(\alpha\) is decreased from 1, the memory trace non-linearly increases from 0, and its dynamics strongly depends on time. Thus, the fractional order dynamics strongly deviates from the first order dynamics.
Examples
>>> import brainpy as bp >>> >>> a, b, c = 10, 28, 8 / 3 >>> def lorenz(x, y, z, t): >>> dx = a * (y - x) >>> dy = x * (b - z) - y >>> dz = x * y - c * z >>> return dx, dy, dz >>> >>> duration = 30. >>> dt = 0.005 >>> inits = [1., 0., 1.] >>> f = bp.fde.CaputoL1Schema(lorenz, alpha=0.99, num_memory=int(duration / dt), inits=inits) >>> runner = bp.IntegratorRunner(f, monitors=list('xz'), dt=dt, inits=inits) >>> runner.run(duration) >>> >>> import matplotlib.pyplot as plt >>> plt.plot(runner.mon.x.flatten(), runner.mon.z.flatten()) >>> plt.show()
- Parameters:
f (callable) – The derivative function.
alpha (int, float, jnp.ndarray, bm.ndarray, sequence) – The fractional-order of the derivative function. Should be in the range of
(0., 1.].num_memory (int) – The total time step of the simulation.
inits (sequence) – A sequence of the initial values for variables.
name (str) – The integrator name.
References