`[<<][meta][>>][..]`
Mon Feb 25 19:52:06 CET 2013

## Linear function test functions

```I got to a point where it's possible to convert an opaque function to:

- A partition of the inputs into linear variables and multiplicative parameters
- A (parameterized) state space representation of the linear map

One of the things that pops up is nilpotent matrices, particularly in
the function that implements the unit delay:

(define z
(lambda ((s)
(i))
(values i
s)))

This has the system matrix:

0 | 1
--+--
1 | 0

The eventual goal is to compute the I->O transfer function of the
system, which involves a matrix inverse.

Should this be special-cased to support the nilpotent case, which
probably always corresponds to a nilponent matrix.

(define z
(lambda ((s)
(i))
(values i
s)))

Testing another function gives another nilpotent matrix.

(define test-z3
(lambda ((s1 s2 s3) (i))
(values i s1 s2 s3)))

0 0 0 | 1
1 0 0 | 0
0 1 0 | 0
------+--
0 0 1 | 0

By reasoning, for pure delays the output should just be multiplied by
z = e^jw.  I wonder if there is a better way to do this.

It's probably best to special-case the `z' case, and throw an error if
a zero pivot shows up during GE.

Wait! the transfer function is

zs = A s + B i
o = C s + D i

or

s = (zI - A)^1 B i
o = C s + D i

or as a transfer function

o = C (zI - A)^1 B i

Even if A is nilpotent, this should still just work.  I.e. in the case
of `z' above, A = 0, so this becomes:

s = z^-1 i
o = s

or
o = z^-1 i

 http://en.wikipedia.org/wiki/State_space_representation

```
`[Reply][About]`
`[<<][meta][>>][..]`