# ncfmr

(Not recommended) Model reduction from normalized coprime factorization

`ncfmr`

is not recommended. Use `reducespec`

instead.* (since R2023b)* For more information on updating your code, see Version History.

## Description

`ncfmr`

computes a reduced-order approximation of a model by
truncating modes in a coprime factorization of the full-order model. This method is related to
the balanced truncation method, but it is particularly well-suited to controller order
reduction. For a stabilizing controller, the reduced controller is also stabilizing as long as
the approximation error is smaller than the robustness margin computed by
`ncfmargin`

.

`[`

computes a reduced-order approximation of the dynamic system model `Gred`

,`info`

] = ncfmr(`G`

,`ord`

)`G`

.
Specify the desired reduction order as `ord`

. If `ord`

is a vector, then `Gred`

is an array of approximations of the
corresponding order. The structure `info`

contains information about the
computation such as bounds on the approximation error.

`[~,`

computes the coprime factorization of `info`

] = ncfmr(`G`

)`G`

given by
`[M,N]`

such that `G = M\N`

(see `lncf`

), the
Hankel singular values of the factorization, and the error bounds. You can use this
information to determine the target reduction order programmatically based on desired
fidelity or robust stability considerations. Then, use the syntax ```
Gred =
ncfmr(G,ord,info)
```

to compute the reduced-order model.

computes the reduced-order approximation using the normalized coprime factorization and
Hankel singular values that you provide in `Gred`

= ncfmr(`G`

,`ord`

,info)`info`

. Obtain
`info`

using the previous syntax, ```
[~,info] =
ncfmr(G)
```

. Providing a previously computed `info`

to
`ncfmr`

allows you to perform model reduction without having to
recompute the factorization and Hankel singular values. This syntax is therefore
particularly useful when performance is a concern.

`ncfmr(G)`

plots the Hankel singular values and bounds on the
approximation error corresponding to each order. Examine the plot to determine a reduced
order based on desired fidelity or robust stability considerations. You can then use
`Gred = ncfmr(G,ord)`

to compute the reduced-order model.

## Examples

## Input Arguments

## Output Arguments

## Tips

You can use

`ncfmr`

to reduce the plant*G*or controller*K*while preserving closed-loop stability of the following SISO or MIMO feedback loop.Stability of this loop is preserved as long as the approximation error of the reduced plant is smaller than the robustness margin for this loop given by

`ncfmargin(G,K)`

.For controllers computed with

`ncfsyn`

, reducing the controller*K*that_{s}`ncfsyn`

computes for the shaped controller*G*is preferable. Both_{s}*K*and_{s}*G*are returned by_{s}`ncfsyn`

in the`info`

output argument. You can then compute*K*, the reduced controller for the original plant_{r}*G*, from*K*=_{r}*W*_{1}*K*_{sr}*W*_{2}, where*W*_{1}and*W*_{2}are the shaping weights used with`ncfsyn`

.For controllers obtained by other techniques, reduction with

`ncfmr`

also preserves stability if the error does not exceed the`ncfmargin`

margin. However, such reduction can partially remove integral action and introduce steady-state tracking errors. Therefore, removing any integrator terms from the controller before reduction with`ncfmr`

and replacing them in the reduced controller is recommended.

## Algorithms

`ncfmr`

performs the following steps to reduce the input model
*G* to the desired order *k*.

## Version History

**Introduced before R2006a**

## See Also

`reducespec`

| `lncf`

| `ncfsyn`

| `ncfmargin`