CÁLCULO EXATO DOS CUSTOS H2 E H∞ PARA SISTEMAS COM INCERTEZAS
POLITÓPICAS
Eduardo N. Goncalves∗, Reinaldo M. Palhares†, Ricardo H. C. Takahashi‡, Renato C.
Mesquita§
∗
Departamento de Engenharia Elétrica
Centro Federal de Educação Tecnológica de Minas Gerais
Av. Amazonas 7675, 31510-470, Belo Horizonte - MG - Brasil
†
Departamento de Engenharia Eletrônica
Universidade Federal de Minas Gerais
Av. Antônio Carlos 6627 - 31270-010, Belo Horizonte - MG - Brasil
‡
Departamento de Matemática
Universidade Federal de Minas Gerais
Av. Antônio Carlos 6627 - 31270-010, Belo Horizonte - MG - Brasil
§
Departamento de Engenharia Elétrica
Universidade Federal de Minas Gerais
Av. Antônio Carlos 6627 - 31270-010, Belo Horizonte - MG - Brasil
Emails: [email protected], [email protected], [email protected],
[email protected]
Abstract— This paper presents an approach for H2 and H∞ cost computation for systems with polytopic
uncertainties based on a branch-and-bound algorithm. The lower bound function is defined as the worst case
H2 or H∞ norm calculated in the polytope vertices. The upper bound function is defined as the guaranteed
cost computed with a Linear Matrix Inequality (LMI) characterization. The difference between the upper and
lower functions converges to zero as the initial polytope is split in smaller polytopes resulting in the exact H2 or
H∞ cost for the whole initial polytope. Its is also presented an algorithm to implement d−dimensional simplex
subdivision to be used in the branch-and-bound algorithm.
Keywords—
H2 and H∞ costs, polytopic model, branch-and-bound algorithm, simplex subdivision.
Resumo— Este artigo apresenta um método de cálculo dos custos H2 e H∞ para sistemas com incertezas
politópicas baseado em um algoritmo branch-and-bound. A função limite inferior é definida como o pior caso das
normas H2 e H∞ calculadas nos vértices do politopo. A função limite superior é definida como o custo garantido
calculado a partir de formulações baseadas em desigualdades lineares matriciais (LMI). A diferença entre as
funções limites inferior e superior converge para zero a medida que o politopo inicial é subdivido em politopos
menores resultando no custo exato H2 ou H∞ para todo politopo inicial. Também é apresentado um algoritmo
para implementar subdivisão de simplex d−dimensional que será usado no algoritmo branch-and-bound.
Keywords—
1
custos H2 e H∞ , modelo politópico, algoritmo branch-and-bound, subdivisão de simplex.
Introdução e Motivação
Existem vários métodos disponı́veis para o cálculo das normas H2 e H∞ no caso de sistemas
precisamente conhecidos. Entretanto, dado um
modelo de sistema com parâmetros incertos, não
existe atualmente nenhum método de determinar
o valor exato do melhor limitante para a norma
no conjunto incerto. Existem estratégias de cálculo dos custos garantidos H2 e H∞ baseados em
formulações por desigualdades matriciais lineares
(LMIs), mas os valores obtidos com estas estratégias são apenas um limite superior dos custos exatos. Este trabalho tem como objetivo apresentar
uma técnica de cálculo menos conservadora dos
custos H2 e H∞ que possa ser usada como ferramenta de análise de desempenho de sistemas
dinâmicos incertos representados por modelos de
incertezas politópicas:
ẋ(t)
z(t)
= A(t)x(t) + B(t)w(t)
= C(t)x(t) + D(t)w(t)
(1)
sendo que as matrizes A(t), B(t), C(t) e D(t) pertencem ao politopo:
A(t) B(t)
T (α) =
=
C(t) D(t)
)
N
(2)
X
Ai Bi
αi
,α ∈ Ω
Ci Di
i=1
n
o
PN
onde Ω , α : αi ≥ 0 ,
α
=
1
, N é
i=1 i
o número
de vértices do politopo e o vetor
′
α1 . . . αN
α =
parametriza o politopo.
A representação por incertezas politópicas
pode ser obtida de um sistema com diferentes
modelos para cada ponto de operação, de sistemas não-lineares, ou de modelos de incertezas
dependente de parâmetros.
No caso de sistemas dependentes de parâmetros com dependência afim de um vetor de parâmetros incertos p =
[p1 , p2 , . . . , pd ] ∈ Rd , com pi ∈ [pi , pi ], o modelo
de incertezas politópicas pode ser obtido dos 2d
extremos da faixa de variação dos parâmetros.
Este artigo propõe uma estratégia para o cálculo com a precisão desejada dos custos H2 e H∞
de sistemas incertos representados por modelo de
incertezas politópicas ou modelo afim dependente
de parâmetros baseada no algoritmo branch-andbound. O uso do algoritmo branch-and-bound
na área de controle robusto não é uma novidade,
tendo sido utilizado como uma possibilidade para
reduzir o conservadorismo na análise de estabilidade robusta de sistemas lineares com parâmetros
incertos reais invariantes no tempo (Balakrishnan
et al., 1991). Será apresentado de forma detalhada uma implementação do algoritmo branchand-bound onde a operação de subdivisão será
baseada na triangulação de Delaunay seguida de
uma subdivisão orientada pelas arestas.
2
(Φub (Pinit ) − Φlb (Pinit ))/Φlb (Pinit ) ≤ ε,
onde ε é uma precisão relativa pré-especificada,
então o algoritmo finaliza. Se o critério de parada
não é atingido, é necessário subdividir o hiperretângulo Pinit em hiper-retângulos menores de
forma que Pinit = P1 ∪ P2 ∪ . . . ∪ PS , e calcular
Φlb (Pi ) e Φub (Pi ), i = 1, . . . , S. Então
max Φlb (Pi ) ≤ Φmax (Pinit ) ≤ max Φub (Pi )
1≤i≤S
fornece novos limites para Φmax (Pinit ). Se a diferença relativa entre os novos limites é menor ou
igual a ε, o algoritmo finaliza. Caso contrário, a
partição de Pinit é novamente refinada e novos limites são calculados. O algoritmo BnB converge
uma vez que dim(Pi ), i = 1, . . . , S, tende para
zero e o hiper-retângulo tende para um ponto,
fazendo com que Φub (Pinit ) − Φlb (Pinit ) tenda
para zero.
A versão do algoritmo BnB utilizada, adaptada de Balakrishnan et al. (1991), é apresentada
a seguir:
Algoritmo
k ← 0;
L0 ← {Pinit };
L0 ← Φlb (Pinit );
U0 ← Φub (Pinit );
enquanto (Uk − Lk )/Lk > ε
selecione P ∈ Lk tal que Φub (P) = Uk ;
particione P em P1 , . . . , PS
Lk+1 ← {Lk − P} ∪ {P1 , . . . , PS };
Lk+1 ← maxP∈Lk+1 Φlb (P);
Uk+1 ← maxP∈Lk+1 Φub (P);
elimine todo P ∈ Lk+1 tal que
Φub (P) < Lk+1 ;
k ← k + 1;
f im enquanto
f im algoritmo
O Algoritmo Branch-and-Bound
O algoritmo branch-and-bound (BnB) pode ser
utilizado para encontrar o máximo global de uma
função f (p) : Rd → R cujo domı́nio é definido
como um hiper-retângulo d-dimensional
Pinit = [p1 , p1 ] × [p2 , p2 ] × . . . × [pd , pd ]
onde pi e pi , i = 1, . . . , d, são os valores extremos dos elementos do vetor de parâmetros
p = [p1 , p2 , . . . , pd ], i.e., pi ∈ [pi , pi ].
A seguinte descrição do algoritmo BnB é
adaptada de Balakrishnan et al. (1991). Para um
hiper-retângulo P ⊆ Pinit , pode-se definir
Φmax (P) , max f (p)
p∈P
(3)
O algoritmo BnB calcula Φmax (Pinit ) baseado
em duas funções, Φlb (P) e Φub (P), definidas sobre {P : P ⊆ Pinit }. Estas duas funções devem
satisfazer as seguintes condições:
Φlb (P) ≤ Φmax (P) ≤ Φub (P)
∀ ǫ > 0, ∃ δ > 0 tal que ∀ P ⊆ Pinit ,
dim(P) ≤ δ ⇒ Φub (P) − Φlb (P) ≤ ǫ
(4)
(5)
A condição (4) estabelece que as funções
Φlb (P) e Φub (P) calculam os limites inferior e superior de Φmax (P), respectivamente. A condição
(5) estabelece que, a medida que o máximo comprimento das arestas de P, denotado por dim(P),
tende a zero, a diferença entre os limites inferior
e superior converge para zero.
O algoritmo BnB inicia pelo cálculo de Φlb (Pinit ) e Φub (Pinit ).
Se
1≤i≤S
3
O Algoritmo BnB Aplicado ao Cálculo
Exato dos Custos H2 e H∞
Para aplicar o algoritmo BnB no cálculo exato
dos custos Hq , q = 2, ∞, é necessário encontrar as funções Φlb (P) e Φub (P) que satisfazem
as condições (4) e (5). A função limite inferior
pode ser definida como o pior caso da norma Hq
calculada nos vértices do politopo de matrizes em
(2):
Φlb (P) = max kTi kq ,
1≤i≤N
(6)
Ti = Ci (sI − Ai )−1 Bi + Di
A função limite superior Φub (P) pode ser
definida como sendo os custos Hq garantidos
(Palhares et al., 1997):
δc ≥ kHk2
∀(A, B, C, D) ∈ T (α), D = 0
γc ≥ kHk∞
∀(A, B, C, D) ∈ T (α)
(7)
(8)
sendo δc e γc calculados através dos seguintes
problemas de otimização baseados em LMIs:
 2
δc = min T race{J}


J,X 


X
∗


≻0
 suj. a:
Ci X J

−(Ai X + XA′i ) Bi


≻0


∗
I



for i = 1, . . . , N
(9)
 2
γ
=
min
µ

c

µ,X


′


suj.
a: X


 =X ≻0

−(Ai X + XA′i ) ∗
∗


Bi X
I
∗ ≻0




Ci
Di µI



for i = 1, . . . , N
(10)
onde o sı́mbolo * denota termos simétricos em relação à diagonal. Em Palhares et al. (1997) também são apresentados as formulações de custos
garantidos para o caso de sistemas discretos. Ao
invés de utilizar formulações baseadas no conceito
de estabilidade quadrática, pode-se optar por formulações baseadas em funções de Lyapunov dependente de parâmetros como, por exemplo, as
formulações apresentadas em de Oliveira et al.
(2004a) e de Oliveira et al. (2004b), o que não significa necessariamente em um menor custo computacional.
A partição de Pinit no algoritmo BnB pode
ser implementada por várias técnicas diferentes.
Neste trabalho será utilizado o método de triangulação de Delaunay. A triangulação de Delaunay
subdivide uma região 2-dimensional em triângulos (tetraedros no caso 3-dimensional ou simplexos
no caso d-dimensional). A vantagem da triangulação de Delaunay é que ela permite que o cálculo exato dos custos baseados no algoritmo BnB
possa ser aplicado em sistemas incertos representados tanto por modelo com dependência afim de
parâmetros, onde os vértices do politopo são os
vértices do hiper-retângulo, como por modelo de
incertezas politópicas, onde os vértices podem estar em pontos quaisquer do espaço de parâmetros.
Existe uma relação estreita entre a triangulação
de Delaunay de um conjunto de pontos S e a
casca convexa da “lifting transformation”(de Berg
et al., 1998) destes pontos em uma dimensão superior. Deste modo, algoritmos para cálculo da casca
convexa em espaços (d+1)-dimensional podem ser
usados para calcular a triangulação de Delaunay
no espaço d-dimensional. Isto é utilizado, por exemplo, pela função delaunayn do MATLABr que
é baseada no algoritmo Quickhull (Barber, 1996).
Após a triangulação inicial de Pinit , os refinamentos posteriores serão realizados por uma
técnica de subdivsão de simplex orientada pelas
arestas (“edgewise subdivision”) (Edelsbrunner
and Grayson, 2000). As subdivisões são obtidas
pela introdução de novos pontos sobre as arestas
do simplex P que atende à condição Φub (P) = Uk .
Estes novos pontos fornecem as condições para
subdividir P em 2d novos simplexos. A subdivisão 2d orientada pelas arestas de um triângulo
é mostrada na Fig. 1, onde Pij , (Pi + Pj )/2.
Existem várias vantagens em se aplicar a subdivisão orientada pelas arestas (Edelsbrunner and
Grayson, 2000) onde a mais importante aqui é
que os novos simplexos terão o mesmo volume ddimensional e forma similar ao simplex original.
Observe que, diferente de outras aplicações em Engenharia, tais como elementos finitos, não existe
a preocupação em se garantir a consistência do
particionamento pela não utilização de vértices de
um simplex sobre a aresta de outro. O algoritmo
proposto para implementar a subdivisão de um
simplex orientada pelas arestas será introduzido
na próxima seção.
P3
P13
P1
P23
P12
P2
Figura 1: Particionamento de um triângulo por
meio de uma subdivisão orientada pelas arestas.
Pode ser interessante normalizar o hiperretângulo Pinit transformando-o em um hipercubo [0, 1]d . O vetor de parâmetros p ∈ Pinit , com
pi ∈ [pi , pi ], pode ser normalizado para o novo
vetor de parâmetros ρ = [ρ1 , . . . , ρd ], ρi ∈ [0, 1],
através das relações:
ρi =
4
pi − pi
p i − pi
⇐⇒ pi = pi + ρi (pi − pi )
(11)
Subdivisão de Simplex Orientada pelas
Arestas
O algoritmo proposto nesta seção implementa
uma subdivisão orientada pelas arestas de um simplex d-dimensional em k d simplexos, sendo inspirado em um esquema de cores (“color scheme”)
(Edelsbrunner and Grayson, 2000). A mesma
notação utilizada por Edelsbrunner and Grayson
(2000) será adotada aqui. Considere um d-simplex
σ definido como uma seqüência de d + 1 pontos,
P0 , P1 , . . . , Pd , que são afim-independentes em Rd .
Considere a notação
Pχ1 χ2 ...χk = (Pχ1 + Pχ2 + . . . + Pχk )/k
(12)
A subdivisão orientada pelas arestas de σ
em k d simplexos será obtida a partir dos pontos P0 , P1 , . . . , Pd e de novos pontos Pχ1 χ2 ...χk
como definidos em (12). Os pontos que definem
cada novo simplex serão obtidos a partir de uma
matriz χ ∈ Nk×(d+1) , denominada esquema de
cores, cujos elementos são números inteiros na
faixa [0,d], denominados cores, que representam
os ı́ndices dos pontos P0 , P1 , . . . , Pd (Edelsbrunner
and Grayson, 2000). A i-ésima coluna de χ
definirá os pontos Pχ0,i χ1,i ...χk−1,i do novo simplex.
Para se adequar ao algoritmo que será proposto,
os ı́ndices das linhas de χ iniciam com 0 ao invés
de 1 como definido por Edelsbrunner and Grayson
(2000). As principais caracterı́sticas do esquema
de cores são que os elementos aparecem em ordem
não decrescente quando lidos como texto:
χ0,0 ≤ χ1,2 ≤ . . . ≤ χ1,d ≤ χ2,0 ≤ . . . ≤ χk−1,d
e as colunas são organizadas de tal forma que, da
coluna i − 1 para a próxima coluna i, apenas uma
das cores muda por um incremento unitário. O
problema tratado aqui é como obter os k d esquemas de cores para gerar a subdivisão completa do
simplex. O algoritmo proposto a seguir irá realizar
a tarefa de gerar automaticamente os esquemas de
cores, tornando viável o uso do método descrito.
No algoritmo proposto, o n-ésimo esquema de
cores, χn , n = 0, 1, . . . , k d − 1, será criado linha
por linha iniciando com χn0,0 = 0. Para saber se
o próximo elemento da matriz será mantido ou
incrementado em um, é necessário representar o
ı́ndice n do simplex χn no sistema numérico com
base k:
n = xd−1 ×k
d−1
+xd−2 ×k
d−2
Considere, por exemplo, a subdivisão de um
tetraedro em k d = 23 sub-tetraedros. O esquema
de cores é formatado como
χ0,0 χ0,1 χ0,2 χ0,3
χ=
χ1,0 χ1,1 χ1,2 χ1,3
Para calcular o sub-tetraedro com n = 6, χ6 ,
a mudança das cores será especificada escrevendo
6 na base 2, ou seja, x = 1102 , o que significa que
as mudanças de cores nas colunas 1 e 2 ocorrerão
na linha 1, enquanto que na coluna 3 a mudança
ocorrerá na linha 0:
0 0 0 1
χ=
1 2 3 3
Este esquema de cores mostra que o subtetraedro é definido pelo conjunto de pontos
{P01 , P02 , P03 , P13 } como mostrado na Fig. 2,
onde o ponto Pχ0,i χ1,i é calculado por (12).
P3
P23
P03
P13
P2
P02
P0
P12
P01
P1
0
+. . .+x0 ×k (13)
Os valores dos dı́gitos xd−i , i = 1, 2, . . . , d,
determinarão qual linha da coluna i − 1 será incrementada em um para gerar a coluna i. Ao terminar uma linha, a próxima linha inicia com a última cor da linha anterior, ou seja, χni,0 = χni−1,d .
O procedimento descrito é implementado pelo
seguinte algoritmo:
Algoritmo
para n = 0, 1, . . . , k d − 1
xd−1 . . . x0 ← converta n para base k;
cor ← 0;
para i = 0, 1, . . . , k − 1
χni,0 ← cor;
para j = 1, . . . , d
se xd−j = i então
cor ← cor + 1;
f im se
χni,j ← cor;
f im para
f im para
f im para
f im algoritmo
Figura 2: Exemplo de sub-tetraedro gerado pela
partição de um tetraedro em 23 partes.
5
Exemplo Ilustrativo
Considere o seguinte sistema dinâmico linear e incerto modelado por:


−0, 1 −a
0
0
0
0
 1
0
0
0
0
0 


 0
a −0, 1 −b
0
0 

A=
 0
0
1
0
0
0 


 0
0
0
b −0, 1 −1 
0
0
0
0
1
0
B=
C=
0
1
′
0 0 0
0 1 ; D= 0
0 0
0 0 0
Os parâmetros incertos a e b podem variar
dentro do politopo cujos vértices são listados na
Tabela 1.
Este exemplo foi escolhido para verificar o
comportamento do algoritmo proposto para um
politopo não retangular e cujo máximo global do
funções limites
custo não se encontra em um dos vértices. A
segunda caracterı́stica pode ser verificada pela
Fig. 3, que mostra a superfı́cie gerada pelos valores de kT2 k2 para a e b variando entre os seus
limites extremos.
Para este sistema, não é possı́vel calcular o
custo garantido H2 por meio da formulação (9)
porque o mesmo não é factı́vel para Pinit . No
entanto, mesmo neste caso onde não é possı́vel
calcular o custo garantido inicial, com a partição
de Pinit , o problema de otimização baseado em
LMIs torna-se factı́vel e o algoritmo proposto converge para o custo exato. Esta potencialidade da
metodologia adotada será ilustrada a seguir.
Adotando o critério de parada ε = 0, 01,
o problema de otimização (9), para o cálculo
do custo garantido H2 , tornou-se factı́vel após
31 iterações e o algoritmo proposto convergiu
com 1455 iterações, após 21,98min, com implementação no MATLABr (notebook com processador de 2.2GHz e 256MB de memória), atingindo
Φlb (P) = 139, 2572 e Φub (P) = 140, 6494. A
Fig. 4 mostra a evolução das funções limites inferior e superior para as primeiras 400 iterações
para o cálculo exato do custo H2 . A Fig. 5 mostra
como o espaço de parâmetros foi subdividido após
400 iterações. A Fig. 6 mostra a partição final do
espaço de parâmetros com a eliminação dos subpolitopos onde Φub (P) < Lk .
1500
1000
500
0
0
50
100
150
200
250
número de iterações
300
350
400
Figura 4: Evolução de Φlb (P) e Φub (P) nas
primeiras 400 iterações no cálculo do custo H2 .
1
0.9
0.8
0.7
0.6
ρ2 (b)
Tabela 1: Valores de a e b nos vértices do politopo
do modelo do exemplo.
Vért.
1
2
3
4
5
6
a
0,75 1,3 1,5 1,5
1
0,75
b
0,75 0,75
1
1,3 1,5 1,5
0.5
0.4
0.3
0.2
0.1
0
0
0.1
0.2
0.3
0.4
0.5
ρ1 (a)
0.6
0.7
0.8
0.9
1
Figura 5: Partição de Pinit após 400 iterações no
caso do cálculo do custo H2 .
kT2 k2
140
120
1
100
0.9
80
60
0.8
40
0.7
20
0.6
ρ2 (b)
1.50
0.5
1.25
a
0.4
1.00
1.50
1.25
1.00
0.75
0.75
b
Figura 3: kT2 k2 para a e b variando entre seus
valores extremos.
Adotando o critério de parada ε = 0, 01,
o problema de otimização (10), para o cálculo
do custo garantido H∞ , tornou-se factı́vel após
31 iterações e o algoritmo proposto convergiu
com 1067 iterações, após 28,12min, atingindo
0.3
0.2
0.1
0
0
0.1
0.2
0.3
0.4
0.5
ρ1 (a)
0.6
0.7
0.8
0.9
1
Figura 6: Partição final de Pinit no caso do cálculo do custo H2 mostrando a eliminação dos subpolitopos.
Φlb (P) = 1011, 2177 e Φub (P) = 1021, 3276. A
Fig. 7 mostra a evolução das funções limites inferior e superior no cálculo exato do custo H∞ .
A Fig. 8 mostra como o espaço de parâmetros foi
subdividido após 31 iterações quando o problema
de otimização (10) tornou-se factı́vel.
5000
4500
4000
funções limites
3500
3000
2500
2000
que o mesmo é aplicável em situações onde as formulações por LMIs não são factı́veis e quando o
são, podem produzir resultados demasiadamente
conservadores. Além disso, este trabalho apresenta um algoritmo eficiente e simples para subdivisão de um d−simplex em k d simplexos que pode
ser aplicado em conjunto com a triangulação de
Delaunay para implementar a operação de partição no algoritmo branch-and-bound que é freqüentemente utilizado na área de controle robusto.
O algoritmo proposto para o cálculo exato dos custos H2 e H∞ também pode ser aplicado para sistemas discretos bastando substituir as funções que
calculam as normas e os custos garantidos H2 e
H∞ pelas suas equivalentes.
1500
7
1000
Agradecimentos
500
0
1
100
200
300
400
500
600
700
número de iterações
800
900
1000 1067
Figura 7: Evolução de Φlb (P) e Φub (P) no cálculo
do custo H∞ .
Os autores agradecem o apoio das agências
CAPES, CNPq e FAPEMIG e as contribuições dos
revisores.
Referências
Balakrishnan, V., Boyd, S. and Balemi, S. (1991).
Computing the minimum stability degree of
parameter-dependent linear systems, in S. P.
Bhattacharyya and L. H. Keel (eds), Control
of Uncertain Dynamic Systems, CRC Press
Inc, pp. 359–378.
1
0.9
0.8
0.7
ρ2 (b)
0.6
Barber, C. B. (1996). The quickhull algorithm for
convex hulls, ACM Transactions on Mathematical Software 22(4): 469–483.
0.5
0.4
0.3
0.2
0.1
0
0
0.1
0.2
0.3
0.4
0.5
ρ1 (a)
0.6
0.7
0.8
0.9
1
Figura 8: Partição de Pinit após 31 iterações no
caso do cálculo do custo H∞ .
6
Conclusões
A metodologia proposta para o cálculo com a precisão desejada dos custos H2 e H∞ de sistemas
com incertezas politópicas baseado no algoritmo
branch-and-bound pode ser utilizada para analisar
o desempenho de projeto de controladores robustos. Para sistemas com pequeno número de parâmetros incertos e com pequena faixa de variação
dos mesmos, o algoritmo converge rapidamente
para o valor exato do custo sendo calculado. Para
um número grande de parâmetros incertos e/ou
grande sensibilidade do modelo à variação dos parâmetros, torna-se necessário considerar o custo
computacional envolvido. Mesmo considerando os
casos em que a convergência é mais lenta, o algoritmo proposto deve ser considerado uma vez
de Berg, M., Kreveld, M. V., Overmas, M.
and Schwarzkopt, O. (1998).
Computational Geometry: Algorithms and Applications, Springer Verlag.
de Oliveira, P. J., Oliveira, R. C. L. F., Leite, V.
J. S., Montagner, V. F. and Peres, P. L. D.
(2004a). H2 guaranteed cost computation
by means of parameter-dependent Lyapunov
functions, International Journal of Systems
Science 35(5).
de Oliveira, P. J., Oliveira, R. C. L. F., Leite, V.
J. S., Montagner, V. F. and Peres, P. L. D.
(2004b). H∞ guaranteed cost computation
by means of parameter-dependent Lyapunov
functions, Automatica 40: 305–315.
Edelsbrunner, H. and Grayson, D. R. (2000).
Edgewise subdivision of a simplex, Discrete
& Computational Geometry 24: 707–719.
Palhares, R. M., Takahashi, R. H. C. and Peres,
P. L. D. (1997). H∞ and H2 guaranteed
costs computation for uncertain linear systems, International Journal of Systems Science 28(2): 183–188.