He estado escribiendo una caja de herramientas del sistema de control desde cero y puramente en Python3 (plug descarado:) harold
. De mi investigación anterior, siempre tengo quejas sobre el solucionador de Riccati care.m
por razones técnicas / irrelevantes.
Por lo tanto, he estado escribiendo mi propio conjunto de rutinas. Una cosa que no puedo encontrar es evitar un algoritmo de equilibrio de alto rendimiento, al menos tan bueno como balance.m
. Antes de mencionarlo, la xGEBAL
familia está expuesta en Scipy y básicamente puede llamar desde Scipy de la siguiente manera, supongamos que tiene una matriz 2D de tipo flotante A
:
import scipy as sp
gebal = sp.linalg.get_lapack_funcs(('gebal'),(A,)) # this picks up DGEBAL
Ab, lo, hi, scaling , info = gebal(A, scale=1 , permute=1 , overwrite_a=0 )
Ahora si uso la siguiente matriz de prueba
array([[ 6. , 0. , 0. , 0. , 0.000002],
[ 0. , 8. , 0. , 0. , 0. ],
[ 2. , 2. , 6. , 0. , 0. ],
[ 2. , 2. , 0. , 8. , 0. ],
[ 0. , 0. , 0.000002, 0. , 2. ]])
yo obtengo
array([[ 8. , 0. , 0. , 2. , 2. ],
[ 0. , 2. , 0.000002, 0. , 0. ],
[ 0. , 0. , 6. , 2. , 2. ],
[ 0. , 0.000002, 0. , 6. , 0. ],
[ 0. , 0. , 0. , 0. , 8. ]])
Sin embargo, si le paso esto balance.m
, me sale
>> balance(A)
ans =
8.0000 0 0 0.0625 2.0000
0 2.0000 0.0001 0 0
0 0 6.0000 0.0002 0.0078
0 0.0003 0 6.0000 0
0 0 0 0 8.0000
Si marca los patrones de permutación, son los mismos, sin embargo, la escala está desactivada. gebal
da escaladas unidad mientras que MATLAB proporciona las siguientes potencias de 2: [-5,0,8,0,2]
.
Aparentemente, estos no están usando la misma maquinaria. He probado varias opciones, como Lemonnier, Van Dooren escala a doble cara, Parlett-Reinsch original y también algunos otros métodos menos conocidos en la literatura, como la versión densa SPBALANCE
.
Un punto que quizás podría enfatizar es que conozco el trabajo de Benner; en particular, el equilibrio simpléctico de matrices hamiltonianas específicamente para este propósito. Sin embargo, tenga en cuenta que este tipo de tratamiento se realiza dentro de gcare.m
(solucionador generalizado de Riccati) y el equilibrio se realiza directamente a través de balance.m
. Por lo tanto, agradecería si alguien me puede señalar la implementación real.
Divulgación: Realmente no estoy tratando de revertir el código de ingeniería matemática: realmente quiero alejarme de él debido a varias razones, incluida la motivación de esta pregunta, es decir, no sé qué está haciendo lo que me costó mucho de tiempo atrás en el día. Mi intención es obtener un algoritmo de equilibrio satisfactorio que me permita pasar ejemplos de CAREX de modo que pueda implementar métodos de iteración de Newton sobre el solucionador habitual.