Assume that the target system is a continuous-time linear time-invariant (CT-LTI) system as follows:

where

$x\left(t\right)$ is the state of the system,

$u\left(t\right)$ is the input of the system, and

$y\left(t\right)$ is the output of the system. Let the tracking error

$e\left(t\right)$ be

where

$r\left(t\right)$ is the reference for the output. Then, the linear-quadratic tracking (LQT) problem can be expressed as follows [

6,

7,

8]:

where

$Q$ and

$R$ are positive definite matrices weighting for the tracking error and the input,

$J$ is the cost function,

${t}_{0}$ is the initial time, and

${t}_{f}$ is the final time. Assume that pair

$\left(A,B\right)$ is controllable and pair

$\left(A,{C}_{y}\right)$ is observable. Then, by the Lagrange multiplier method [

6,

7,

8] and the variational approach (

Theorem A1), the LQT problem (4) can be transformed into a problem of finding solutions of the Riccati equation with boundary conditions and an auxiliary dynamic equation related to the reference. The Riccati equation and the auxiliary dynamic equation can be derived as follows:

where

$P\left(t\right)$ and

$g\left(t\right)$ are the solutions to be determined. These solutions are usually calculated in the backward direction in time or by using iterations since

$A-B{R}^{-1}{B}^{T}P$, which is the system matrix of the closed-loop system, must have all the negative real parts of the eigenvalues. However, if there are no constraints on the input and the state, it is well known in control engineering that the solutions of the equations can be approximated to their steady-state values, and the solutions become independent of the time. In the case of input constraints alone, the optimal input can be determined by Pontryagin’s minimum principle [

6,

7,

8,

9]. In general, the solutions determined by Pontryagin’s minimum principle are closely related with the solutions of the Equations (5) and (6) and have a form simple enough to be implemented on modern microcontrollers. On the other hand, if there are inequality constraints on the state, the problem statement (4) is not valid, therefore it must be redefined as follows:

where

${C}_{h}$ and

$w$ are time-invariant parameters of the inequality constraints. The vector inequality

$h\le 0$ means that

${h}_{i}\le 0\left(i=1,\cdots ,n\right)$, where

$h={\left[\begin{array}{ccc}{h}_{1}& \cdots & {h}_{n}\end{array}\right]}^{T}$. In this case, the problem related to the direction of the calculation is hard to avoid.

Since the problem (7) is difficult to solve exactly, many kinds of research were proposed to solve this problem approximately. The first group of research consists of numerical approaches including dynamic programming methods [

6,

10,

11] or direct and indirect methods [

11,

12,

13]. In general, these methods discretize the target system and apply numerical methods. Since this procedure does not change the direction of the calculation, most of these methods need backward calculations or iterations for all the time steps. The second group of research comprises model-predictive control (MPC) methods including implicit MPC [

14,

15,

16,

17] and explicit MPC [

18,

19,

20]. The main difference from the first group is that time-forward calculation is possible since this method predicts the optimal states and inputs of the target system for a short time ahead. However, this method also requires repetitive calculations for the predictions, and the precision of the calculation decreases if the time length of the prediction is not long enough, therefore it still requires many computations in general. To reduce the computational load, explicit MPC was proposed. For explicit MPC design, methods dividing the state space are essential, but the results of these methods are not easy to analyze in practice [

21] since they are based on numerical iterations. In summary, the computational problem of the state-constrained optimal tracking control is that the direction of the exact computation for the solution is a time-backward calculation which leads to increasing computational loads.