FPGA Implementation Based on the Short-Memory Principle: Analysis of a Lorenz-Type Systems Family

Abstract

Fractional differential equations and fractional-order chaotic systems are attractive for secure communications, but the nonlocal memory of the Caputo derivative makes their digital implementation costly, so iterative methods are preferred for developing digital implementations of physical systems. This paper characterizes seven members of the Lorenz family (Lorenz, Chen, Burke–Shaw, Liu, Shimizu–Morioka, Lü, and Yang) and implements them on an FPGA using the short-memory principle. Starting from rectangular (REC) and predictor–corrector (PC) product-integration rules, we derive incremental iterative forms with a finite memory window suited to digital hardware. Largest Lyapunov exponent maps and bifurcation diagrams over fractional order and memory duration identify chaotic regimes for the Caputo case that, to our knowledge, have not been reported; for most systems, they stabilize once the window exceeds about 2 s. On a Cyclone V FPGA with a common Q1.11.20 fixed-point format, each architecture lets you select any of the seven systems and a memory depth of 1–1000 samples without resynthesis. For a 2 s window, REC uses fewer resources (3258 ALMs, 60 DSP blocks), whereas PC, thanks to its larger time step, reaches a higher estimated state-generation rate (330,457 versus 291,839 state vectors/s). Finally, 8-bit pseudorandom sequences extracted from the Lorenz system (1 Gbit per architecture) pass NIST SP 800-22 and the TestU01 Rabbit, Alphabit, and BlockAlphabit batteries. In addition, we present numerical simulations and their digital implementation to validate the numerical schemes.

1. Introduction

Fractional calculus studies the differentiation and integration of non-integer order, where the order may be rational, real, or complex [1,2,3]. Its origins date back to a 1695 correspondence between Leibniz and L’Hôpital, in which they first proposed the concept of a fractional derivative [4]. Although fractional calculus remained primarily theoretical for centuries, Fractional-Order Systems (FOSs) have received significant attention in recent decades because of their capacity to model memory phenomena and nonlocal behavior [5,6]. Compared with integer-order models, FOSs bring additional degrees of freedom that allow a flexible description of complex physical phenomena, and they have been applied in bio-inspired robotics, oscillator design, control theory, cryptography, and chaotic systems [7,8,9,10,11].

Chaotic systems are nonlinear dynamical systems characterized by strong sensitivity to initial conditions, topological mixing, and deterministic behavior that appears random [12,13,14]. Since Lorenz introduced his butterfly attractor in 1963 to model atmospheric convection [15], many chaotic systems have been proposed, including the Chen and Lü systems and hyperchaotic and memristive extensions [16,17,18,19]. Their unpredictability has been exploited in secure communications, Pseudorandom Number Generation (PRNG), neural networks, and Internet of Things (IoT) security [20,21,22].

Combining these fields yields fractional-order chaotic systems, where the derivative is commonly defined using the Caputo, Grünwald–Letnikov (GL), or Riemann–Liouville (RL) formulations [23]. Because these operators are nonlocal, the current state depends on the full history of previous states, making the computational cost considerably higher than for integer-order systems [24]. The short-memory principle mitigates this cost by truncating the history to a finite window of length L, assuming distant states contribute little; the resulting error can be bounded in terms of L and the fractional order $\alpha$ [25,26]. The window length therefore directly trades off accuracy and storage. Several numerical schemes compatible with this principle have been proposed, including the GL method and modified product-integration (PI) rules, such as the rectangular, trapezoidal, and predictor–corrector variants, where some numerical methods are described algebraically to express them as iterative methods of the form $x_{n+1}=x_n+f\left(·\right)$ to facilitate the digital implementation [27].

In addition, extending classical chaotic systems to the fractional domain enriches their dynamics, with more complex bifurcation structures, enhanced ergodicity, and improved sensitivity, making them attractive for encryption and PRNG design [28]. Researchers have traditionally built chaotic systems with analog circuits based on operational amplifiers and discrete components, which are convenient for observing nonlinear dynamics [29,30]. Digital implementations, in contrast, offer better reproducibility, stability, and integration. Among digital platforms, field-programmable gate arrays (FPGAs) stand out for their parallelism, reconfigurability, and energy efficiency, which suit the repetitive arithmetic and memory accesses of fractional-order operators and enable real-time execution that general-purpose processors struggle to achieve.

Research on chaos in fractional-order systems and its applications in FPGAs is diverse. Ref. [31] presents GL-based operators as reusable hardware blocks with a short-memory window for several families of fractional-order oscillators on a Cyclone IV FPGA, using RAM/ROM blocks, resource-sharing control logic, and 32-bit fixed-point arithmetic. Later designs include GL integrators and differentiators using LUT- and quadratic- or piecewise-linear-based approximations, reducing the maximum absolute error by up to 91% over previous methods [32]; a complete GL differ-integral on a Virtex-5 with multiple window sizes is presented in [33]. Similar studies present a generic reconfigurable GL core on Artix-7 for four-wing systems [34] and an enhanced core whose fractional order, step size, and system parameters can be tuned at runtime, validated on a variable-order chaotic oscillator [35].

Another important line of research targets high-dimensional memristive and multi-scroll systems. Examples include a 5D memristive hyperchaotic system with coexisting attractors implemented on a Xilinx XC7Z020 FPGA with 32-bit floating-point [36], a 5D multi-wing system with hidden attractors [37], and a 4D memristive Hopfield neural network [38]. Recently, ref. [39] also proposed a piecewise-linear decomposition that avoids explicit Adomian polynomials for multi-scroll systems and targets ARM processors and FPGAs. In all of them, FPGA phase portraits agree with numerical simulations.

Several studies embed fractional chaos directly into application-specific designs, mostly for encryption. GL-based multi-scroll and memristive systems have been combined with CORDIC cores to generate PRNG sequences for image ciphers, with the sequences validated by NIST SP 800-22 [40,41]. A 1D time-delay fractional memristive system, modeled with the Caputo definition, has been implemented on an FPGA using a short-memory scheme and applied to a multilevel image-encryption algorithm [42]; ref. [43] explores randomness and image encryption using a memristive dual-wing fractional-order Hopfield neural network.

Many studies have developed diverse numerical schemes to simulate and implement fractional-order chaotic systems on FPGAs, formulating novel short-memory-based methods to use available hardware resources. Inspired by the aforementioned research, this paper aims for the dynamic characterization of seven chaotic systems that are members of the Lorenz family. We employ classical numerical methods to simulate fractional systems with the Caputo derivative. Using algebraic procedures, we derive simple iterative forms for the rectangular (REC) and predictor–corrector (PC) methods to compute dynamic characteristics of the Lorenz family—such as Lyapunov exponents and bifurcation diagrams—while accounting for the short-memory principle. This analysis identifies ranges of $\alpha$ and memory durations associated with chaotic behavior in the Lorenz family modeled with a Caputo derivative, which have not been reported previously.

The FPGA implementations complement this characterization through configurable model selection and memory depth. Within each REC or PC bitstream, any of the seven systems and a memory depth between 1 and 1000 samples can be selected through configuration inputs. Changing these settings requires a reset, without modifying the HDL code or resynthesizing the design. The work also quantitatively compares both implementations on the same FPGA platform using a common fixed-point representation, reporting resource consumption, update latency, maximum operating frequency, and estimated power under the specified configurations. A systematic comparison of fixed-point formats against double-precision references supports the selection of Q1.11.20 for the evaluated operating conditions.

Each implementation also supports a PRNG application using the state variables of the selected Lorenz-family model. Statistical evaluation is performed in the Lorenz configuration for both REC and PC. The resulting bitstreams satisfy the reported acceptance criteria of NIST SP 800-22 and the Rabbit, Alphabit, and BlockAlphabit batteries of TestU01. These results support the statistical quality of the evaluated streams under the specified conditions; potential cryptographic applications require further cryptanalytic assessment.

The paper is organized as follows. Section 2 presents the Riemann–Liouville integral and its numerical approximation. Section 3 discusses fractional-order derivatives and the theoretical basis of the short-memory principle. Section 4 analyzes numerical methods for solving fractional differential equations. In Section 5, we make the corresponding modifications to obtain iterative forms ready for implementation in digital systems. Section 6 introduces the generalized Lorenz family under study and reports numerical simulations to validate our approach; it also presents the FPGA experimental results and their application in PRNG. Finally, Section 7 concludes the work with the main results.

2. The Riemann–Liouville Integral and Its Numerical Approximation

In this section, we present an intuitive derivation of the Riemann–Liouville integral and several numerical methods for computing it. First, consider the well-known n-fold integral in Definition 1. Integral (1) simplifies n repeated integrals associated with one function to only one calculation. In this sense, the values of n considered by the operator in (1) are restricted to the natural numbers, as shown on the left-hand side of Figure 1.

Figure 1. Sets associated with the order of the Cauchy formula (Equation (1)) and the Riemann–Liouville integral (Equation (4)). Each arrow indicates that n is mapped to a natural number, whereas when generalized to an arbitrary value $\alpha$, it is mapped to an arbitrary positive real number instead.

Definition 1

([44]). Let $f:[a,t]\to \mathbb{R}$ be a continuous function, $n\in \mathbb{N}$. The n-th repeated integral of f (the Cauchy formula for repeated integration or n-fold integral) is given by

$$\begin{array}{cc}\hfill {}_{a}I_t^{n}f\left(t\right)& =\underset{n-\mathit{times}}{\underbrace{{\int }_a^t{\int }_a^{{\tau }_1}\dots {\int }_a^{{\tau }_{n-1}}}}f\left({\tau }_n\right)\underset{n-\mathit{times}}{\underbrace{d{\tau }_n\dots d{\tau }_{2}d{\tau }_1}}\hfill \\ \hfill & ={\displaystyle \frac{1}{(n-1)!}}{\int }_a^t{\left(t-\tau \right)}^{n-1}f\left(\tau \right)d\tau .\hfill \end{array}$$

(1)

Now, we can ask what happens if the order of the n-fold integral is $n=\alpha \in {\mathbb{R}}^{+}$, as shown on the right-hand side of Figure 1. The answer to this question requires the following special function.

Definition 2

([45]). Let $\alpha \in {\mathbb{R}}^{+}$. The function

$${\displaystyle \Gamma \left(\alpha \right)={\int }_0^{\infty }{t}^{\alpha -1}{e}^{-t}dt=\underset{\tau \to \infty }{\lim }{\int }_0^{\tau }{t}^{\alpha -1}{e}^{-t}dt,}$$

(2)

whenever the limit exists (as a finite number) is called the gamma function.

The gamma function generalizes the factorial function. In fact, by interpolating the factorial values, we can obtain the graphical representation of Function (2). Analytically, their relationship is straightforward; we can prove it by mathematical induction, i.e.,

$$\Gamma \left(n\right)=\left(n-1\right)!\forall n\in \mathbb{N},$$

(3)

so the following operator is obtained [46,47].

Definition 3

([44,48]). Let $\alpha \in {\mathbb{R}}^{+}$. The operator defined on $L_1[a,b]$ by

$${{}^{RL}\mathcal{I}}_{a+}^{\alpha }f\left(t\right)={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_a^t{(t-\tau )}^{\alpha -1}f\left(\tau \right)d\tau ,$$

(4)

for $a\le t\le b$, is called the Riemann–Liouville fractional integral operator of order α.

One essential part of applied math is the computational implementation of equations, such as Integral (4). Let $f\left(t\right)\in \mathcal{C}\left(I\right)$ be the function of interest analyzed in the interval $I=[0,T]$. If the interval is divided into $N_R\in \mathbb{N}$ subintervals, then the step size is

$$h={\displaystyle \frac{T-0}{N_R}}={\displaystyle \frac{T}{N_R}},$$

(5)

so the interval has $N=N_R+1$ points where the function could be evaluated with the algorithm. If the step size is smaller, the number N increases, i.e., there will be more points where the numerical algorithm is evaluated, improving the numerical estimation. Figure 2 shows a uniform grid in the interval $I=[0,T]$ with $N=N_R+1$ equispaced nodes $t_k=kh$ with $k=0,1,\dots ,N_R$, i.e.,

$$0=t_0<t_1<t_2<\dots <t_{N_R}=T.$$

(6)

At the node $t_n$ with $0\le n\le N_R$, regarding Definition 3, we get

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& ={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_0^{t_n}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}\left[{\int }_{t_0}^{t_1}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau +{\int }_{t_1}^{t_2}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \right.\hfill \\ \hfill & \left.+{\int }_{t_2}^{t_3}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau +\dots +{\int }_{t_{n-1}}^{t_n}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \right].\hfill \end{array}$$

In summary, for $t=t_n$,

$${{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}{\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau .$$

(7)

Equation (7) can be simplified if we can evaluate the integral. Considering the arbitrary subinterval $\left[t_k,t_{k+1}\right]$ shown in Figure 3, and given that we do not have a fixed value for $f\left(t\right)$, we can take as a first approximation the corresponding evaluation at the infimum and supremum of the subinterval, thus approximating $f\left(t\right)$ by a constant.

Figure 2. Visualization of the lattice associated with $f\left(t\right)\in \mathcal{C}\left(I\right)$ to determine numerically the Riemann–Liouville integral in (4).

Figure 3. Visualization of the k-th subinterval of $f\left(t\right)\in \mathcal{C}\left(I\right)$.

Case (a) Evaluating the function at the infimum, we get

$$f\left(t\right){|}_{[t_k,t_{k+1})}\approx f\left(t_k\right).$$

(8)

Substituting and simplifying Expression (7), it follows that

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& ={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}{\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \hfill \\ \hfill & \approx {\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}{\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}f\left(t_k\right)d\tau \hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}f\left(t_k\right){\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}d\tau .\hfill \end{array}$$

According to the uniform distribution of the nodes, $t_k=kh$, then

$$\begin{array}{cc}\hfill {\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}d\tau & ={\displaystyle \frac{1}{\alpha }}\left[{(t_n-t_k)}^{\alpha }-{(t_n-t_{k+1})}^{\alpha }\right]\hfill \\ \hfill & ={\displaystyle \frac{1}{\alpha }}\left\{{\left[nh-kh\right]}^{\alpha }-{\left[nh-(k+1)h\right]}^{\alpha }\right\}\hfill \\ \hfill & ={\displaystyle \frac{h^{\alpha }}{\alpha }}\left[{(n-k)}^{\alpha }-{(n-k-1)}^{\alpha }\right].\hfill \end{array}$$

so the Riemann–Liouville integral in (4) at time $t_n$ is approximated by

$${{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}\approx {\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}{\displaystyle \sum _{k=0}^{n-1}}f\left(t_k\right)\left[{(n-k)}^{\alpha }-{(n-k-1)}^{\alpha }\right].$$

(9)

Defining

$${\Lambda }_j^{\left(\beta \right)}={\displaystyle \frac{{(j+1)}^{\beta }-j^{\beta }}{\Gamma (\beta +1)}},$$

(10)

the approximation (9) can be written more compactly as the left-fractional rectangular method

$${{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_0^{t_n}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \approx h^{\alpha }{\displaystyle \sum _{k=0}^{n-1}}f\left(t_k\right){\Lambda }_{n-k-1}^{\left(\alpha \right)}.$$

(11)

Case (b) Evaluating the function at the supremum, we get

$$f\left(t\right){|}_{(t_k,t_{k+1}]}\approx f\left(t_{k+1}\right).$$

(12)

Substituting (12) into (7) and performing a similar simplification to the previous case allows us to obtain the right-fractional rectangular method

$${{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_0^{t_n}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \approx h^{\alpha }{\displaystyle \sum _{k=0}^{n-1}}f\left(t_{k+1}\right){\Lambda }_{n-k-1}^{\left(\alpha \right)}.$$

(13)

Remark 1.

Algorithms (11) and (13) consist of a finite sum of rectangles. In particular, if $\alpha =1$, then ${\Lambda }_{n-k-1}^{\left(1\right)}=1$ and

$${{}^{RL}\mathcal{I}}_{0+}^{1}f\left(t\right){|}_{t=t_n}={\int }_0^{t_n}f\left(\tau \right)d\tau \approx h{\displaystyle \sum _{k=0}^{n-1}}f\left(t_k\right),$$

(14)

recovering the classical sum of areas of rectangles (rectangle method) to compute the numerical approximation for the definite integral [49].

Case (c) Using the two-step Lagrange polynomial interpolation [49], the function $f\left(t\right)$ can be approximated as

$$f\left(t\right){|}_{[t_k,t_{k+1}]}\approx {\displaystyle \frac{t_{k+1}-t}{t_{k+1}-t_k}}f\left(t_k\right)+{\displaystyle \frac{t-t_k}{t_{k+1}-t_k}}f\left(t_{k+1}\right).$$

(15)

Graphically, Equation (15) represents the linear approximation on the interval $[t_k,t_{k+1}]$, that is, the secant line from point $(t_k,f\left(t_k\right))$ to point $(t_{k+1},f\left(t_{k+1}\right))$ (see Figure 3). Substituting (15) into (7) with $h=t_{k+1}-t_k$, it follows that

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& ={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}{\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \hfill \\ \hfill & \approx {\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}{\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}\left[{\displaystyle \frac{t_{k+1}-\tau }{h}}f\left(t_k\right)+{\displaystyle \frac{\tau -t_k}{h}}f\left(t_{k+1}\right)\right]d\tau \hfill \\ \hfill & ={\displaystyle \frac{1}{h\Gamma \left(\alpha \right)}}{\displaystyle \sum _{k=0}^{n-1}}\left[f\left(t_k\right){\mathcal{I}}_1+f\left(t_{k+1}\right){\mathcal{I}}_2\right],\hfill \end{array}$$

(16)

where

$${\mathcal{I}}_1={\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}\left(t_{k+1}-\tau \right)d\tau ,$$

(17)

$${\mathcal{I}}_2={\int }_{t_k}^{t_{k+1}}{(t_n-\tau )}^{\alpha -1}\left(\tau -t_k\right)d\tau .$$

(18)

Integrals (17) and (18) are solved using the tabular method for integration by parts as follows [50]: Calculating the corresponding diagonal products between the functions connected by the corresponding arrows and their corresponding signs, one obtains

$$\begin{array}{cc}\hfill {\mathcal{I}}_1& =\left[-{\displaystyle \frac{1}{\alpha }}{\left(t_n-\tau \right)}^{\alpha }\left(t_{k+1}-\tau \right)+{\displaystyle \frac{{(t_n-\tau )}^{\alpha +1}}{\alpha (\alpha +1)}}\right]{|}_{t_k}^{t_{k+1}}\hfill \\ \hfill & ={\displaystyle \frac{1}{\alpha (\alpha +1)}}\left\{{\left(t_n-t_{k+1}\right)}^{\alpha +1}-{\left(t_n-t_k\right)}^{\alpha }\left[-\alpha \left(t_{k+1}-t_k\right)-t_{k+1}+t_n\right]\right\}\hfill \\ \hfill & ={\displaystyle \frac{h^{\alpha +1}}{\alpha (\alpha +1)}}\left[{(n-k-1)}^{\alpha +1}-{(n-k)}^{\alpha }(n-k-1-\alpha )\right],\hfill \end{array}$$

$$\begin{array}{cc}\hfill {\mathcal{I}}_2& =\left[-{\displaystyle \frac{1}{\alpha }}{\left(t_n-\tau \right)}^{\alpha }\left(\tau -t_k\right)-{\displaystyle \frac{{(t_n-\tau )}^{\alpha +1}}{\alpha (\alpha +1)}}\right]{|}_{t_k}^{t_{k+1}}\hfill \\ \hfill & ={\displaystyle \frac{1}{\alpha (\alpha +1)}}\left\{{\left(t_n-t_k\right)}^{\alpha +1}+{\left(t_n-t_{k+1}\right)}^{\alpha }\left[t_{k+1}-t_n-(\alpha +1)\left(t_{k+1}-t_k\right)\right]\right\}\hfill \\ \hfill & ={\displaystyle \frac{h^{\alpha +1}}{\alpha (\alpha +1)}}\left[{(n-k)}^{\alpha +1}+{(n-k-1)}^{\alpha }(k-n-\alpha )\right].\hfill \end{array}$$

Substituting the previous results into (16) allows us to obtain

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& \approx {\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}{\displaystyle \sum _{k=0}^{n-1}}\left\{f\left(t_k\right)\left[{(n-k-1)}^{\alpha +1}-{(n-k)}^{\alpha }(n-k-1-\alpha )\right]\right.\hfill \\ \hfill & \left.+f\left(t_{k+1}\right)\left[{(n-k)}^{\alpha +1}+{(n-k-1)}^{\alpha }(k-n-\alpha )\right]\right\}.\hfill \end{array}$$

(19)

Remark 2.

The trapezoidal method is obtained by evaluating (19) with $\alpha =1$, i.e.,

$${{}^{RL}\mathcal{I}}_{0+}^{1}f\left(t\right){|}_{t=t_n}={\int }_0^{t_n}f\left(\tau \right)d\tau \approx {\displaystyle \frac{h}{2}}{\displaystyle \sum _{k=0}^{n-1}}\left[f\left(t_k\right)+f\left(t_{k+1}\right)\right].$$

(20)

The numerical method in (19) explicitly shows how each segment of the function contributes to the fractional operator’s memory; however, it evaluates the contribution of $f\left(t_k\right)$ twice in consecutive loops. To improve computational efficiency, the first step is to expand (19) as follows:

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& \approx {\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left\{f\left(t_0\right)\left[{(n-1)}^{\alpha +1}-n^{\alpha }(n-1-\alpha )\right]+{\Sigma }_1+{\Sigma }_2+f\left(t_n\right)\right\},\hfill \end{array}$$

where

$${\Sigma }_1={\displaystyle \sum _{k=1}^{n-1}}f\left(t_k\right)\left[{(n-k-1)}^{\alpha +1}-{(n-k)}^{\alpha }(n-k-1-\alpha )\right],$$

and

$$\begin{array}{cc}\hfill {\Sigma }_2& ={\displaystyle \sum _{k=0}^{n-2}}f\left(t_{k+1}\right)\left[{(n-k)}^{\alpha +1}+{(n-k-1)}^{\alpha }(k-n-\alpha )\right]\hfill \\ \hfill & ={\displaystyle \sum _{k=0}^{n-2}}f\left(t_{k+1}\right)\left\{{[n-\left(k+1\right)+1]}^{\alpha +1}+{[n-\left(k+1\right)]}^{\alpha }[-n-\alpha +\left(k+1\right)-1]\right\}\hfill \\ \hfill & ={\displaystyle \sum _{k=0+1}^{n-2+1}}f\left(t_{k+1-1}\right)\left\{{[n-\left(k+1-1\right)+1]}^{\alpha +1}+{[n-\left(k+1-1\right)]}^{\alpha }[-n-\alpha +\left(k+1-1\right)-1]\right\}\hfill \\ \hfill {\Sigma }_2& ={\displaystyle \sum _{k=1}^{n-1}}f\left(t_k\right)\left[{(n-k+1)}^{\alpha +1}+{(n-k)}^{\alpha }(k-1-n-\alpha )\right].\hfill \end{array}$$

By grouping the sums and simplifying,

$$\begin{array}{cc}\hfill {\Sigma }_1+{\Sigma }_2& ={\displaystyle \sum _{k=1}^{n-1}}f\left(t_k\right)\left[{(n-k-1)}^{\alpha +1}-{(n-k)}^{\alpha }(n-k-1-\alpha )\right.\hfill \\ \hfill & \left.+{(n-k+1)}^{\alpha +1}+{(n-k)}^{\alpha }(k-1-n-\alpha )\right]\hfill \\ \hfill & ={\displaystyle \sum _{k=1}^{n-1}}f\left(t_k\right)\left[{(n-k+1)}^{\alpha +1}+{(n-k-1)}^{\alpha +1}-2{(n-k)}^{\alpha +1}\right],\hfill \end{array}$$

so that (19) is rewritten as

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& \approx {\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\{f\left(t_0\right)\left[{(n-1)}^{\alpha +1}-n^{\alpha }(n-1-\alpha )\right]+f\left(t_n\right)\hfill \\ \hfill & +{\displaystyle \sum _{k=1}^{n-1}}f\left(t_k\right)\left[{(n-k+1)}^{\alpha +1}+{(n-k-1)}^{\alpha +1}-2{(n-k)}^{\alpha +1}\right]\}.\hfill \end{array}$$

(21)

Defining

$$W_j^{\left(\beta \right)}={(j+1)}^{\beta +1}+{(j-1)}^{\beta +1}-2j^{\beta +1},$$

(22)

$${\mathsf{\Omega }}_j^{\left(\beta \right)}={(j-1)}^{\beta +1}-j^{\beta }(j-1-\beta ),$$

(23)

Equation (21) is expressed as the fractional trapezoidal method

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{I}}_{0+}^{\alpha }f\left(t\right){|}_{t=t_n}& ={\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_0^{t_n}{(t_n-\tau )}^{\alpha -1}f\left(\tau \right)d\tau \hfill \\ \hfill & \approx {\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left[f\left(t_0\right){\mathsf{\Omega }}_n^{\left(\alpha \right)}+{\displaystyle \sum _{k=1}^{n-1}}f\left(t_k\right)W_{n-k}^{\left(\alpha \right)}+f\left(t_n\right)\right].\hfill \end{array}$$

(24)

Remark 3.

According to [51], the following equation holds for any whole number r:

$${\displaystyle \sum _{k=m}^p}{a}_k={\displaystyle \sum _{k=m+r}^{p+r}}{a}_{k-r}.$$

(25)

In the previous analysis, the simplification of ${\displaystyle {\Sigma }_2}$ follows from (25).

Remark 4.

The coefficients belonging to the same value of $f\left(t_k\right)$ are grouped together in Method (24), reducing the round-off error and the inaccuracies we get by taking a certain number of decimal places instead of taking the entire number [52]. Since the weight vector in (22) depends only on the difference $n-k$, when performing the numerical simulation, the vector $W_{n-k}^{\left(\alpha \right)}$ is pre-calculated, and the calculation at each step reduces to a dot product between the function history vector and the weight vector $W_{n-k}^{\left(\alpha \right)}$, resulting in greater computational speed.

3. Fractional-Order Derivatives and the Short-Memory Principle

In this section, we contrast the Riemann integral with the fractional derivative and the short-memory principle, which we use to optimize the numerical methods in the next section. Readers interested in delving deeper into fractional calculus may consult [44,48,53,54].

Definition 4.

Let $\alpha \in {\mathbb{R}}^{+}$ and $n=\alpha =\min \left\{k\in \mathbb{N}\mid k\ge \alpha \right\}$. The operator defined by

$$\begin{array}{cc}\hfill {{}^{RL}\mathcal{D}}_{a+}^{\alpha }f\left(t\right)& =D^n\left[{{}^{RL}\mathcal{I}}_{a+}^{n-\alpha }f\left(t\right)\right]\hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma (n-\alpha )}}{\displaystyle \frac{d^n}{d{t}^n}}{\int }_a^t{\left(t-\tau \right)}^{n-\alpha -1}f\left(\tau \right)d\tau ,\hfill \end{array}$$

(26)

is called the Riemann–Liouville fractional differential operator of order α, with $D^n={\displaystyle \frac{d^n}{d{t}^n}}$ the n-th derivative of integer order.

Definition 5.

Let $\alpha \in {\mathbb{R}}^{+}$ and $n=\lceil \alpha \rceil =\min \left\{k\in \mathbb{N}\mid k\ge \alpha \right\}$. For $D^{n}f\left(t\right)=f^{\left(n\right)}\in L_1[a,b]$, the operator defined by

$$\begin{array}{cc}\hfill {{}^C\mathcal{D}}_{a+}^{\alpha }f\left(t\right)& ={{}^{RL}\mathcal{I}}_{a+}^{n-\alpha }\left[D^{n}f\left(t\right)\right]\hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma (n-\alpha )}}{\int }_a^t{\left(t-\tau \right)}^{n-\alpha -1}{f}^{\left(n\right)}\left(\tau \right)d\tau ,\hfill \end{array}$$

(27)

is called the Caputo fractional differential operator of order α.

For practical purposes, consider $0<\alpha \le 1$, so that Operator (27) reduces to

$${{}^C\mathcal{D}}_{a+}^{\alpha }f\left(t\right)={{}^{RL}\mathcal{I}}_{a+}^{1-\alpha }{f}^{\prime }\left(t\right)={\displaystyle \frac{1}{\Gamma (1-\alpha )}}{\int }_a^t{\left(t-\tau \right)}^{-\alpha }{f}^{\prime }\left(\tau \right)d\tau .$$

(28)

As we can see from Operators (26) and (27), the calculation of each derivative at time t involves all the information from the initial time $t_0=a$. From a computational point of view, we see later that this has significant repercussions due to resource constraints, such as memory. That is why we must look for ways to reduce the computational cost. One way to address this situation is through the well-known short-memory principle, which relates the approximation error to the memory length L.

(i) 

Riemann–Liouville derivative of order $0<\alpha <1$. Let $\Delta \left(t\right)$ be the error between ${{}^{RL}\mathcal{D}}_a^{\alpha }f\left(t\right)$ and ${{}^{RL}\mathcal{D}}_{t-L}^{\alpha }f\left(t\right)$ in $a+L\le t\le b$; then,

$$\begin{array}{cc}\hfill \Delta \left(t\right)& ={{}^{RL}\mathcal{D}}_a^{\alpha }f\left(t\right)-{{}^{RL}\mathcal{D}}_{t-L}^{\alpha }f\left(t\right)\hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma (1-\alpha )}}{\displaystyle \frac{d}{dt}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha }f\left(\tau \right)d\tau \hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma (1-\alpha )}}\{{\int }_a^{t-L}{\displaystyle \frac{\partial }{\partial t}}\left[{\left(t-\tau \right)}^{-\alpha }f\left(\tau \right)\right]d\tau \hfill \\ \hfill & +{(t-\tau )}^{-\alpha }f\left(\tau \right){|}_{\tau =t-L}{\displaystyle \frac{d(t-L)}{dt}}-{(t-\tau )}^{-\alpha }f\left(\tau \right){|}_{\tau =a}{\displaystyle \frac{da}{dt}}\}\hfill \\ \hfill \Delta \left(t\right)& ={\displaystyle \frac{-\alpha }{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}f\left(\tau \right)d\tau +{\displaystyle \frac{L^{-\alpha }}{\Gamma (1-\alpha )}}f(t-L)\hfill \end{array}$$

If $M={\parallel f\parallel }_{\infty }=\sup \left\{\left|f\left(t\right)\right|,t\in (a,b)\right\}$, then

$$\begin{array}{cc}\hfill \left|\Delta \left(t\right)\right|& =\left|{\displaystyle \frac{-\alpha }{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}f\left(\tau \right)d\tau +{\displaystyle \frac{L^{-\alpha }}{\Gamma (1-\alpha )}}f(t-L)\right|\hfill \\ \hfill & \le \left|{\displaystyle \frac{-\alpha }{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}f\left(\tau \right)d\tau \right|+\left|{\displaystyle \frac{L^{-\alpha }}{\Gamma (1-\alpha )}}f(t-L)\right|\hfill \\ \hfill & \le {\displaystyle \frac{1}{\Gamma (-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}\left|f\left(\tau \right)\right|d\tau +{\displaystyle \frac{L^{-\alpha }}{\Gamma (1-\alpha )}}\left|f(t-L)\right|\hfill \\ \hfill & \le {\displaystyle \frac{M}{\Gamma (-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}d\tau +{\displaystyle \frac{L^{-\alpha }M}{\Gamma (1-\alpha )}}\hfill \\ \hfill & ={\displaystyle \frac{M}{\Gamma (-\alpha )}}{\displaystyle \frac{1}{-\alpha }}\left[{(t-a)}^{-\alpha }-L^{-\alpha }\right]+{\displaystyle \frac{L^{-\alpha }M}{\Gamma (1-\alpha )}}\hfill \\ \hfill & ={\displaystyle \frac{M}{\Gamma (1-\alpha )}}{(t-a)}^{-\alpha }-{\displaystyle \frac{M{L}^{-\alpha }}{\Gamma (1-\alpha )}}+{\displaystyle \frac{L^{-\alpha }M}{\Gamma (1-\alpha )}}\hfill \\ \hfill & ={\displaystyle \frac{M}{\Gamma (1-\alpha )}}{(t-a)}^{-\alpha }\hfill \end{array}$$

Finally, considering $a+L\le t$, it follows that $L\le t-a$, which implies $L^{\alpha }\le {(t-a)}^{\alpha }$, i.e., ${(t-a)}^{-\alpha }\le L^{-\alpha }$. Therefore, the following bound is obtained:

$$\left|\Delta \left(t\right)\right|\le {\displaystyle \frac{M}{\Gamma (1-\alpha )}}{(t-a)}^{-\alpha }\le {\displaystyle \frac{M}{\Gamma (1-\alpha )}}{L}^{-\alpha }.$$

(29)

Remark 5.

Inequality (29) can be used to determine memory length L providing the required precision ${\epsilon }_1$. Then, to ensure $\left|\Delta \left(t\right)\right|<{\epsilon }_1$ (the estimation error), the memory length should satisfy

$${\left({\displaystyle \frac{M}{{ϵ}_1\Gamma (1-\alpha )}}\right)}^{1/\alpha }\le L,$$

(30)

in order to satisfy the short-memory principle

$${{}^{RL}\mathcal{D}}_a^{\alpha }f\left(t\right)\approx {{}^{RL}\mathcal{D}}_{t-L}^{\alpha }f\left(t\right).$$

(31)

(ii) 

Caputo derivative of order $0<\alpha <1$. In a similar manner to the previous case, the error is given by

$${}^C\Delta ={{}^C\mathcal{D}}_a^{\alpha }f\left(t\right)-{{}^C\mathcal{D}}_{t-L}^{\alpha }f\left(t\right)={\displaystyle \frac{1}{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha }{f}^{\prime }\left(\tau \right)d\tau .$$

(32)

From Equation (32), define

$$\begin{array}{cc}\hfill u& ={\displaystyle \frac{1}{\Gamma (1-\alpha )}}{(t-\tau )}^{-\alpha },du={\displaystyle \frac{\alpha }{\Gamma (1-\alpha )}}{(t-\tau )}^{-\alpha -1}d\tau \hfill \\ \hfill dv& =f^{\prime }\left(\tau \right)d\tau ,v=f\left(\tau \right)\hfill \end{array}$$

Then, one has

$$\begin{array}{cc}\hfill {}^C\Delta & ={\displaystyle \frac{1}{\Gamma (1-\alpha )}}{(t-\tau )}^{-\alpha }f\left(\tau \right){|}_a^{t-L}-{\displaystyle \frac{\alpha }{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}f\left(\tau \right)d\tau \hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma (1-\alpha )}}\left[{(t-\tau )}^{-\alpha }f\left(\tau \right){|}_{\tau =t-L}-{(t-\tau )}^{-\alpha }f\left(\tau \right){|}_{\tau =a}\right]\hfill \\ \hfill & -{\displaystyle \frac{\alpha }{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}f\left(\tau \right)d\tau \hfill \\ \hfill & ={\displaystyle \frac{1}{\Gamma (1-\alpha )}}\left[L^{-\alpha }f(t-L)-{(t-a)}^{-\alpha }f\left(a\right)\right]-{\displaystyle \frac{\alpha }{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}f\left(\tau \right)d\tau .\hfill \end{array}$$

Considering the bound $M={\parallel f\parallel }_{\infty }=\sup \left\{\left|f\left(t\right)\right|,t\in (a,b)\right\}$ and the triangle inequality, it is possible to conclude

$$\begin{array}{cc}\hfill \left|{}^C\Delta \right|& \le {\displaystyle \frac{M}{\Gamma (1-\alpha )}}\left[L^{-\alpha }+{(t-a)}^{-\alpha }\right]+{\displaystyle \frac{\alpha M}{\Gamma (1-\alpha )}}{\int }_a^{t-L}{\left(t-\tau \right)}^{-\alpha -1}d\tau \hfill \\ \hfill & ={\displaystyle \frac{M}{\Gamma (1-\alpha )}}\left[L^{-\alpha }+{(t-a)}^{-\alpha }\right]+{\displaystyle \frac{\alpha M}{\Gamma (1-\alpha )}}\left[{\displaystyle \frac{L^{-\alpha }}{\alpha }}-{\displaystyle \frac{{(t-a)}^{-\alpha }}{\alpha }}\right]\hfill \\ \hfill & ={\displaystyle \frac{2M{L}^{-\alpha }}{\Gamma (1-\alpha )}}.\hfill \end{array}$$

When $\left|{}^C\Delta \right|<{\epsilon }_2$ holds, the memory length must satisfy

$${\left({\displaystyle \frac{2M}{{ϵ}_2\Gamma (1-\alpha )}}\right)}^{1/\alpha }\le L,$$

(33)

to fulfill the short-memory principle

$${{}^C\mathcal{D}}_a^{\alpha }f\left(t\right)\approx {{}^C\mathcal{D}}_{t-L}^{\alpha }f\left(t\right).$$

(34)

Remark 6

([48]). The above result was expected since, for absolutely continuous functions $f\in {AC}^1[a,b]$ and $0<\alpha <1$, the following relation holds:

$${{}^{RL}\mathcal{D}}_a^{\alpha }f\left(t\right)={{}^C\mathcal{D}}_a^{\alpha }f\left(t\right)+{\displaystyle \frac{f\left(a\right)}{\Gamma (1-\alpha )}}{(t-a)}^{-\alpha }.$$

(35)

Figure 4 illustrates the general idea behind the short-memory principle: the classical derivative (of order n) is a local operator because it depends only on the function’s behavior at the evaluation point $f\left(\widehat{t}\right)$. In contrast, the fractional derivative is a non-local operator, since the value of the derivative at the point $\widehat{t}$ depends on the entire history of the function from an initial point a. Equation (34) states that, when $\widehat{t}$ is large, the contribution of the values of $f^{\prime }\left(\tau \right)$ near the lower limit a becomes negligible in the calculation of the derivative at $\widehat{t}$, that is, we can define a memory window L to approximate the fractional derivative by considering only the recent interval. This reduces the computational load, since computing an integral over the entire history of a system (a to t) requires memory and processing time that grow indefinitely as $\widehat{t}$ increases. By limiting the calculation to a window L, the computational cost becomes constant and manageable [55,56].

Figure 4. Visualization of the short-memory principle.

4. Numerical Solution of Fractional Differential Equations

A fractional differential equation (FDE) can be defined similarly to ordinary or partial differential equations, i.e., equations that involve fractional-order derivatives of a dependent variable with respect to another independent variable, such as time. Assuming the existence and uniqueness of solutions, this section presents numerical methods based on successive approximations to solve FDE. The idea of successive approximations is simple [57,58,59]; recall that the function $x\left(t\right)$ is a solution to the initial value problem $\dot{x}=f(t,x\left(t\right))$, $x_a=x\left(a\right)$ if and only if it is a solution to Volterra’s integral equation

$$x\left(t\right)=x_a+{\int }_a^{t}f(\tau ,x\left(\tau \right))d\tau .$$

(36)

Let us now see how to formulate the integral equation problem and the solution method for FDEs.

4.1. Fractional Differential Equations with Caputo Derivative

Let $m-1<\alpha <m$ be the fractional-order; the function $x\left(t\right)$ is a solution of

$${{}^C\mathcal{D}}_a^{\alpha }x\left(t\right)=f(t,x\left(t\right)),{\displaystyle \frac{d^{\mathsf{\ell }}x}{d{t}^{\mathsf{\ell }}}}{|}_{t=a}=x_a^{\left(\mathsf{\ell }\right)},\mathsf{\ell }=0,1,\dots ,m-1,$$

(37)

if and only if it is a solution of Volterra’s integral equation

$$\begin{array}{cc}\hfill x\left(t\right)& ={\displaystyle \sum _{\mathsf{\ell }=0}^{m-1}}{\displaystyle \frac{{(t-a)}^{\mathsf{\ell }}}{\mathsf{\ell }!}}{x}_a^{\left(\mathsf{\ell }\right)}+{{}^{RL}\mathcal{I}}_a^{\alpha }f(t,x\left(t\right))\hfill \end{array}$$

(38)

whose solution can be constructed using the method of successive approximations [44,48]. Evidently, if $\alpha =1$, we recover the classical initial value problem and its integral—Equation (36). In particular, for $0<\alpha \le 1$, Volterra’s integral in Equation (38) takes the following form:

$$\begin{array}{cc}\hfill x\left(t\right)& =x_a+{\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_a^t{(t-\tau )}^{\alpha -1}f(\tau ,x\left(\tau \right))d\tau .\hfill \end{array}$$

(39)

In contrast to the general exposition of FDE from an analytical point of view, using different valuable methods to determine explicit forms associated with the solution sought in various problems, multiple studies have been carried out to analyze numerical methods to solve FDEs, including error analysis and computational implementation [60,61,62,63,64]. Evaluating Volterra’s integral in Equation (38) at time $t=t_{n+1}$ with initial time $a=0$,

$$x\left(t_{n+1}\right)={\displaystyle \sum _{\mathsf{\ell }=0}^{m-1}}{\displaystyle \frac{t_{n+1}^{\mathsf{\ell }}}{\mathsf{\ell }!}}{x}_0^{\left(\mathsf{\ell }\right)}+{{}^{RL}\mathcal{I}}_0^{\alpha }f(t,x\left(t\right)){|}_{t=t_{n+1}}.$$

(40)

Based on the left-fractional rectangular method in (11), it follows Approximation (40) $x\left(t_{n+1}\right)=x_{n+1}$ can be determined as

$$x_{n+1}={\displaystyle \sum _{\mathsf{\ell }=0}^{m-1}}{\displaystyle \frac{t_{n+1}^{\mathsf{\ell }}}{\mathsf{\ell }!}}{x}_0^{\left(\mathsf{\ell }\right)}+h^{\alpha }{\displaystyle \sum _{k=0}^{(n+1)-1}}f(t_k,x_k){\Lambda }_{(n+1)-k-1}^{\left(\alpha \right)}.$$

Reducing terms, we have, for $m-1<\alpha <m$,

$$\left\{\begin{array}{cc}\hfill x_{n+1}& ={\displaystyle \sum _{\mathsf{\ell }=0}^{m-1}}{\displaystyle \frac{t_{n+1}^{\mathsf{\ell }}}{\mathsf{\ell }!}}{x}_0^{\left(\mathsf{\ell }\right)}+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_k,x_k){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k+1)}^{\alpha }-{(n-k)}^{\alpha }}{\Gamma (\alpha +1)}}.\hfill \end{array}\right.$$

(41)

Similarly, now using the right-fractional rectangular method in (13), the solution can be approximated for $m-1<\alpha <m$ as

$$\left\{\begin{array}{cc}\hfill x_{n+1}& ={\displaystyle \sum _{\mathsf{\ell }=0}^{m-1}}{\displaystyle \frac{t_{n+1}^{\mathsf{\ell }}}{\mathsf{\ell }!}}{x}_0^{\left(\mathsf{\ell }\right)}+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_{k+1},x_{k+1}){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k+1)}^{\alpha }-{(n-k)}^{\alpha }}{\Gamma (\alpha +1)}}.\hfill \end{array}\right.$$

(42)

Finally, based on the fractional trapezoidal formula in (24), it is straightforward to verify for $m-1<\alpha <m$

$$\left\{\begin{array}{cc}\hfill x_{n+1}& ={\displaystyle \sum _{\mathsf{\ell }=0}^{m-1}}{\displaystyle \frac{t_{n+1}^{\mathsf{\ell }}}{\mathsf{\ell }!}}{x}_0^{\left(\mathsf{\ell }\right)}+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left[f(t_0,x_0){\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}+f(t_{n+1},x_{n+1})+{\displaystyle \sum _{k=1}^n}f(t_k,x_k)W_{n-k+1}^{\left(\alpha \right)}\right],\hfill \\ \hfill {\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}& =n^{\alpha +1}-{(n+1)}^{\alpha }(n-\alpha ),\hfill \\ \hfill W_{n-k+1}^{\left(\alpha \right)}& ={(n-k+2)}^{\alpha +1}+{(n-k)}^{\alpha +1}-2{(n-k+1)}^{\alpha +1}.\hfill \end{array}\right.$$

(43)

In particular, if $0<\alpha <1$, Algorithms (41), (42) and (43) take the form of product integration (PI) rules to solve FDEs [61,65]:

• Explicit PI rectangular rule (fractional forward Euler method):

  $$\left\{\begin{array}{cc}\hfill x_{n+1}& =x_0+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_k,x_k){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k+1)}^{\alpha }-{(n-k)}^{\alpha }}{\Gamma (\alpha +1)}},\hfill \end{array}\right.$$

  (44)
• Implicit PI rectangular rule (fractional backward Euler method):

  $$\left\{\begin{array}{cc}\hfill x_{n+1}& =x_0+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_{k+1},x_{k+1}){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k+1)}^{\alpha }-{(n-k)}^{\alpha }}{\Gamma (\alpha +1)}},\hfill \end{array}\right.$$

  (45)
• Implicit-type trapezoidal rule:

  $$\left\{\begin{array}{cc}\hfill x_{n+1}& =x_0+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left[f(t_0,x_0){\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}+f(t_{n+1},x_{n+1})+{\displaystyle \sum _{k=1}^n}f(t_k,x_k)W_{n-k+1}^{\left(\alpha \right)}\right],\hfill \\ \hfill {\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}& =n^{\alpha +1}-{(n+1)}^{\alpha }(n-\alpha ),\hfill \\ \hfill W_{n-k+1}^{\left(\alpha \right)}& ={(n-k+2)}^{\alpha +1}+{(n-k)}^{\alpha +1}-2{(n-k+1)}^{\alpha +1}.\hfill \end{array}\right.$$

  (46)

Remark 7.

We obtain classical numerical methods from Algorithms (44) and (45) if $\alpha =1$. In both cases, the coefficient ${\Lambda }_{n-k}^{\left(1\right)}=1$, which implies

$$\begin{array}{cc}\hfill x_{n+1}& =x_0+h{\displaystyle \sum _{k=0}^n}f(t_k,x_k),\hfill \end{array}$$

(47)

and

$$\begin{array}{cc}\hfill x_{n+1}& =x_0+h{\displaystyle \sum _{k=0}^n}f(t_{k+1},x_{k+1}).\hfill \end{array}$$

(48)

Methods (47) and (48) represent the classical forward Euler and backward Euler methods, respectively [49,66]. On the other hand, considering $\alpha =1$ in (46), one has ${\mathsf{\Omega }}_{n+1}^{\left(1\right)}=1$ and $W_{n-k+1}^{\left(1\right)}=2$, so that

$$\begin{array}{cc}\hfill x_{n+1}& =x_0+{\displaystyle \frac{h}{2}}\left[f(t_0,x_0)+f(t_{n+1},x_{n+1})+2{\displaystyle \sum _{k=1}^n}f(t_k,x_k)\right]\hfill \\ \hfill & =x_0+{\displaystyle \frac{h}{2}}\left[f(t_0,x_0)+f(t_{n+1},x_{n+1})+{\displaystyle \sum _{k=1}^n}f(t_k,x_k)+{\displaystyle \sum _{k=0+1}^{\left(n-1\right)+1}}f(t_{\left(k+1\right)-1},x_{\left(k+1\right)-1})\right].\hfill \end{array}$$

Applying Property (25) to the last term of the above equation, it follows that

$$\begin{array}{cc}\hfill x_{n+1}& =x_0+{\displaystyle \frac{h}{2}}\left[f(t_0,x_0)+f(t_{n+1},x_{n+1})+{\displaystyle \sum _{k=1}^n}f(t_k,x_k)+{\displaystyle \sum _{k=0}^{n-1}}f(t_{k+1},x_{k+1})\right]\hfill \\ \hfill & =x_0+{\displaystyle \frac{h}{2}}\left[\left(f(t_0,x_0)+{\displaystyle \sum _{k=1}^n}f(t_k,x_k)\right)+\left(f(t_{n+1},x_{n+1})+{\displaystyle \sum _{k=0}^{n-1}}f(t_{k+1},x_{k+1})\right)\right]\hfill \\ \hfill & =x_0+{\displaystyle \frac{h}{2}}\left[{\displaystyle \sum _{k=0}^n}f(t_k,x_k)+{\displaystyle \sum _{k=0}^n}f(t_{k+1},x_{k+1})\right].\hfill \end{array}$$

By grouping the two previous sums, we arrive at the trapezoidal method for solving ordinary differential equations [49,66]:

$$x_{n+1}=x_0+{\displaystyle \frac{h}{2}}{\displaystyle \sum _{k=0}^n}\left[f(t_k,x_k)+f(t_{k+1},x_{k+1})\right].$$

(49)

The calculation of $x_{n+1}$ in (45) and (46) depends on itself. However, the solution can be estimated in two phases: the predictor step with Equation (44), which provides an initial estimate of the solution, and later the corrector step with (46), which refines the initial estimate. These ideas allow us to obtain the predictor–corrector (PC) scheme (see [67] for an in-depth discussion regarding the error analysis of this numerical method):

$$\left\{\begin{array}{cc}\hfill x_{n+1}^{\mathrm{P}}& =x_0+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_k,x_k){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill x_{n+1}& =x_0+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left[f(t_0,x_0){\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}+f(t_{n+1},x_{n+1}^{\mathrm{P}})+{\displaystyle \sum _{k=1}^n}f(t_k,x_k)W_{n-k+1}^{\left(\alpha \right)}\right].\hfill \end{array}\right.$$

(50)

4.2. Fractional Differential Equations with Riemann–Liouville Derivative

Consider the Riemann–Liouville operator in (26) with $m-1<\alpha <m$, and the nonlinear model

$${{}^{RL}\mathcal{D}}_a^{\alpha }x\left(t\right)=f(t,x\left(t\right)),{{}^{RL}\mathcal{D}}_a^{\alpha -\mathsf{\ell }}x(a+)=b_{\mathsf{\ell }},\mathsf{\ell }=1,\dots ,m,$$

(51)

where ${{}^{RL}\mathcal{D}}_a^{\alpha -\mathsf{\ell }}x(a+)$ represents the limit at almost all the points of the right-hand side neighborhood of a, i.e., in the set $(a,a+ϵ)$, $ϵ>0$:

$$\left\{\begin{array}{cc}\hfill {{}^{RL}\mathcal{D}}_a^{\alpha -\mathsf{\ell }}x(a+)& =\underset{t\to a^{+}}{\lim }{{}^{RL}\mathcal{D}}_a^{\alpha -\mathsf{\ell }}x\left(t\right),\mathsf{\ell }=1,\dots ,m-1,\hfill \\ \hfill {{}^{RL}\mathcal{D}}_a^{\alpha -m}x(a+)& =\underset{t\to a^{+}}{\lim }{{}^{RL}\mathcal{I}}_{a+}^{m-\alpha }x\left(t\right),\alpha \ne m\hfill \\ \hfill {{}^{RL}\mathcal{D}}_a^{0}x(a+)& =x\left(a\right),\alpha =m\hfill \end{array}\right.$$

(52)

According to [44,48], $x\left(t\right)$ is a solution of (51) if and only if it is a solution of the Volterra equation

$$\begin{array}{cc}\hfill x\left(t\right)& ={\displaystyle \sum _{\mathsf{\ell }=1}^m}{\displaystyle \frac{b_{\mathsf{\ell }}}{\Gamma (\alpha -\mathsf{\ell }+1)}}{(t-a)}^{\alpha -\mathsf{\ell }}+{\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_a^t{(t-\tau )}^{\alpha -1}f(\tau ,x\left(\tau \right))d\tau .\hfill \end{array}$$

(53)

Evaluating Equation (53) at $t=t_{n+1}$ with $a=0$, we obtain

$$x\left(t_{n+1}\right)={\displaystyle \sum _{\mathsf{\ell }=1}^m}{\displaystyle \frac{b_{\mathsf{\ell }}}{\Gamma (\alpha -\mathsf{\ell }+1)}}{t}_{n+1}^{\alpha -\mathsf{\ell }}+{{}^{RL}\mathcal{I}}_{0+}^{\alpha }f(t,x\left(t\right)){|}_{t=t_{n+1}}.$$

(54)

Now, considering numerical Method (11) with $t_{n+1}=(n+1)h$, it follows that

$$\left\{\begin{array}{cc}\hfill x_{n+1}& ={\displaystyle \sum _{\mathsf{\ell }=1}^m}{\displaystyle \frac{b_{\mathsf{\ell }}}{\Gamma (\alpha -\mathsf{\ell }+1)}}{\left((n+1)h\right)}^{\alpha -\mathsf{\ell }}+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_k,x_k){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k+1)}^{\alpha }-{(n-k)}^{\alpha }}{\Gamma (\alpha +1)}}.\hfill \end{array}\right.$$

(55)

For systems of order $0<\alpha \le 1$, the corresponding integral in Equation (53) is reduced to

$$\begin{array}{cc}\hfill x\left(t\right)& ={\displaystyle \frac{b_1}{\Gamma \left(\alpha \right)}}{(t-a)}^{\alpha -1}+{\displaystyle \frac{1}{\Gamma \left(\alpha \right)}}{\int }_a^t{(t-\tau )}^{\alpha -1}f(\tau ,x\left(\tau \right))d\tau ,\hfill \end{array}$$

(56)

with

$$b_1={{}^{RL}\mathcal{D}}_a^{\alpha -1}x(a+)=\underset{t\to a^{+}}{\lim }{{}^{RL}\mathcal{I}}_{a^{+}}^{1-\alpha }x\left(t\right).$$

(57)

Taking $x_0={\displaystyle \frac{b_1{h}^{\alpha -1}}{\Gamma \left(\alpha \right)}}$ and $a=0$, the Explicit PI-RL rectangular rule is given as

$$\left\{\begin{array}{cc}\hfill x_{n+1}& ={(n+1)}^{\alpha -1}{x}_0+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_k,x_k){\Lambda }_{n-k}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k+1)}^{\alpha }-{(n-k)}^{\alpha }}{\Gamma (\alpha +1)}}.\hfill \end{array}\right.$$

(58)

5. Practical Aspects for FPGA Implementation of Numerical Methods

The numerical methods presented in the previous section are based on simple operations, which allow us to determine closed forms for computing the n-th iteration of the solution of an FDE. However, each iteration depends on a finite sum that must be computed at each instant, which imposes a considerable computational burden. In this section, we make a small modification to the algorithms to obtain equivalent forms with greater computational advantage, which we use to implement dynamic systems in embedded systems [68].

5.1. Modified Explicit PI Algorithm

According to (44), it is straightforward to obtain the sample n

$$\left\{\begin{array}{cc}\hfill x_n& =x_0+h^{\alpha }{\displaystyle \sum _{k=0}^{n-1}}f(t_k,x_k){\Lambda }_{n-k-1}^{\left(\alpha \right)},\hfill \\ \hfill {\Lambda }_{n-k-1}^{\left(\alpha \right)}& ={\displaystyle \frac{{(n-k)}^{\alpha }-{(n-k-1)}^{\alpha }}{\Gamma (\alpha +1)}}.\hfill \end{array}\right.$$

(59)

From (59), the initial condition is expressed as ${\displaystyle x_0=x_n-h^{\alpha }{\displaystyle \sum _{k=0}^{n-1}}f(t_k,x_k){\Lambda }_{n-k-1}^{\left(\alpha \right)}}$, so that Equation (44) can be written as

$$\begin{array}{cc}\hfill x_{n+1}& =x_n-h^{\alpha }{\displaystyle \sum _{k=0}^{n-1}}f(t_k,x_k){\Lambda }_{n-k-1}^{\left(\alpha \right)}+h^{\alpha }{\displaystyle \sum _{k=0}^n}f(t_k,x_k){\Lambda }_{n-k}^{\left(\alpha \right)}\hfill \\ \hfill & =x_n+h^{\alpha }{\displaystyle \sum _{k=0}^{n-1}}f(t_k,x_k)\left[{\Lambda }_{n-k}^{\left(\alpha \right)}-{\Lambda }_{n-k-1}^{\left(\alpha \right)}\right]+h^{\alpha }f(t_n,x_n){\Lambda }_0^{\left(\alpha \right)}.\hfill \end{array}$$

Then, after some elementary simplifications, an iterative method for $n\ge 1$ is obtained, i.e.,

$$\begin{array}{cc}\hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{k=0}^{n-1}}f(t_k,x_k)W_{n-k}^{(\alpha -1)}\right].\hfill \end{array}$$

(60)

It is essential to mention that the iteration for $n=0$ is obtained directly from Algorithm (44) to complete the calculations. Considering that the sum must be performed from $k=0$ to $k=n-1$ at each iteration of Algorithm (60), we employ the short-memory principle in (34) to reduce the computational cost and physical limitations of embedded systems. Then, for $n\ge L+1$, the iterations of (60) are recalculated as

$$\begin{array}{cc}\hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{k=n-1-L}^{n-1}}f(t_k,x_k)W_{n-k}^{(\alpha -1)}\right].\hfill \end{array}$$

(61)

Defining $j=n-k$ as a new variable yields $k=n-j$. Then, (60) and (61) are rewritten as

$$\begin{array}{cc}\hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{j=1}^n}f(t_{n-j},x_{n-j})W_j^{(\alpha -1)}\right]\hfill \end{array}$$

(62)

and

$$\begin{array}{cc}\hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{j=1}^{L+1}}f(t_{n-j},x_{n-j})W_j^{(\alpha -1)}\right],\hfill \end{array}$$

(63)

respectively. Finally, by setting the initial value $x_0$, use Algorithm (44) for $n=0$, so that the modified explicit PI algorithm for FPGA implementations has the recursive equation

$$\left\{\begin{array}{cc}\hfill x_1& =x_0+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}f(t_0,x_0)\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{j=1}^{\nu }}f(t_{n-j},x_{n-j})W_j^{(\alpha -1)}\right],\hfill \end{array}\right.$$

(64)

with

$$\nu =\left\{\begin{array}{c}\hfill n,1\le n\le L\\ \hfill L+1,n\ge L+1\end{array}\right.$$

(65)

Remark 8.

In particular, for $\alpha =1$, one has $W_j^{\left(0\right)}=0$, so we get the classical Euler’s numerical method

$$x_{n+1}=x_n+hf(t_n,x_n).$$

(66)

5.2. Modified Explicit PC Algorithm

In a similar manner to the previous case, from (46), we get $x_n$ and solve for the value of $x_0$ given by

$$\begin{array}{cc}\hfill x_0& =x_n-{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left[f(t_0,x_0){\mathsf{\Omega }}_n^{\left(\alpha \right)}+f(t_n,x_n)+{\displaystyle \sum _{k=1}^{n-1}}f(t_k,x_k)W_{n-k}^{\left(\alpha \right)}\right].\hfill \end{array}$$

Substituting the above equation into (50) yields

$$\begin{array}{cc}\hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\{f(t_0,x_0)\left[{\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}-{\mathsf{\Omega }}_n^{\left(\alpha \right)}\right]+f(t_{n+1},x_{n+1}^{\mathrm{P}})\hfill \\ \hfill & +f(t_n,x_n)\left[W_1^{\left(\alpha \right)}-1\right]+{\displaystyle \sum _{k=1}^{n-1}}f(t_k,x_k)\left[W_{n-k+1}^{\left(\alpha \right)}-W_{n-k}^{\left(\alpha \right)}\right]\}.\hfill \end{array}$$

Combining with the explicit rule in (60) and performing the corresponding simplifications, for $n\ge 2$, we obtain the following numerical method:

$$\left\{\begin{array}{cc}\hfill x_{n+1}^{\mathrm{P}}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{k=0}^{n-1}}f(t_k,x_k)W_{n-k}^{(\alpha -1)}\right]\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}[f(t_0,x_0){\gamma }_n^{\left(\alpha \right)}+{\displaystyle \sum _{k=1}^{n-1}}f(t_k,x_k){\delta }_{n-k}^{\left(\alpha \right)}\hfill \\ \hfill & +f(t_{n+1},x_{n+1}^{\mathrm{P}})+(2^{\alpha +1}-3)f(t_n,x_n)],\hfill \end{array}\right.$$

(67)

where

$$\begin{array}{cc}\hfill {\gamma }_n^{\left(\alpha \right)}& ={\mathsf{\Omega }}_{n+1}^{\left(\alpha \right)}-{\mathsf{\Omega }}_n^{\left(\alpha \right)}\hfill \\ \hfill & =n^{\alpha }(2n-1-\alpha )-{(n+1)}^{\alpha }(n-\alpha )-{(n-1)}^{\alpha +1},\hfill \end{array}$$

(68)

and

$$\begin{array}{cc}\hfill {\delta }_{n-k}^{\left(\alpha \right)}& =W_{n-k+1}^{\left(\alpha \right)}-W_{n-k}^{\left(\alpha \right)}\hfill \\ \hfill & ={(n-k+2)}^{\alpha +1}+3{(n-k)}^{\alpha +1}-3{(n-k+1)}^{\alpha +1}-{(n-k-1)}^{\alpha +1}.\hfill \end{array}$$

(69)

Remark 9.

If $\alpha =1$, we obtain ${\gamma }_n^{\left(\alpha \right)}=0$ and ${\delta }_{n-k}^{\left(\alpha \right)}=0$. Numerical Method (67) is reduced to the classical predictor–corrector method

$$\left\{\begin{array}{cc}\hfill x_{n+1}^{\mathrm{P}}& =x_n+hf(t_n,x_n)\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h}{2}}\left[f(t_n,x_n)+f(t_{n+1},x_{n+1}^P)\right]\hfill \end{array}\right.$$

(70)

According to the short-memory principle, one has

$$\left\{\begin{array}{cc}\hfill x_{n+1}^{\mathrm{P}}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{k=n-1-L}^{n-1}}f(t_k,x_k)W_{n-k}^{(\alpha -1)}\right]\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}[f(t_0,x_0){\gamma }_n^{\left(\alpha \right)}+{\displaystyle \sum _{k=n-L}^{n-1}}f(t_k,x_k){\delta }_{n-k}^{\left(\alpha \right)}\hfill \\ \hfill & +f(t_{n+1},x_{n+1}^{\mathrm{P}})+(2^{\alpha +1}-3)f(t_n,x_n)],\hfill \end{array}\right.$$

(71)

where $n\ge L+2$. To further simplify the algorithms and obtain a more computationally efficient implementation, let us again consider the change of variables $j=n-k$, which implies $k=n-j$. Then, Algorithms (67) and (71) are rewritten as

$$\left\{\begin{array}{cc}\hfill x_{n+1}^{\mathrm{P}}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{j=1}^n}f(t_{n-j},x_{n-j})W_j^{(\alpha -1)}\right]\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}[f(t_0,x_0){\gamma }_n^{\left(\alpha \right)}+{\displaystyle \sum _{j=1}^{n-1}}f(t_{n-j},x_{n-j}){\delta }_j^{\left(\alpha \right)}\hfill \\ \hfill & +f(t_{n+1},x_{n+1}^{\mathrm{P}})+(2^{\alpha +1}-3)f(t_n,x_n)]\hfill \end{array}\right.$$

(72)

and

$$\left\{\begin{array}{cc}\hfill x_{n+1}^{\mathrm{P}}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{j=1}^{L+1}}f(t_{n-j},x_{n-j})W_j^{(\alpha -1)}\right]\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}[f(t_0,x_0){\gamma }_n^{\left(\alpha \right)}+{\displaystyle \sum _{j=1}^L}f(t_{n-j},x_{n-j}){\delta }_j^{\left(\alpha \right)}\hfill \\ \hfill & +f(t_{n+1},x_{n+1}^{\mathrm{P}})+(2^{\alpha +1}-3)f(t_n,x_n)]\hfill \end{array}\right.$$

(73)

respectively.

Finally, we can establish a recursive equation for the modified explicit PC algorithm by setting the initial value $x_0$, and using Algorithms (44), (62) for $n=0$ and $n=1$, respectively, that is,

$$\left\{\begin{array}{cc}\hfill x_1& =x_0+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}f(t_0,x_0)\hfill \\ \hfill x_2& =x_1+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_1,x_1)+(2^{\alpha }-2)f(t_0,x_0)\right]\hfill \\ \hfill x_{n+1}^{\mathrm{P}}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +1)}}\left[f(t_n,x_n)+{\displaystyle \sum _{j=1}^{\nu }}f(t_{n-j},x_{n-j})W_j^{(\alpha -1)}\right]\hfill \\ \hfill x_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}[f(t_0,x_0){\gamma }_n^{\left(\alpha \right)}+{\displaystyle \sum _{j=1}^{\overline{\nu }}}f(t_{n-j},x_{n-j}){\delta }_j^{\left(\alpha \right)}\hfill \\ \hfill & +f(t_{n+1},x_{n+1}^{\mathrm{P}})+(2^{\alpha +1}-3)f(t_n,x_n)]\hfill \end{array}\right.$$

(74)

with

$$\nu =\left\{\begin{array}{c}\hfill n,2\le n\le L\\ \hfill L+1,n\ge L+1\end{array}\right.\overline{\nu }=\left\{\begin{array}{c}\hfill n-1,2\le n\le L\\ \hfill L,n\ge L+1\end{array}\right.$$

(75)

Remark 10.

Consider the function ${\gamma }_n^{\left(\alpha \right)}$ in (68) for $n\ge 2$. By direct substitution, one gets ${\gamma }_n^{\left(0\right)}={\gamma }_n^{\left(1\right)}=0$. If $0<\alpha <1$, then ${\displaystyle \underset{n\to \infty }{\lim }{\gamma }_n^{\left(\alpha \right)}=0}$ for all $n\ge 2$. The most significant value always occurs in iteration $n=2$, i.e., ${\gamma }_2^{\left(\alpha \right)}>{\gamma }_n^{\left(\alpha \right)}$ for all $n\ge 3$. In addition, the minimum possible value always occurs when $\alpha \approx 0.649824$ (see Appendix B for details). Then, for practical purposes, from algorithm (74), let

$$\begin{array}{cc}\hfill {\widehat{x}}_{n+1}& =x_n+{\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\left[{\displaystyle \sum _{j=1}^{\overline{\nu }}}f(t_{n-j},x_{n-j}){\delta }_j^{\left(\alpha \right)}+f(t_{n+1},x_{n+1}^{\mathrm{P}})+(2^{\alpha +1}-3)f(t_n,x_n)\right],\hfill \end{array}$$

(76)

for $\parallel {\gamma }_n^{\left(\alpha \right)}\parallel <\tilde{\epsilon }$ from a determined $\widehat{n}$. Then, considering $M={\parallel f\parallel }_{\infty }=\sup \left\{\left|f\left(t\right)\right|,t\in (a,b)\right\}$, one has that

$$\begin{array}{c}\hfill \parallel x_{n+1}-{\widehat{x}}_{n+1}\parallel ={\displaystyle \frac{h^{\alpha }}{\Gamma (\alpha +2)}}\parallel f(t_0,x_0){\gamma }_n^{\left(\alpha \right)}\parallel \le {\displaystyle \frac{h^{\alpha }M}{\Gamma (\alpha +2)}}\tilde{\epsilon }\end{array}$$

for $\widehat{n}\le n$, and $\parallel x_{n+1}-{\widehat{x}}_{n+1}\parallel \to 0$ as $n\to \infty$. This simplification reduces resource use, such as embedded system memory.

Remark 11.

Numerical Methods (64) and (74) consider the short-memory principle. However, because they are expressed as difference equations, L is expressed in terms of the number of samples. With a window memory time $T_{mem}$ and step size h, we have $L={\displaystyle \frac{T_{mem}}{h}}$. The pseudocode provided by Algorithms A1 and A2 describes each numerical method.

6. Numerical and Experimental Results

Fractional-order derivatives introduce a memory effect that captures long-range temporal dependencies, enabling the more accurate modeling of real-world phenomena than integer-order approaches [69]. In chaotic systems, this intrinsic memory enhances dynamical complexity, ergodicity, and the emergence of hidden attractors, making fractional-order models particularly attractive for a wide range of applications.

Despite these advantages, the numerical solution of fractional-order differential equations is considerably more demanding than in the integer-order case. Each state depends on the entire history of previous states, leading to high computational and memory requirements. Numerical methods based on definitions such as Caputo, Grünwald–Letnikov (GL), or Riemann–Liouville (RL) involve convolution-like operations that are inefficient for real-time execution on general-purpose processors or microcontrollers [70].

To alleviate this burden, the short-memory principle is often employed, which assumes that the influence of distant past states becomes negligible beyond a finite time window. By truncating the memory length, the computational and storage requirements can be significantly reduced, at the cost of a controlled approximation error [25,26]. This trade-off is especially relevant in practical implementations where bounded resources are a constraint.

In this section, we validate the numerical algorithms from the previous section to characterize a family of chaotic systems. We also present numerical results for each family member, along with experimental implementation results on FPGA boards and a PRNG application.

6.1. Generalized Lorenz Family

The generalized Lorenz family consists of a 3-dimensional dynamical system given by

$$\dot{\mathbf{x}}=f_{\mathcal{L}}\left(\mathbf{x}\right).$$

(77)

The explicit form of (77) is

$$\left.\begin{array}{cc}\hfill {\dot{x}}_1& =a_{11}{x}_1+a_{12}{x}_2+d_1\hfill \\ \hfill {\dot{x}}_2& =a_{21}{x}_1+a_{22}{x}_2+\gamma x_1{x}_3+d_2\hfill \\ \hfill {\dot{x}}_3& =\mu {x_1}^2+\delta x_2{x}_1+a_{33}{x}_3+d_3\hfill \end{array}\right\}$$

(78)

where $a_{11}$, $a_{12}$, $a_{21}$, $a_{22}$, $a_{33}$, $d_1$, $d_2$, $d_3$, $\gamma$, $\delta$, and $\mu$ are parameters, and their choice allows us to obtain a different chaotic system. Table 1 lists the parameter sets that define the dynamical system family in (78) for $d_1=d_2=0$.

Table 1. Parameters of the generalized Lorenz family in (78) considering $d_1=d_2=0$.

System	${\mathit{a}}_{11}$	${\mathit{a}}_{12}$	${\mathit{a}}_{21}$	${\mathit{a}}_{22}$	${\mathit{a}}_{33}$	$\mathit{\gamma }$	$\mathit{\delta }$	$\mathit{\mu }$	${\mathit{d}}_3$
Lorenz  [15]	$-a$	a	c	$-1$	$-b$	$-1$	1	0	0
Chen [71]	$-a$	a	$c-a$	c	$-b$	$-1$	1	0	0
Burke–Shaw [72]	$-a$	$-a$	0	$-1$	0	$-k$	g	0	d
Liu [73]	$-a$	a	c	0	$-b$	$-k$	0	$\widehat{h}$	0
Shimizu–Morioka [74]	0	a	1	$-c$	$-b$	$-1$	0	1	0
Lü [75]	$-a$	a	0	c	$-b$	$-1$	1	0	0
Yang [76]	$-a$	a	c	0	$-b$	$-1$	1	0	0

The analysis of Family (78) was presented in [77] using the Grünwald–Letnikov (GL) derivative approach. However, the GL and Caputo derivatives have different properties; therefore, applying parameters from [77] or those associated with integer order does not guarantee that Family (78) will exhibit chaotic behavior. To characterize Family (78) with the Caputo operator, consider two key aspects:

(1) 

A system with n state variables possesses n Lyapunov exponents $\lambda$, each corresponding to a direction in state space. The largest Lyapunov exponent (LLE) quantifies the rate at which two initially close trajectories diverge or converge. If $\lambda <0$, nearby trajectories converge, and the system tends toward an equilibrium or stable state. If $\lambda =0$, trajectories neither converge nor diverge, as in a limit cycle. If $\lambda >0$, nearby trajectories diverge while remaining bounded, as in a chaotic attractor.

(2) 

A bifurcation represents a qualitative change in system behavior when a parameter surpasses a critical value. The bifurcation diagram illustrates the transition to chaos and reveals the structure of the parameter region. A single curve in the diagram indicates that the system settles into an equilibrium or a stable fixed point. A curve that successively splits into two, four, and eight branches demonstrates period-doubling behavior. A dense cloud of points indicates chaotic behavior, where the trajectory never repeats.

The bifurcation diagram depicts the long-term states as a parameter varies, while the LLE quantifies the degree of chaos in those states. These metrics are typically plotted against the same parameter and compared. A dense cloud in the diagram corresponds to a positive LLE, whereas a single curve or periodic window corresponds to a negative or zero LLE. The consistency between these indicators strengthens the validity of numerical results, while discrepancies often indicate insufficient simulation time, unremoved transients, or numerical problems.

According to [78,79], Algorithms A1 and A2 calculate the LLE for each system in family (78). Figure 5 and Figure 6 (Algorithm A1) and Figure 7 and Figure 8 (Algorithm A2) show how the fractional order $\alpha$ and the short-memory window $T_{mem}$ affect the LLE in each system. In the two-dimensional map of the LLE over $\alpha$ and $T_{mem}$, a black contour marks the level $\lambda =0$, the border between regular dynamics ($\lambda <0$) and chaotic regime ($\lambda >0$). For clarity, the LLE surface shows a gray plane at $\lambda =0$, indicating where the surface crosses from negative to positive values. In contrast to the LLE calculation, we show a 3D point cloud of the state variable $x_1$ against $\alpha$ and $T_{mem}$, with bifurcation diagrams stacked along the memory-window axis. Each horizontal slice is the bifurcation diagram for one $T_{mem}$.

Figure 5. Based on Algorithm A1, we quantitatively analyzed the Largest Lyapunov Exponent (LLE), comparing the effects of fractional order $\alpha$ and the memory window $T_{mem}$ to assess the short-memory principle. The results correspond to Lorenz system (a–c), the Chen system (d–f), the Burke–Shaw system (g–i), and the Liu system (j–l), respectively.

Figure 6. Based on Algorithm A1, we quantitatively analyzed the Largest Lyapunov Exponent (LLE), comparing the effects of fractional order $\alpha$ and the memory window $T_{mem}$ to assess the short-memory principle. The results correspond to Shimizu–Morioka system (a–c), the Lü system (d–f), and the Yang system (g–i), respectively.

Figure 7. Based on Algorithm A2, we quantitatively analyzed the Largest Lyapunov Exponent (LLE), comparing the effects of fractional order $\alpha$ and the memory window $T_{mem}$ to assess the short-memory principle. The results correspond to Lorenz system (a–c), the Chen system (d–f), the Burke–Shaw system (g–i), and the Liu system (j–l), respectively.

Figure 8. Based on Algorithm A2, we quantitatively analyzed the Largest Lyapunov Exponent (LLE), comparing the effects of fractional order $\alpha$ and the memory window $T_{mem}$ to assess the short-memory principle. The results correspond to Shimizu–Morioka system (a–c), the Lü system (d–f), and the Yang system (g–i), respectively.

In all systems, the sign of the LLE changes at a critical $\alpha$ that depends only weakly on $T_{mem}$ once the window is long enough. For the Lorenz system, the transition under Algorithm A1 is near $\alpha \approx 0.955$ (Figure 5a–c). Chaotic behavior ($\lambda$ up to ≈0.9) appears above it. Chen and Liu have thresholds near $\alpha \approx 0.82$ (Figure 5d–f,j–l). The Chen system shows a second contour at $\alpha \approx 1$. The Liu system has a second boundary near $\alpha \approx 0.90$ with an irregular contour. This points to alternating regular/chaotic windows rather than a single transition. Burke–Shaw has one near $\alpha \approx$ 0.89–0.90 (Figure 5g–i). Lü and Yang systems (Figure 6d–i) have several vertical contours and bands at $\alpha \approx 1$ showing multiple transitions between regular and chaotic behavior. In the Shimizu–Morioka system (Figure 6a–c), the transition is more gradual, and the LLE is small (LLE $<0.1$), with a much longer window time than in the other systems ($T_{mem}\approx 10 \mathrm{s}$, $\alpha \approx 0.91$). The contour shows a sink in the point cloud around the transition. The results associated with Algorithm A2 (Figure 7 and Figure 8) shift to higher $\alpha$: for the Lorenz system, the transition is near $\alpha \approx 0.967$; for Chen, it shifts to $\alpha \approx 0.845$; for Burke–Shaw, $\alpha \approx 0.915$; and, for Liu, the first boundary is near $\alpha \approx 0.84$.

For small $T_{mem}$, the contour oscillates strongly in $\alpha$. The oscillations appear as ripples in the 3D surfaces and as striped patterns in the negative-LLE region. Once $T_{mem}$ exceeds approximately $2$ s, the contour becomes almost vertical, and the LLE stabilizes. This indicates that a truncated memory window is enough to reproduce the dynamics, which is the central point of the short-memory principle.

The chaotic region appears as two separate blocks of points in $x_1$. A gap separates them and corresponds to the attractor’s two symmetric wings. The cloud preserves its shape as $T_{mem}$ increases, so the bifurcation structure does not depend on the window length for sufficiently large $T_{mem}$. Checking that the LLE map and the bifurcation diagram agree, and that both are stable for large $T_{mem}$, provides evidence that the short-memory scheme is reliable.

To determine the Lyapunov exponents and bifurcation diagrams described above, we used the parameters from Table 2 in conjunction with Algorithms A1 and A2. For all systems, we used an initial condition $\mathbf{x}\left(0\right)=(0.1,0.5,0.1)$ and a simulation time of $300$ s to analyze the effect of $0.1\le T_{mem}\le 8$ s. The only exception is the Shimizu–Morioka system; due to its slow dynamics, we used a simulation time of $2500$ s, with $0.1\le T_{mem}\le 50$ s for Algorithms A1 and A2.

Table 2. Specific parameters of System (78) with $d_1=d_2=0$.

System	h [s]	Parameters	Interval of $\mathit{\alpha }$
Lorenz	0.004	$a=12$, $b=1.5$, $c=38$	$0.94\le \alpha \le 1$
Chen	0.004	$a=35$, $b=3$, $c=26$	$0.75\le \alpha \le 1$
Burke–Shaw	0.004	$a=10$, $k=10$, $g=10$, $d=10$	$0.85\le \alpha \le 1$
Liu	0.004	$a=10$, $b=2.5$, $c=40$, $k=1$, $\widehat{h}=4$	$0.75\le \alpha \le 1$
Shimizu–Morioka	0.04	$a=1$, $b=0.45$, $c=0.75$	$0.86\le \alpha \le 1$
Lü	0.004	$a=36$, $b=3$, $c=20$	$0.85\le \alpha \le 1$
Yang	0.004	$a=19.4$, $b=1.55$, $c=38.2$	$0.92\le \alpha \le 1$

The preceding analysis allows for the characterization of Family (78) modeled by Caputo Derivative (27). Each system uses the parameters in Table 2, with $h=0.004$ ($h=0.04$ for the Shimizu–Morioka system), a simulation time of $300$ s ($2500$ s for the Shimizu–Morioka system), the memory window $T_{mem}=2$ s ($T_{mem}=20$ s for the Shimizu–Morioka system), and the fractional dynamics governed by $\alpha =0.97$. All systems share the same initial condition, $\mathbf{x}\left(0\right)=(0.1,0.5,0.1)$. Using Algorithm A1, we obtained the results shown in Figure 9 and Figure 10, which depict the phase-plane projections ($x_1$–$x_2$, $x_1$–$x_3$, $x_2$–$x_3$) and the corresponding chaotic attractor. For Algorithm A2, we used a shorter simulation time for Chen, Burke–Shaw, and Liu ($100$ s); for Lorenz, Lü, and Yang, we used $150$ s. For the Shimizu–Morioka system, we used the same parameters as in Algorithm A1. In both cases, $L={\displaystyle \frac{T_{mem}}{h}}=500$. Figure 11 and Figure 12 show the simulation results obtained with Algorithm A2.

Figure 9. Simulation results considering Algorithm A1 applied to Family (78), showing the phase plane projections and the chaotic attractor of Lorenz system (a,b), the Chen system (c,d), the Burke–Shaw system (e,f), and the Liu system (g,h).

Figure 10. Simulation results considering Algorithm A1 applied to Family (78), showing the phase plane projections and the chaotic attractor of Shimizu–Morioka system (a,b), the Lü system (c,d), and the Yang system (e,f).

Figure 11. Simulation results considering Algorithm A2 applied to Family (78), showing the phase plane projections and the chaotic attractor of Lorenz system (a,b), the Chen system (c,d), the Burke–Shaw system (e,f), and the Liu system (g,h).

Figure 12. Simulation results considering Algorithm A2 applied to Family (78), showing the phase plane projections and the chaotic attractor of Shimizu–Morioka system (a,b), the Lü system (c,d), and the Yang system (e,f).

6.2. FPGA Experiments

Field-Programmable Gate Arrays (FPGAs) offer an effective alternative because their inherent parallelism and reconfigurability suit accelerating the repetitive operations and memory accesses associated with fractional operators. Before implementing a system on an FPGA, you must analyze how its variables and parameters are represented numerically. Floating-point is the usual alternative to fixed-point, but it generally costs more in area, power consumption, and design complexity. Fixed-point arithmetic stores real numbers as scaled integers, so it maps directly onto adders and multipliers, whereas floating-point arithmetic needs operations such as exponent alignment and normalization, which add latency and hardware [80]. Comparative studies report 20–30% gains and considerable logic savings when replacing floating-point with an optimized fixed-point representation [81], and FPGA implementations of fractional-order systems based on product integration commonly adopt fixed-point formats for this reason. The cost is that the word length and scaling must be chosen carefully to avoid overflow and maintain sufficient precision, which precision-tuning and error-analysis techniques can address systematically [82,83].

To experimentally validate the proposed algorithms, the rectangular (REC) and predictor–corrector (PC) methods, based on the Caputo derivative, are implemented on FPGAs and applied to the Lorenz family models in (78), with the parameters indicated in the previous subsection, except for the integration steps. In the implementation, h = 0.004 (0.04 for Shimizu–Morioka) is used for the rectangular method, and h = 0.01 (0.1 for Shimizu–Morioka) for the predictor–corrector method. This is because the predictor–corrector method allows the use of larger integration steps without losing the stability of the algorithm or the chaotic properties of the dynamic models. Both implementations use Q1.11.20, a 32-bit signed fixed-point format with 1 sign bit, 11 integer bits and 20 fractional bits. The integer part holds the state variables and the stored vector-field evaluations without overflow in all fourteen system–method combinations evaluated. The fractional part gives a spacing of $2^{-20}\approx 9.54\times {10}^{-7}$ between representable values. The vector-field evaluations are the right-hand sides (RHSs) of the system equations, and they are stored for the memory calculations.

Since finite precision can change the dynamics of digitally implemented chaotic systems [84,85], the fractional part is assessed quantitatively. All seven systems are simulated with both methods, using $\alpha =0.97$ and a memory duration $T_{mem}=2$ s, except for Shimizu–Morioka, where $T_{mem}=20$ s. Representations Q1.11.F, with total word length $W=12+F$ from 16 to 64 bits, are compared against double-precision implementations of the same finite-memory algorithms. Every comparison uses the same nominal initial conditions, parameters, timestep and memory window. The fixed-point simulations reproduce the hardware truncation and the widened intermediate arithmetic, including the quantization of initial values and stored constants.

Short-time trajectory agreement, shown in Figure 13a, is measured with the normalized root-mean-square error (NRMSE)

$$E_{\mathrm{traj}}\left(Q\right)=100\sqrt{{\displaystyle \frac{{\displaystyle {\displaystyle \sum _{n=0}^{N_s}}{\parallel {\mathbf{X}}_n^{\left(Q\right)}-{\mathbf{X}}_n^{\left(D\right)}\parallel }_2^2}}{{\displaystyle {\displaystyle \sum _{n=0}^{N_s}}{\parallel {\mathbf{X}}_n^{\left(D\right)}\parallel }_2^2}}}},$$

(79)

where ${\mathbf{X}}_n^{\left(Q\right)}$ and ${\mathbf{X}}_n^{\left(D\right)}$ are the state vectors $(x_n,y_n,z_n)$ from the fixed-point and double-precision simulations at the same sampling instant, and $N_s$ represents the final sample index. The metric expresses the RMS distance between the trajectories as a percentage of the reference trajectory’s RMS magnitude.

Figure 13. Accuracy versus fractional precision for Q1.11.F. (a) Maximum short-time NRMSE across seven systems for each method. (b) Aggregate relative $L^1$ error of each complete ROM bank. Errors are percentages on logarithmic axes; points denote evaluated formats and connecting lines guide the eye. Bands mark Q1.11.20 (32 bits); annotations give its largest errors across methods in (a) and coefficient banks in (b).

The comparison covered the first $1$ s ($10$ s for the Shimizu–Morioka system), corresponding to 250 REC steps or 100 PC steps. This metric measures short-time agreement, including initial-state quantization and subsequent arithmetic errors. Chaotic sensitivity can amplify these perturbations and produce fluctuating trajectory differences; therefore, we did not interpret the metric as a measure of long-time attractor preservation. Figure 13a shows decreasing errors across the evaluated precisions: the maximum NRMSE among the fourteen cases decreased from $41.0\%$ at Q1.11.12 to $0.0649\%$ at Q1.11.20. Within the Q1.11.20 comparison windows, the largest instantaneous state-vector difference, normalized by the reference RMS state-vector magnitude, was $0.2811\%$.

Memory-coefficient accuracy, shown in Figure 13b, was evaluated using the aggregate relative $L^1$ error:

$$E_{\mathrm{mem}}\left(Q\right)=100{\displaystyle \frac{{\displaystyle \sum _{k\in \mathcal{K}}\left|{\widehat{w}}_k-w_k\right|}}{{\displaystyle \sum _{k\in \mathcal{K}}\left|w_k\right|}}},$$

(80)

where $w_k$ and ${\widehat{w}}_k$ are the original and quantized history coefficients. These coefficients weight the contributions of past vector-field evaluations. The metric measures the total absolute coefficient discrepancy relative to the total original coefficient magnitude; it is an aggregate bank error, not the largest error of an individual coefficient. Since the hardware supports any memory length $1\le M\le 1000$, the analysis covers the complete ROM coefficient tables instead of only the coefficients used for a particular M. Each bank stores the coefficients for lags 1–999 and one zero padding entry, which is left out of the evaluation by restricting the lags to $\mathcal{K}=\{1,\dots ,999\}$. REC and PC share the predictor-history coefficients, and PC also stores the interior and boundary corrector coefficients. The PC interior coefficient at lag 999 is stored but never used; it is still counted in the physical-ROM analysis because it occupies memory. At each precision, the coefficients are regenerated and rounded to the nearest representable value.

The largest aggregate error among the three banks is shown in Figure 13b to decrease from $26.7051\%$ at Q1.11.12 to $0.1252\%$ at Q1.11.20. At Q1.11.12, 796 predictor, 607 PC interior and 799 PC boundary coefficients were rounded to zero, out of 999 entries per bank. An accessed coefficient that is rounded to zero contributes nothing to the corresponding memory calculation. No nonzero coefficients were rounded to zero at Q1.11.20. This analysis covers the full supported coefficient range, whereas the trajectory accuracy and overflow results apply only to the operating memory windows specified above.

Finite-time surrogate largest Lyapunov exponent (LLE) estimates were used as supplementary dynamical diagnostics (Figure 14, with REC in panel (a) and PC in panel (b)). A tangent vector, representing an infinitesimal state perturbation, was propagated through the finite-memory recurrence using the smooth vector-field Jacobian along the simulated trajectory. After discarding the transient and a memory-window warm-up, the estimate was calculated as

$${\widehat{\lambda }}_{\mathrm{sur}}={\displaystyle \frac{1}{T_{\mathrm{meas}}}}{\displaystyle \sum _{r=1}^R}\ln \left({\displaystyle \frac{\parallel {\mathit{\eta }}_r^{-}{\parallel }_2}{{\delta }_0}}\right),$$

(81)

where ${\mathit{\eta }}_r^{-}$ is the tangent vector before renormalization, ${\delta }_0=1$ is its prescribed norm afterward, R is the number of retained renormalization intervals, and $T_{\mathrm{meas}}$ is their total duration. Both the tangent vector and its retained RHS history were rescaled at each renormalization. The accumulated logarithmic growth measures the average perturbation expansion rate in the smooth surrogate model.

Figure 14. Finite-time smooth-surrogate LLE estimates for the seven systems: (a) REC and (b) PC, with identical vertical scales. Markers show evaluated fixed-point formats, connecting lines guide the eye, and dashed horizontal lines show double-precision references. Hollow black squares flag constant post-transient trajectories. Bands mark Q1.11.20 (32 bits). Positive surrogate estimates alone do not establish chaotic stored trajectories.

At Q1.11.20, all fourteen estimates were positive, with maximum absolute differences from double precision of $0.1391$ s⁻¹ for REC and $0.1251$ s⁻¹ for PC. Unlike the errors in Figure 13, the estimates in Figure 14 do not vary monotonically with fractional precision, and, since they omit rounding discontinuities and are not classical LLEs of the quantized map, they are taken only as supplementary information about dynamical sensitivity. Positive estimates were even obtained for some constant Shimizu–Morioka trajectories at low precision, so positivity alone does not establish chaotic behavior of the stored trajectories. Overall, Q1.11.20 is supported as a practical common 32-bit representation for the evaluated operating conditions: overflow was avoided by its integer range, and close short-time trajectory agreement and low coefficient errors were obtained with its fractional precision, without any nonzero ROM coefficient being rounded to zero. Wider formats reduced the errors further, but at the cost of longer words.

The RTL architecture shown in Figure 15 implements the fractional-order Lorenz-family systems with Caputo’s incremental rectangular algorithm (Equation (64)). Its arithmetic datapath evaluates the functions $f_x$, $f_y$ and $f_z$. A configuration block selects the model parameters listed in Table 2 and the precomputed integration factor $C_{\alpha }=h^{\alpha }/\Gamma (\alpha +1)$, while a global input sets the length M of the short-memory window. The fractional order is fixed at $\alpha =0.97$ and the time step is $h=0.004$ s, except for the Shimizu–Morioka system, where $h=0.04$ s.

Figure 15. Simplified RTL architecture of the rectangular Caputo algorithm.

The short-memory module, shown in Figure 16, stores the previous function evaluations in a banked circular RAM. Like the rest of the datapath, it works in Q1.11.20, and intermediate products and sums keep extra bits that are rescaled and truncated only when they are stored. The depth of the memory is set directly by the number of samples M. If the memory is specified as a nominal duration $T_{mem}$, M is obtained outside the hardware from the integration step h:

$$M=\max \left\{1,\mathrm{round}\left({\displaystyle \frac{T_{mem}}{h}}\right)\right\}.$$

(82)

Figure 16. Short-memory module of the rectangular architecture.

The hardware does not perform this conversion. The selected value of M is maintained during operation, and changing M or the system requires a reset. At iteration n, the history contains $m_n=\min (n,M-1)$ previous evaluations, while the current function evaluation is processed separately. The implementation supports $M_{\max }=1000$ and uses 10 RAM banks of 100 words, each 96 bits wide to store the three 32-bit function evaluations. Circular addressing updates the history without shifting stored samples.

To accommodate the limited DSP resources of the DE1-SoC FPGA, a multiply–accumulate architecture evaluates the short-memory sums. Ten multiplier lanes process the history in batches of up to ten terms. A coefficient ROM supplies the weights, while bank-selection logic aligns the corresponding samples and coefficients. The same lanes are reused across batches and sequentially for the three functions, keeping the multiplier count independent of M. A reduction tree combines the ten products, and the resulting sums are accumulated in three registers. The final batch sets unused lanes to zero.

A local controller manages memory access and accumulation. The main finite-state machine (FSM) starts the short-memory calculation and updates the state register only after the historical sums are ready. At the same update edge, the held current function evaluations are written into RAM for the next numerical step. The history-validity counter is cleared during reset so that uninitialized RAM contents are ignored.

The synthesized memory capacity is determined by $M_{\max }$, whereas the computation time depends on the selected M. Thus, changing $M\le M_{\max }$ changes the number of processed history terms without changing the allocated RAM, ROM, or multiplier resources. For 32-bit samples and coefficients, with $M_{\max }$ a multiple of 10, the nominal storage is

$$\begin{array}{cc}\hfill B_{\mathrm{RAM}}& =96M_{\max }\mathrm{bits},\hfill \\ \hfill B_{\mathrm{ROM},\mathrm{REC}}& =32M_{\max }\mathrm{bits},\hfill \end{array}$$

(83)

giving a total of $128M_{\max }$ bits. The coefficient ROM contains $M_{\max }/10$ rows of 320 bits, including one unused coefficient position.

With a fully populated memory window and $M\ge 2$, each step uses $M-1$ previous evaluations per function. For the pipelined controller, the interval between successive state updates is

$$N_{\mathrm{clk},\mathrm{REC}}=5⌈{\displaystyle \frac{M-1}{10}}⌉+11.$$

(84)

The five cycles per batch account for memory access, batch loading, and the processing of the three function sums; the additional cycles cover the pipelined function evaluation, controller sequencing, and state update. During initialization, the shorter available history $m_n$ reduces the required number of batches. At clock frequency $f_{\mathrm{clk}}$, the computation time per numerical step is

$$T_{\mathrm{step}}={\displaystyle \frac{N_{\mathrm{clk}}}{f_{\mathrm{clk}}}}.$$

(85)

The architecture was described in VHDL and synthesized using Intel Quartus Prime. The resulting RTL schematic, shown in Figure 17, illustrates the shared equation evaluator, parameter-selection logic, short-memory module, controller, and state registers.

Figure 17. Quartus-generated RTL schematic of the rectangular architecture.

On the other hand, the predictor–corrector (PC) topology described in Equation (74) extends the rectangular architecture. First, the circuit computes the predicted state ${\mathbf{x}}_{n+1}^{\mathrm{P}}$ and subsequently the corrected state ${\mathbf{x}}_{n+1}$. The same pipelined equation evaluator is reused to calculate the nonlinear functions at the current and predicted states.

Figure 18 shows the PC architecture, and Figure 19 details the short-memory module. The history RAM retains the same 10-bank organization as REC. A shared ten-lane multiply–accumulate unit sequentially calculates the three predictor and three corrector history sums, using their respective coefficient sets. For the corrector, the coefficient associated with the oldest retained evaluation is selected separately, as required by the short-memory formulation. The same integration-factor multipliers are also reused in the predictor and corrector updates.

Figure 18. Simplified RTL architecture of the Caputo predictor–corrector algorithm.

Figure 19. Short-memory module of the predictor–corrector architecture.

A Moore FSM coordinates the evaluation of the current functions, short-memory sums, prediction, evaluation at the predicted state, and correction. The corrected state and the current function evaluations are then stored for the next step. The additional predictor registers and arithmetic increase hardware utilization, but no second ten-multiplier short-memory unit is required.

The PC coefficient ROM stores three 32-bit coefficients per history position, organized as $M_{\max }/10$ rows of 960 bits. The nominal RAM storage remains $96M_{\max }$ bits, while the ROM requires $96M_{\max }$ bits, giving $192M_{\max }$ bits in total. With a full memory window and $M\ge 2$, the pipelined PC controller requires

$$N_{\mathrm{clk},\mathrm{PC}}=8⌈{\displaystyle \frac{M-1}{10}}⌉+15$$

(86)

clock cycles per state update. Each batch includes two memory-access/loading cycles and six cycles for the predictor and corrector history sums. The additional cycles correspond to equation evaluations and the prediction/correction updates. The Quartus-generated RTL schematic of the PC architecture is shown in Figure 20.

Figure 20. Quartus-generated RTL schematic of the predictor–corrector architecture.

Regarding resource consumption, Table 3 summarizes the Quartus Prime post-fit results for both architectures on the Cyclone V 5CSEMA5F31C6 FPGA. For a common nominal short-memory duration of $T_{mem}=2$ s ($20$ s for the Shimizu–Morioka system), Equation (82) gives $M=500$ for REC and $M=200$ for PC. Once these windows are filled, Equations (84) and (86) give 261 and 175 clock cycles per state update, respectively.

Table 3. Post-fit FPGA resource utilization, estimated state-generation rates for fully populated short-memory windows, and estimated thermal power for Lorenz at 50 MHz. Percentages refer to available Cyclone V resources.

Metric	REC	PC
ALMs	3258 (10%)	3869 (12%)
Registers	2652	3569
DSP blocks	60 (69%)	69 (79%)
M10K blocks	38 (10%)	54 (14%)
Logical memory (bits)	128,000	192,000
$F_{\max }$ (MHz)	76.17	57.83
Selected M	500	200
Cycles per state update	261	175
State vectors/s at $F_{\max }$	291,839	330,457
Total thermal power	472.39 mW @ 50 MHz	477.69 mW @ 50 MHz
Core dynamic power	49.93 mW @ 50 MHz	55.32 mW @ 50 MHz

The state-generation rates are theoretical estimates calculated as

$$R_{\mathrm{state}}={\displaystyle \frac{F_{\max }}{N_{\mathrm{clk}}}},$$

(87)

using the worst-case post-fit $F_{\max }$ and full-window latency. Each generated state vector contains the simultaneous values $(x,y,z)=(x_1,x_2,x_3)$; these rates describe the computational architectures rather than the external visualization hardware. Although PC requires more DSP and memory resources and has a lower $F_{\max }$, its larger selected integration step reduces the number of history terms required for the same nominal memory duration, yielding a higher estimated state-generation rate under the reported configurations.

The short-memory module uses 30 DSP blocks in each architecture, while the common function evaluator uses 24. The state-update datapath requires 6 DSP blocks for REC and 15 for PC. The logical memory requirements correspond to 38 and 54 physical M10K blocks, respectively, after Quartus mapping.

Power was estimated using the Quartus Power Analyzer with activity from functional simulation supplemented by vectorless estimation. These estimates correspond to a common 50 MHz clock, typical device characteristics, and a 25 °C ambient temperature; HPS power is excluded, and both estimates are classified as low confidence by Quartus. Under these configurations, PC’s estimated core dynamic power is 10.8% higher than REC’s, while its estimated total thermal power is only 1.1% higher. The smaller relative difference in total power reflects the dominant core static component, approximately 412 mW in both architectures.

Table 4 comparatively provides an overview of the proposed architectures for FPGA implementations of fractional-order dynamic systems reported in the literature. Previous work has explored various numerical and architectural strategies, including integration schemes based on rectangular and trapezoidal approximations, the Grünwald–Letnikov methods, reconfigurable implementations, and frequency-domain approximations. Taken together, these studies demonstrate the feasibility of implementing fractional-order systems in programmable hardware and of adjusting certain numerical or configuration parameters. However, the comparison also shows that implementation characteristics are not always documented consistently, particularly with regard to memory usage, clock cycles per update, maximum frequency, power consumption, and specific selection and reconfiguration mechanisms. In addition, this comparison positions the proposed work within the context of integrating diverse models, configuring short-term memory, and evaluating two numerical schemes using explicit implementation metrics. Unlike previous studies in which some of these indicators are unavailable or cannot be verified, the characterization presented here allows for a joint analysis of resource utilization, maximum frequency, update latency, and estimated power consumption. However, since the studies considered use different devices, arithmetic representations, algorithms, and evaluation conditions, these results do not allow us to conclude that the proposed architectures are universally more efficient. Their main comparative value lies in providing a reproducible characterization of two implementation alternatives and demonstrating how the choice of numerical method affects the trade-off between hardware resources and temporal performance.

Table 4. Comparative hardware analysis of the proposed FPGA implementations of fractional-order chaotic systems. NR: not reported or not verifiable from the original paper.

Reference	Device/Arithmetic/ Derivative/Method	Systems Selectable in One Bitstream	Configuration and Memory	Resources	Cycles/Update	${\mathit{F}}_{\max }$ (MHz)	Complete State Vectors/s	Power
Proposed work REC	Cyclone V; 32-bit Q1.11.20 fixed-point; Caputo; explicit left-rectangle PI, incremental, short-memory	7: Lorenz, Chen, Burke–Shaw, Liu, Shimizu–Morioka, Lü, Yang	External system_select and M captured after reset; $M=1$–1000; $h=0.004$ s, except Shimizu–Morioka $0.04$ s; separate REC bitstream	3258 ALMs, 2652 regs, 60 DSPs, 38 M10K, 128,000 bits	261 at $M=500$; $C_{\mathrm{REC}}\left(M\right)=5\lceil (M-1)/10\rceil +11$ for $M\ge 2$	76.17	291,839 at $F_{\max }$, $M=500$	472.39 mW
Proposed work PC	Cyclone V; 32-bit Q1.11.20 fixed-point; Caputo; predictor–corrector PI, incremental, short-memory	7: Lorenz, Chen, Burke–Shaw, Liu, Shimizu–Morioka, Lü, Yang	External system_select and M captured after reset; $M=1$–1000; $h=0.01$ s, except Shimizu–Morioka $0.1$ s; separate PC bitstream	3869 ALMs, 3569 regs, 69 DSPs, 54 M10K, 192,000 bits	175 at $M=200$; $C_{\mathrm{PC}}\left(M\right)=8\lceil (M-1)/10\rceil +15$ for $M\ge 2$	57.83	330,457 at $F_{\max }$, $M=200$	477.69 mW
Abdelaty 2020 PI-RECT [27]	Artix-7; 32-bit fixed-point; Caputo PI rectangular	1: A multi-scroll chaotic system	Short-memory; different window sizes validated; exact mechanism NR	2156 LUTs, 1305 regs	NR	40.00	NR; 1280 Mbit/s reported	NR
Abdelaty 2020 PE-TRAP [27]	Artix-7; 32-bit fixed-point; Caputo PE-TRAP	1: A multi-scroll chaotic system	Short-memory; different window sizes validated; exact mechanism NR	19,038 LUTs, 2263 regs	NR	4.02	NR; 129.12 Mbit/s reported	NR
Mohamed 2021 [34]	Artix-7; 50-bit fixed-point; GL derivative IP core	3 systems reported, Liu, Li and Chen systems; selector mechanism implied reconfigurable	Real-time fractional-order configuration; memory setting NR	981 Slices, 2251 regs, 161 DSPs	NR	40.23	NR; 1.1266/1.1266/ 1.434 Gbit/s reported	NR
Tolba 2017 [33]	Virtex-5; 54-bit fixed-point; GL	1: Liu chaotic system	Different window sizes, orders, and step sizes; mechanism NR	5688 Slices, 4962 regs, 99 DSPs	NR	38.87	NR; 1.986 and 2.921 Gbit/s system throughputs	588 mW
Pano-Azucena 2019 [31]	Cyclone IV GX DE2i-150; 32-bit fixed-point; GL	3: Chaotic systems reported	Short-memory using RAM/ROM; exact mechanism NR	2236 Logic Elements, 24,576 memory bits, 92 embedded multiplier	NR	77.59–84.91	NR	NR
Sayed 2020 [86]	Nexys 4 Artix-7; 32-bit fixed-point; GL delayed FO system	1: Liu chaotic attractor	Window size L and delay $\tau$ studied; mechanism NR	10,026 LUTs, 5139 Slice registers	NR	37.57	NR; 1.2 Gbit/s reported	NR
Tolba 2020 [35]	Basys 3 Artix-7; 32-bit fixed-point; GL variable-order derivative	3: Three chaotic systems	Real-time configuration of order, step size, and parameters	12,917 LUTs, 3373 FF, 40 DSPs	NR	35.05	NR	NR
Mohamed 2023 [41]	Artix-7; 32-bit fixed-point; GL + reconfigurable CORDIC	1: Memristive Chaotic System	Memory/order mechanism NR	6269 Slices, 23,929 LUTs, 4599 regs, 144 DSPs	NR	12.36	NR; 0.396 Gbit/s reported	NR
Lin 2022 [87]	Zynq-7000/arithmetic NR; Bode-domain approximation	1: Chen Chaotic System	Adjustable settling-time parameter; memory NR	12,856 LUTs, 3183 FF, 78 DSPs	NR	NR	NR	NR
Núñez Pérez 2026 [88]	Artix-7; 32-bit fixed-point; ABM and EFORK	5 oscillators realized, one-bitstream selector NR	Reconfigurable VHDL modules; memory NR	ABM Lorenz 47,780 LUTs, 432 regs, 94 DSPs	NR	0.5	NR	NR

Figure 21 shows the experimental setup used to visualize the FPGA-generated chaotic attractors through a 16-bit digital-to-analog converter (DAC) and a digital oscilloscope.

Figure 21. Experimental setup with the DE1-SoC FPGA, 16–bit DAC, and oscilloscope.

The experimental chaotic time series of each system of the Lorenz family in (78), obtained with the parameters described previously and numerical Method (64), are presented in Figure 22 and Figure 23. The oscilloscope allows the phase plane projections to be obtained, which validate the chaotic attractors previously determined numerically. In contrast, the experimental results associated with numerical Method (74) are shown in Figure 24 and Figure 25.

Figure 22. Experimental results considering Rectangular Algorithm (64) applied to Family (78), showing the temporal series ($x_1\left(t\right)$, $x_2\left(t\right)$), ($x_1\left(t\right)$, $x_3\left(t\right)$) and the phase plane projections $x_1$–$x_2$, $x_1$–$x_3$, and $x_2$–$x_3$ of Lorenz system (a–e), the Chen system (f–j), the Burke–Shaw system (k–o), and the Liu system (p–t).

Figure 23. Experimental results considering Rectangular Algorithm (64) applied to Family (78), showing the temporal series ($x_1\left(t\right)$, $x_2\left(t\right)$), ($x_1\left(t\right)$, $x_3\left(t\right)$) and the phase plane projections $x_1$–$x_2$, $x_1$–$x_3$, and $x_2$–$x_3$ of Shimizu–Morioka system (a–e), the Lü system (f–j), and the Yang system (k–o).

Figure 24. Experimental results considering PC Algorithm (74) applied to Family (78), showing the temporal series ($x_1\left(t\right)$, $x_2\left(t\right)$), ($x_1\left(t\right)$, $x_3\left(t\right)$) and the phase plane projections $x_1$–$x_2$, $x_1$–$x_3$, and $x_2$–$x_3$ of Lorenz system (a–e), the Chen system (f–j), the Burke–Shaw system (k–o), and the Liu system (p–t).

Figure 25. Experimental results considering PC Algorithm (74) applied to Family (78), showing the temporal series ($x_1\left(t\right)$, $x_2\left(t\right)$), ($x_1\left(t\right)$, $x_3\left(t\right)$) and the phase plane projections $x_1$–$x_2$, $x_1$–$x_3$, and $x_2$–$x_3$ of Shimizu–Morioka system (a–e), the Lü system (f–j), and the Yang system (k–o).

6.3. PRNG Application

Pseudo-Random Number Generators (PRNGs) are essential components in modern cryptographic systems, where they are used to generate keys, nonces, and masks whose unpredictability directly impacts overall security. Unlike true random number generators (TRNGs), which exploit physical phenomena and are inherently non-reproducible, PRNGs are deterministic algorithms that produce reproducible sequences fully defined by an initial secret seed. This determinism makes them attractive for digital hardware, offering high throughput and easy integration, but also places strict requirements on statistical quality, period length and resistance to cryptanalytic attacks [89,90,91].

Chaotic dynamical systems have emerged as promising building blocks for PRNG design, owing to properties such as ergodicity, topological mixing and extreme sensitivity to initial conditions and parameters. These characteristics can be mapped to desirable cryptographic features like diffusion, confusion and high key sensitivity, and many chaos-based PRNGs have been shown to pass stringent statistical batteries such as NIST SP 800-22, TestU01 and ENT, as well as key-space and correlation analyses [90,92,93,94].

To further enhance randomness and enlarge the key space, several works combine multiple chaotic maps, introduce turbulence or cross-over operations between maps, or add perturbation and scrambling stages before bit extraction [90,92,94,95].

However, when chaotic systems are implemented digitally, the finite precision of arithmetic leads to orbit quantization, short periods, and the possible loss or degradation of chaos, a phenomenon that is particularly relevant for fixed-point realizations preferred in FPGA designs due to their simplicity, low resource usage, and high clock frequencies [91,96]. A variety of countermeasures have been proposed to mitigate this dynamic degradation, including the dynamic perturbation of the state, weak coupling of several maps, conservative systems with controlled repetition rates, and careful selection of fixed-point formats guided by finite-precision period analysis [90,97,98].

Within this context, chaotic PRNGs implemented with sufficient resolution on FPGA can generate long-period sequences that closely approximate their continuous-time behavior, achieving a favorable trade-off between hardware efficiency and statistical quality, and making them promising candidates for high-speed stream ciphers and lightweight security applications [99,100,101,102].

To generate pseudorandom sequences from the digitally implemented fixed-point chaotic system, a simple post-processing method is applied in this work. This approach uses a bitwise XOR operation on the least significant bits (LSBs), which typically exhibit faster variations than the most significant bits (MSBs). In the evaluated configuration, the eight LSBs of the $x_1$ and $x_3$ state variables are combined to obtain one 8-bit pseudorandom number per accepted state update:

$$r_n={\mathrm{LSB}}_8\left(X_{1,n}\right)\oplus {\mathrm{LSB}}_8\left(X_{3,n}\right),$$

where $X_{1,n}$ and $X_{3,n}$ denote the 32-bit fixed-point representations of $x_1$ and $x_3$ at update n, respectively. For the predictor–corrector topology, extraction is performed from the corrected state. The proposed post-processing scheme is illustrated in Figure 26.

Figure 26. Method for obtaining 8-bit pseudorandom numbers from 32-bit fixed-point chaotic variables.

The PRNG evaluation considers the Lorenz system for both topologies, with fractional order $\alpha =0.97$, parameters $(a,b,c)=(12,1.5,38)$, and common initial conditions $(x_1\left(0\right),x_2\left(0\right),x_3\left(0\right))=(0.1,0.5,0.1)$, quantized to Q1.11.20. The rectangular topology uses $h=0.004$ s and $M=500$, whereas the predictor–corrector topology uses $h=0.01$ s and $M=200$, corresponding to a common nominal short-memory duration of 2 s.

Since one 8-bit word is extracted per accepted state update, the steady-state bit rate supported by each chaotic core is

$$R_{\mathrm{bit}}={\displaystyle \frac{8f_{\mathrm{clk}}}{C_{\mathrm{update}}}},$$

where $f_{\mathrm{clk}}$ is the clock frequency and $C_{\mathrm{update}}$ is the number of clock cycles between accepted state updates. At 50 MHz, with the configured short-memory windows filled, the rectangular and predictor–corrector cores require 261 and 175 clock cycles per update, respectively. Table 5 summarizes the corresponding update intervals and bit rates. The predictor–corrector configuration supports an approximately $49.1\%$ higher rate because its larger integration step allows fewer memory samples for the same nominal memory duration, reducing the update interval despite the additional correction stage.

Table 5. Core-derived generation throughput for 8-bit output words at 50 MHz with filled short-memory windows.

Metric	Rectangular	Predictor–Corrector
Memory samples, M	500	200
Clock cycles per state update	261	175
Update interval (μs)	5.22	3.50
Core-derived bit rate (Mbit/s)	1.533	2.286

Finally, the statistical quality of the proposed pseudorandom number generators is evaluated using the NIST statistical test suite. After discarding an initial transient corresponding to 30 s of model time, a total of 1 billion bits, equivalent to 125 million 8-bit numbers, is collected directly from the FPGA implementation of each topology. Each dataset is divided into 1000 consecutive sequences of 1 million bits, using the default test parameters of NIST STS 2.1.2 [103].

This suite comprises 15 statistical test families that compare the evaluated sequences against an ideal random binary source, yielding 188 subtest results. Individual sequences pass a subtest when their p-value is greater than or equal to $0.01$. At the second level, the distribution of p-values is assessed for uniformity using a minimum p-value of ${10}^{-4}$, while the passing proportion is evaluated using the integer count thresholds implemented in STS 2.1.2, derived from the three-sigma interval. The Random Excursions and Random Excursions Variant proportions use only the eligible sequences: 594 for rectangular and 631 for predictor–corrector.

Table 6 summarizes the NIST results obtained for both topologies. For test families producing multiple outputs, the minimum uniformity p-value and the minimum passing proportion are reported separately. Both methods satisfy all acceptance checks reported by STS 2.1.2.

Table 6. Results of NIST statistical tests for rectangular and predictor–corrector topologies using 1 billion bits per method. The reported p-values assess the uniformity of individual sequence p-values. The p-value and proportion minima are computed independently across each family’s subtests.

Statistical Test	Rectangular		Predictor–Corrector
	p-Value	Proportion	p-Value	Proportion
Frequency	0.215574	989/1000	0.949278	991/1000
Block Frequency	0.866097	994/1000	0.014550	983/1000
Cumulative Sums	0.672470	988/1000	0.618385	986/1000
Runs	0.382115	992/1000	0.981417	991/1000
Longest Run	0.342451	990/1000	0.801865	993/1000
Rank	0.534146	985/1000	0.413628	984/1000
FFT	0.100709	987/1000	0.213309	991/1000
Non-Overlapping Template	0.005319	982/1000	0.002058	981/1000
Overlapping Template	0.113372	982/1000	0.182550	985/1000
Universal	0.040635	994/1000	0.216713	988/1000
Approximate Entropy	0.668321	989/1000	0.461612	992/1000
Random Excursions	0.086830	581/594	0.134686	617/631
Random Excursions Variant	0.009779	583/594	0.034625	621/631
Serial	0.437274	988/1000	0.029796	986/1000
Linear Complexity	0.286836	990/1000	0.616305	992/1000

To complement the NIST evaluation, the same binary streams are tested using the Rabbit, Alphabit and BlockAlphabit binary-file batteries of TestU01 1.2.3 [104]. BlockAlphabit is applied with block sizes 1, 2, 4, 8, 16 and 32. A reported statistic is considered suspicious when its p-value falls outside $[0.001,0.999]$. Table 7 summarizes the numbers of statistics within this interval; these counts refer to reported statistics, rather than sequence passing proportions.

Table 7. Results of the TestU01 binary-stream batteries for rectangular and predictor–corrector topologies using 1 billion bits per method.

Battery	Rectangular	Predictor–Corrector
Rabbit	40/40	40/40
Alphabit	17/17	17/17
BlockAlphabit	102/102	102/102

All three tested TestU01 batteries are successfully passed by both methods, with no suspicious p-values. The reported results support the statistical quality of the proposed generators for the evaluated configurations and stream lengths; statistical testing alone does not establish cryptographic security [103].

7. Conclusions

This work combines the dynamical characterization and FPGA implementation of seven fractional-order Lorenz-family systems using Caputo-based rectangular (REC) and predictor–corrector (PC) schemes with the short-memory principle. LLE maps and bifurcation diagrams obtained by varying both the fractional order $\alpha$ and memory duration $T_{mem}$ characterize the dynamical regimes within the investigated parameter ranges and guide the selection of finite-memory operating conditions. The effect of truncation was assessed through the consistency of these maps across $T_{mem}$, not against a full-memory reference solution.

The precision assessment supports Q1.11.20 as a practical representation for the evaluated configurations. Across the fourteen system–method combinations, fixed-point simulations produced a maximum short-time NRMSE of approximately 0.065% relative to the corresponding double-precision reference. These comparisons precede history truncation and therefore quantify finite-precision effects over the evaluated intervals. The coefficient-error assessment and supplementary smooth-surrogate LLE estimates provide additional information for selecting the arithmetic format.

We implemented separate REC and PC architectures on a Cyclone V FPGA, each supporting selection among the seven models and memory lengths from 1 to 1000 samples. After a reset, model and memory settings can be changed without modifying the HDL code or resynthesizing the design. Within each architecture, the maximum supported memory capacity determines resource allocation, while the selected memory length determines the processing workload and update latency. The hardware comparison quantifies resource utilization, timing, estimated throughput, and estimated power under the reported configurations. REC requires fewer hardware resources, whereas PC achieves a higher estimated state-generation rate because its larger selected timestep requires fewer history samples for the same nominal memory duration. Experimental phase portraits obtained through DAC-based oscilloscope measurements complement the numerical characterization.

The implementations also support a PRNG application that extracts pseudorandom bits from the state variables of the selected Lorenz-family model. We performed statistical evaluation in the Lorenz configuration for both REC and PC. The resulting streams met the acceptance criteria in NIST SP 800-22 and the Rabbit, Alphabit, and BlockAlphabit batteries of TestU01. These findings support the statistical quality of the evaluated streams under the specified conditions. Potential applications in secure communications and IoT require further cryptanalytic assessment.

The Riemann–Liouville formulation remains theoretical, since we must close a gap in the numerical analysis before we can implement and validate it on an FPGA. The proposal for the iterative method, as well as the characterization of the Lorenz family via the Riemann–Liouville derivative, remains an open problem for future study.