# hinffi

Full-information H-infinity synthesis

## Syntax

``[K,CL,gamma] = hinffi(P,ncont)``
``[K,CL,gamma] = hinffi(P,ncont,gamTry)``
``[K,CL,gamma] = hinffi(P,ncont,gamRange)``
``[K,CL,gamma] = hinffi(___,opts)``
``[K,CL,gamma,info] = hinffi(___)``

## Description

Full-information synthesis assumes the controller has access to both the state vector x and the disturbance signal w. Synthesis with `hinffi` is the dual of the full-control problem covered by `hinffc`. For the more general output-feedback case when only output measurements are available, use `hinfsyn`.

````[K,CL,gamma] = hinffi(P,ncont)` computes the H∞-optimal control law$u=K\left[\begin{array}{c}x\\ w\end{array}\right]$for the plant `P`. The plant is described by the state-space equations:$\begin{array}{c}dx=Ax+{B}_{1}w+{B}_{2}u\\ z={C}_{1}x+{D}_{11}w+{D}_{12}u.\end{array}$Here, w represents the disturbance inputs, and z represents the error outputs to be kept small. `ncont` is the number of control inputs u, which must be the last inputs of `P`. The gain matrix `K` minimizes the H∞ norm of the closed-loop transfer function `CL` from the disturbance signals w to the error signals z. ```
````[K,CL,gamma] = hinffi(P,ncont,gamTry)` calculates a gain matrix for the target performance level `gamTry`. Specifying `gamTry` can be useful when the optimal achievable performance is better than you need for your application. In that case, a less-than-optimal solution can have smaller gains and be more numerically well-conditioned. If `gamTry` is not achievable, `hinffi` returns `[]` for `K` and `CL`, and `Inf` for `gamma`. ```
````[K,CL,gamma] = hinffi(P,ncont,gamRange)` searches the range `gamRange` for the best achievable performance. Specify the range with a vector of the form `[gmin,gmax]`. Limiting the search range can speed up computation by reducing the number of iterations performed to test different performance levels. ```
````[K,CL,gamma] = hinffi(___,opts)` specifies additional computation options. To create `opts`, use `hinfsynOptions`. Specify `opts` after all other input arguments.```
````[K,CL,gamma,info] = hinffi(___)` returns a structure containing additional information about the H∞ synthesis computation. You can use this argument with any of the previous syntaxes.```

## Input Arguments

collapse all

Plant, specified as an LTI model such as a state-space (`ss`) model. If `P` is a generalized state-space model with uncertain or tunable control design blocks, then `hinffi` uses the nominal or current value of those elements.

Construct `P` so that it has the partitioned form

`$\begin{array}{c}dx=Ax+{B}_{1}w+{B}_{2}u\\ z={C}_{1}x+{D}_{11}w+{D}_{12}u.\end{array}$`

Here, w represents the disturbance inputs, and z represents the error outputs to be kept small. The `ncont` control inputs u are the last inputs.

For information about conditions imposed on the plant matrices and how the software addresses them, see `hinfsyn`.

Number of control input signals in the plant, specified as a nonnegative integer. `hinffi` takes the last `ncont` plant inputs as the control u. The returned gain matrix `K` has `ncont` outputs.

Target performance level, specified as a positive scalar. `hinffi` attempts to compute a gain matrix such that the H of the closed-loop system does not exceed `gamTry`. If this performance level is achievable, then the returned gain matrix has `gamma``gamTry`. If `gamTry` is not achievable, `hinffi` returns an empty matrix.

Performance range for search, specified as a vector of the form `[gmin,gmax]`. The `hinffi` command tests only performance levels within that range. It returns a gain matrix with performance:

• `gamma``gmin`, when `gmin` is achievable.

• `gmin` < `gamma` < `gmax`, when `gmax` is achievable and but `gmin` is not.

• `gamma` = `Inf` when `gmax` is not achievable. In this case, `hinffi` returns `[]` for `K` and `CL`.

If you know a range of feasible performance levels, specifying this range can speed up computation by reducing the number of iterations performed by `hinffi` to test different performance levels.

Additional options for the computation, specified as an options object you create using `hinfsynOptions`. Available options include displaying algorithm progress at the command line, turning off automatic scaling and regularization, and specifying an optimization method. For more information, see `hinfsynOptions`.

## Output Arguments

collapse all

Gain matrix, returned as a matrix or `[]`. The gain-matrix dimensions are `ncont`-by-ny where ny is the number of states plus the number disturbance inputs of `P` (inputs not included in `ncont`).

If you supply `gamTry` or `gamRange` and the specified performance values are not achievable, then `K` = `[]`.

Closed-loop transfer function, returned as a state-space (`ss`) model object or `[]`. The returned performance level `gamma` is the H norm of `CL`.

If you supply `gamTry` or `gamRange` and the specified performance levels are not achievable, then `CL` = `[]`.

Closed-loop performance, returned as a nonnegative scalar value or `Inf`. This value is the H norm of `CL`. If you do not provide performance levels to test using `gamTry` or `gamRange`, then `gamma` is the best achievable performance level.

If you provide `gamTry` or `gamRange`, then `gamma` is the actual performance level achieved by the gain matrix computed for the best passing performance level that the function tries. If the specified performance levels are not achievable, then `gamma` = `Inf`.

Additional synthesis data, returned as a structure or `[]` (if the specified performance level is not achievable). `info` has the following fields

FieldDescription
`gamma`

Performance level used to compute the gain matrix `K`, returned as a nonnegative scalar. Typically, `hinffi` tests multiple target performance levels and returns a gain matrix corresponding to the best passing performance level (see the Algorithms section of `hinfsyn` for details). The value `info.gamma` is an upper limit on the actual achieved performance returned as the output argument `gamma`.

`X`

Riccati solution X for the performance level `info.gamma`, returned as a matrix. For more information, see the Algorithms section of `hinfsyn`.

`Preg`

Regularized plant used for `hinffi` computation, returned as a state-space (`ss`) model object. By default, `hinffi` automatically adds extra disturbances and errors to the plant to ensure that it meets certain conditions (see the Algorithms section of `hinfsyn`). The field `info.Preg` contains the resulting plant model.

## Algorithms

For information about the algorithms used for H synthesis, see `hinfsyn`.

 Doyle, J.C., K. Glover, P. Khargonekar, and B. Francis. "State-space solutions to standard H2 and H control problems." IEEE Transactions on Automatic Control, Vol 34, Number 8, , August 1989, pp. 831–847.