Borrador Georgina

Algoritmos Secuenciales y Paralelos para la
Resolución del Problema Inverso de Valores

Singulares
Trabajo de Tesis Doctoral

Presentado por Georgina Flores Becerra
Dirigido por Dr. Antonio M. Vidal Maciá
Valencia, España
Noviembre 2005
Índice general
1. Introducción 6
1.1. Definición del Problema Inverso de
Valores Singulares . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.1. Los Problemas Inversos de Valores Propios . . . . . . . . 8
1.1.2. Los Problemas Inversos de Valores Singulares . . . . . . . 10
1.2. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3. Estado del Arte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4. Planteamiento del Problema . . . . . . . . . . . . . . . . . . . . . 13
1.5. Resolución y Casos de Prueba . . . . . . . . . . . . . . . . . . . . 15
1.6. Herramientas Hardware y Software de Entornos Paralelos . . . . 17
1.7. Evaluación de Algoritmos Paralelos . . . . . . . . . . . . . . . . . 21
1.8. Estructura del trabajo . . . . . . . . . . . . . . . . . . . . . . . . 23
2. Métodos y Algoritmos Secuenciales para la Resolución del PI-

AVS 24
2.1. Método Fuerza Bruta (FB) . . . . . . . . . . . . . . . . . . . . . 26
2.1.1. Algoritmo Fuerza Bruta . . . . . . . . . . . . . . . . . . . 28
2.1.2. Probando Fuerza Bruta . . . . . . . . . . . . . . . . . . . 29
2.2. Método I (MI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.2.1. Automatización del Método I . . . . . . . . . . . . . . . . 35
2.2.2. Pruebas Numéricas del Método I . . . . . . . . . . . . . . 36
2.3. Método Elevación-Proyección (EP) . . . . . . . . . . . . . . . . . 40
2.3.1. Algoritmo secuencial Elevación-Proyección . . . . . . . . . 43
2.3.2. Pruebas Numéricas de Elevación-Proyección . . . . . . . . 44
2.4. Método III (MIII) . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.4.1. Algoritmo Secuencial del Método III . . . . . . . . . . . . 53
2.4.2. Pruebas Numéricas del Método III . . . . . . . . . . . . . 54
3. Implementación, Análisis y Evaluación de los Algoritmos del

PIAVS 59
3.1. Detalle de Operaciones de Algoritmos del PIAVS . . . . . . . . . 60
3.2. Algoritmos del PIAVS y Tiempos de Ejecución Teóricos . . . . . 68
1
3.3. Análisis y Evaluación de los Algoritmos Secuenciales del PIAVS . 72
3.3.1. Requerimientos de Memoria . . . . . . . . . . . . . . . . . 72
3.3.2. Convergencia . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.3.3. Exactitud de la solución . . . . . . . . . . . . . . . . . . . 73
3.3.4. Estimación de la complejidad de tiempo y tiempos de eje-
cución . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.3.5. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . 75
4. Algoritmos Paralelos para la Resolución del PIAVS 77

4.1. Paralelización de Operaciones de Algoritmos del PIAVS . . . . . 78
4.1.1. Paralelización de rutinas necesarias para FB . . . . . . . . 79
4.1.2. Paralelización de rutinas necesarias para MI . . . . . . . . 81
4.1.3. Paralelización de rutinas necesarias para EP . . . . . . . . 82
4.1.4. Paralelización de rutinas necesarias para MIII . . . . . . . 83
4.2. Algoritmos Paralelos para el PIAVS y Tiempos de Ejecución
Teóricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
4.3. Prestaciones Experimentales de los Algoritmos Paralelos del PIAVS 98
4.4. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5. Resolución Paralela del PIEVS 109

5.1. Resoluciones Generales del PIEVS . . . . . . . . . . . . . . . . . 110
5.2. Propuestas de Resoluciones Especı́ficas del PIEVS . . . . . . . . 115
5.3. Paralelización de Resoluciones Especı́ficas del PIEVS . . . . . . . 123
5.4. Prestaciones de Resoluciones Paralelas del PIEVS . . . . . . . . . 132
5.5. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6. Algoritmos para la Resolución del PIVSVP 139

6.1. Método MTriIU . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
6.1.1. Algoritmo Secuencial del Método MTriIU . . . . . . . . . 143
6.1.2. Paralelización del Algoritmo MTriIU . . . . . . . . . . . . 145
6.1.3. Análisis de Prestaciones e Implementaciones del Algorit-
mo Paralelo MTriIU . . . . . . . . . . . . . . . . . . . . . 149
6.2. Método MBidiag . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
6.2.1. Algoritmo MBidiag y Experimentos Numéricos . . . . . . 158
6.3. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
7. Conclusiones y Perspectivas 165
2
Índice de tablas
2.1. Puntos iniciales del caso ChuBai . . . . . . . . . . . . . . . . . . 25

2.2. Resultados esperados del caso ChuBai . . . . . . . . . . . . . . . 25
2.3. Dimensiones de F y J del algoritmo FB . . . . . . . . . . . . . . 29
2.4. Requerimiento de memoria del algoritmo FB . . . . . . . . . . . 29
2.5. Resultados y convergencia del caso ChuBai con FB . . . . . . . . 30
2.6. Errores del caso ChuBai con FB . . . . . . . . . . . . . . . . . . 31
2.7. Resultados del caso Gral con FB . . . . . . . . . . . . . . . . . . 32
2.8. Requerimiento de memoria de algoritmo MI . . . . . . . . . . . . 36
2.9. Resultados del caso ChuBai con MI . . . . . . . . . . . . . . . . . 37
2.10. Errores del caso ChuBai con MI . . . . . . . . . . . . . . . . . . . 37
2.11. Resultados y convergencia del caso Gral con MI . . . . . . . . . . 39
2.12. Requerimiento de memoria de EP . . . . . . . . . . . . . . . . . . 44
2.13. Resultados del caso ChuBai con EP . . . . . . . . . . . . . . . . 45
2.14. Errores del caso ChuBai con EP . . . . . . . . . . . . . . . . . . 45
2.15. Resultados del caso Gral con EP . . . . . . . . . . . . . . . . . . 47
2.16. Convergencia de EP para el caso Gral . . . . . . . . . . . . . . . 48
2.17. Requerimiento de memoria de MIII . . . . . . . . . . . . . . . . . 54
2.18. Resultados del caso ChuBai con MIII . . . . . . . . . . . . . . . . 55
2.19. Errores de ChuBai con MIII . . . . . . . . . . . . . . . . . . . . . 55
2.20. Resultados del caso Gral con MIII . . . . . . . . . . . . . . . . . 57
2.21. Convergencia de MIII para el caso Gral . . . . . . . . . . . . . . 58
4.1. Tiempos de Ejecución Teóricos de FB en Kefren . . . . . . . . . 97

4.2. Tiempos de Ejecución Teóricos de MI en Kefren . . . . . . . . . . 97
4.3. Tiempos de Ejecución Teóricos de EP en Kefren . . . . . . . . . 97
4.4. Tiempos de Ejecución Teóricos de MIII en Kefren . . . . . . . . . 98
4.5. Tiempos de Ejecución Experimentales de FB . . . . . . . . . . . 99
4.6. Tiempos de Ejecución Experimentales de MI . . . . . . . . . . . 99
4.7. Tiempos de Ejecución Experimentales de EP . . . . . . . . . . . 100
4.8. Tiempos de Ejecución Experimentales de MIII . . . . . . . . . . 100
4.9. Eficiencia Experimental de FB . . . . . . . . . . . . . . . . . . . 103
4.10. Eficiencia Experimental de MI . . . . . . . . . . . . . . . . . . . 104
3
4.11. Eficiencia Experimental de EP . . . . . . . . . . . . . . . . . . . 104
4.12. Eficiencia Experimental de MIII . . . . . . . . . . . . . . . . . . 104
5.1. Tiempos de ejecución experimentales de MI y EP para el PIEVS 114

5.2. Tiempos de ejecución experimentales de MIE y EPE para el PIEVS121
5.3. Tiempos de ejecución experimentales de dos implementaciones
paralelas de la svd . . . . . . . . . . . . . . . . . . . . . . . . . . 127
5.4. Tiempos de ejecución y Speedup experimentales de MIE paralelo 134
5.5. Tiempos de ejecución y Speedup experimentales de EPE paralelo 135
5.6. Eficiencia Experimental de MIE . . . . . . . . . . . . . . . . . . . 136
5.7. Eficiencia Experimental de EPE . . . . . . . . . . . . . . . . . . 136
6.1. Resultados del caso Triu con MTriIU . . . . . . . . . . . . . . . . 145

6.2. Tiempos de Ejecución Experimentales de MTriIU en Kefren, con-
struyendo A en P roc0 . . . . . . . . . . . . . . . . . . . . . . . . 150
6.3. Tiempos de Ejecución Experimentales de MTriIU en Kefren, SIN
construı́r A en P roc0 . . . . . . . . . . . . . . . . . . . . . . . . . 151
6.4. Speedup experimental de MTriIU en Kefren, sin construir A en
P roc0 , multiplicando el número de procesadores por 2 y por 4 . . 151
6.5. Tiempos de Ejecución Experimentales de MTriIU en Aldebarán,
bajo el modelo de Memoria Compartida . . . . . . . . . . . . . . 154
6.6. Eficiencia Experimental de MTriIU en Aldebarán. Modelo de
Memoria Compartida . . . . . . . . . . . . . . . . . . . . . . . . 155
6.7. Resultados del caso Bidiag con MBidiag, para n = {4, 10, 25, 50, 100},
(0)
con ci = c∗i + δ (i = 1, n) . . . . . . . . . . . . . . . . . . . . . 160
6.8. Resultados del caso Bidiag con MBidiag, para n = {150, 200, 400, 500, 1000},
(0)
con ci = c∗i + δ (i = 1, n) . . . . . . . . . . . . . . . . . . . . . 161
6.9. Métodos de Chu v.s. Li-Mathias v.s. MBidiag . . . . . . . . . . 162
4
Índice de figuras
4.1. Tiempos de ejecución teóricos vs. experimentales de FB . . . . . 101

4.2. Tiempos de ejecución teóricos vs. experimentales de MI . . . . . 101
4.3. Tiempos de ejecución teóricos vs. experimentales de EP . . . . . 101
4.4. Tiempos de ejecución teóricos vs. experimentales de MIII . . . . 102
4.5. Speedup experimental de FB y MI para m = {1000, 2000, 3000} . 102
4.6. Speedup experimental de EP y MIII para m = {1000, 2000, 3000} 103
4.7. SpeedUp Escalado de los algoritmos paralelos del PIAVS . . . . . 105
5.1. Tiempos de ejecución experimentales con algoritmos PIAVS vs

PIEVS sobre los mismos casis de prueba . . . . . . . . . . . . . . 122
5.2. Speedup experimentales de MIE y EPE en el cluster Kefren . . . 136
5.3. Speedup Escalado de los algoritmos paralelos del PIEVS . . . . . 137
6.1. Speedup experimental de MTriIU en Kefren, SIN construir A en

P roc0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
6.2. Speedup experimentales de MTriIU en Aldebarán. Modelo de
Memoria Compartida . . . . . . . . . . . . . . . . . . . . . . . . 154
6.3. Speedup Escalado de MTriIU en Aldebarán. Memoria Compartida155
5
Capı́tulo 1
Introducción
El propósito de coleccionar datos es obtener información significativa acerca

de un sistema o fenómeno fı́sico. Si dada cierta información sobre los valores
de un conjunto de parámetros, tratamos de utilizar relaciones teóricas para
obtener información sobre los valores de algunas cantidades que pueden medirse,
se estará resolviendo, por definición, un problema directo. En cambio, si dada
cierta información sobre los valores de algunas cantidades medidas, se utilizan
relaciones teóricas para obtener información de los valores del conjunto de pa-
rámetros, entonces se estará resolviendo un problema inverso [TV82].
En un problema directo los valores de los parámetros son los datos y los
valores de algunas cantidades observables son las incógnitas. Mientras que en un
problema inverso los datos son el resultado de algunas medidas y las incógnitas
son los valores de los parámetros. En otras palabras, se puede decir que un
problema inverso es aquel en el que se mide un efecto y se quiere determinar la
causa [TF03].
Los problemas directos pueden describirse como sigue [Gro99]
Entrada → P roceso → Salida
o bien como
Causa → M odelo → Ef ecto
Si x simboliza la entrada y K el proceso, entonces el problema directo es encon-

trar Kx:
Entrada P roceso Salida
x → K → ?
Causa M odelo Ef ecto
6
Bajo este esquema, cada problema directo sugiere dos problemas inversos in-
mediatos: uno denominado problema de causalidad y otro denominado problema
de identificación de modelo.
En el problema de causalidad, dado un modelo K y un efecto y, hay que
encontrar la causa del efecto:
? → K → y
mientras que en el problema de identificación del modelo, dada información de

causas-efectos, hay que identificar el modelo [Gro99]:
x → ? → y
Los problemas directos se caracterizan por tener solución única y estable,

no ası́ los problemas inversos cuya solución puede no existir, puede ser única o
pueden ser múltiples.
De acuerdo a [Gro99] los diferentes tipos de problemas inversos y sus apli-
caciones son:
Problemas Inversos en Cálculo. El cálculo es particularmente

una fuente rica en problemas inversos. No es de sorprender si pen-
samos en la relación inversa que existe entre la diferenciación y la
integración. Problemas como cálculo de trayectorias, determinación
de la deformación y distribución de masas, distribución y balanceo de
fuerzas, la mecánica orbital y la mecánica celeste son buenos repre-
sentantes de los Problemas Inversos en Cálculo. Para su resolución
se emplean métodos de aproximación basados en la discretización de
derivadas e integrales, además de herramientas como la geometrı́a
analı́tica.
Problemas Inversos en Ecuaciones Diferenciales. Muchos de

los problemas en ciencia y tecnologı́a están vinculados con ecuaciones
diferenciales. Ejemplares de este tipo de problemas son los relaciona-
dos con: hidráulica, teorı́a de irrigación, conducción de calor y sis-
temas dinámicos. Para atacar este tipo de problemas se emplean he-
rramientas matemáticas como métodos de resolución de ecuaciones
7
diferenciales, transformada de Laplace, métodos de diferencias fini-
tas y elementos finitos.
Problemas Inversos en Algebra Lineal. El problema básico

del álgebra lineal, la resolución de un sistema de ecuaciones linea-
les, es un problema inverso. Además de los problemas básicos, se
cuentan los relacionados con: tomografı́a, gravimetrı́a, estereografı́a,
geofı́sica, astronomı́a. Los tópicos matemáticos empleados incluyen
proyecciones en hiperplanos, integración múltiple, transformada de
Laplace, matrices inversas, resolución de mı́nimos cuadrados y análi-
sis de valores y vectores propios.
De acuerdo a qué elementos se identifican como incógnitas de un problema

inverso, éstos se clasifican en dos grandes bloques [Gra98]:
Problemas inversos para estimar parámetros. Tratan de la

determinación de los valores de los parámetros de un modelo que
permitan el mejor ajuste entre los resultados del modelo y los datos
medidos [Giu02].
Problemas inversos para estimar funciones. Involucran la de-

terminación de una función desconocida.
Dentro de los problemas inversos para la estimación de parámetros, se en-

cuentran clasificados, entre otros: los Problemas Inversos de Valores Propios
(PIVP) y los Problemas Inversos de Valores Singulares (PIVS).
1.1. Definición del Problema Inverso de

Valores Singulares
Antes de definir el Problema Inverso de Valores Singulares, se define el Pro-
blema Inverso de Valores Propios, como importante y principal antecedente.
1.1.1. Los Problemas Inversos de Valores Propios

Este tipo de problemas tiene como propósito la construcción de una matriz
con una determinada estructura que posea cierto espectro predefinido. Se definen
como sigue [Chu98]:
Dada una familia de matrices A(c) ∈ Ψ, con c = [c1 , c2 , · · · , cl ]t ∈ F l

y escalares {λ∗1 , λ∗2 , · · · , λ∗n } ⊂ F , encontrar un parámetro c tal que
σ(A(c)) = {λ∗1 , λ∗2 , · · · , λ∗n } donde:
8
F representa el campo escalar de los reales < o de los com-
plejos C
σ(A) denota el espectro de la matriz A
Ψ denota cierto conjunto de matrices cuadradas, que entre
otras, pueden ser:
S(n) el conjunto de todas las matrices simétricas
en <n×n
O(n) el conjunto de todas las matrices ortogo-
nales en <n×n
DR (n) el conjunto de todas las matrices diagonales
en <n×n
H(n) el conjunto de todas las matrices Hermi-
tianas en C n×n
DC (n) el conjunto de todas las matrices diagonales
en C n×n
En [Chu98] se puede encontrar una clasificación de estos problemas inversos,

entre ellos se especifican:
MVIEP. Problema Inverso Multivariable de Valores Propios

LSIEP. Problema Inverso de Mı́nimos Cuadrados de Valores Propios
PIEP. Problema Inverso Parametrizado de Valores Propios
SIEP. Problema Inverso Estructurado de Valores Propios
PDIEP. Problema Inverso Parametrizado de Valores Propios
AIEP. Problema Inverso Aditivo de Valores Propios
MIEP. Problema Inverso Multiplicativo de Valores Propios
de los cuales son de particular interés en este trabajo el LSIEP o caso simétrico
aditivo [VA01] [VA02] y el MIEP o caso simétrico multiplicativo [FVA02], que
se definen como:
LSIEP. Caso Aditivo Simétrico.
Dado un conjunto de escalares λ∗1 , λ∗2 , ..., λ∗m ⊂ < encon-

trar una matriz
( l
)
X
X ∈ A(c) = A0 + ci Ai |Ai ∈ S(n), i = 0, l
i=1
y un conjunto τ = {τ1 , τ2 , ..., τm }de ı́ndices, con 1 ≤ τ1 <

τ2 < · · · < τm ≤ n, tales que la función
m
1X 2
F (X, τ ) = (λτi (X) − λ∗i )
2 i=1
donde λi (X), i = 1, n, son valores propios de la matriz X,

sea minimizada.
9
MIEP. Caso Multiplicativo Simétrico.
Dada una matriz simétrica y definida positiva A ∈ <n×n y

escalares reales λ∗1 ≤ λ∗2 ≤ · · · ≤ λ∗n , encontrar c ∈ <n tal
que los valores propios reales λ1 (c) ≤ λ2 (c) ≤ · · · ≤ λn (c)
de la matriz DA, con D = diag(d1 , d2 , · · · , dn ), satisfagan
λi (d) = λ∗i , para i = 1, n
1.1.2. Los Problemas Inversos de Valores Singulares

Al igual que los problemas inversos de valores propios, los de valores sin-
gulares consisten en construir una matriz que mantenga ciertas caracterı́sticas
especı́ficas de estructura, ası́ como un subconjunto de valores singulares dados.
Una definición general de este tipo de problemas es:
Dada una familia de matrices A(c) ∈ <m×n (m ≥ n), con c =

[c1 , c2 , ..., cl ]t ∈ <l y escalares {S1∗ , S2∗ , · · · , Sn∗ } ⊂ <, encontrar un
parámetro c tal que los valores singulares de (A(c)) sean S1∗ , S2∗ , ..., Sn∗ .
Esta definición también puede particulalizarse para los casos aditivo y mul-
tiplicativo como sigue:
Definición del Problema Inverso de Valores Singulares: Caso Aditi-

vo [Chu92a].
Dado un conjunto de matrices A0 , A1 , ..., Al ∈ <m×n (m ≥

n) y un conjunto de números reales Σ∗ = {S1∗ , S2∗ , ..., Sn∗ },
con S1∗ > S2∗ > · · · > Sn∗ , encontrar el conjunto de números
reales c = {c1 , c2 , ..., cl }, tal que los valores singulares de
A(c) = A0 + c1 A1 + · · · + cl Al sean los elementos de Σ∗ .
Definición del Problema Inverso de Valores Singulares: Caso Multi-

plicativo.
Dada una matriz A ∈ <m×n (m ≥ n), y un conjunto de

números reales Σ∗ = {S1∗ , S2∗ , ..., Sn∗ }, con S1∗ > S2∗ > · · · >
Sn∗ , encontrar una matriz M tal que los valores singulares
de M A sean los elementos de Σ∗ .
Este problema se considera resuelto en el caso en que A
es cuadrada e invertible si se toma
−1 t
M = diag(S1∗ , S2∗ , ..., Sn∗ )QA SA PA ,
donde A = PA SA QtA es la descomposición en valores sin-

gulares de A.
10
1.2. Objetivos
En este trabajo se tiene por objetivo general diseñar, implementar y evaluar
algoritmos secuenciales y paralelos para resolver eficientemente el Problema In-
verso de Valores Singulares. Para alcanzar este objetivo, se definen los siguientes
objetivos particulares:
F Diseñar algoritmos secuenciales que implementen los métodos

que resuelven el PIVS reportados en la literatura.
F De los métodos que resuelven el PIVP, seleccionar aquellos
adaptables a la resolución del PIVS, diseñando los correspon-
dientes algoritmos secuenciales.
F Analizar y evaluar los diversos algoritmos que resuelven el PIVS,
de acuerdo a diversos parámetros como: tiempos de ejecución,
requerimientos de almacenamiento, convergencia y exactitud,
con el fin de determinar el o los algoritmos que reunan las ca-
racterı́sticas deseables de eficiencia, robustez y exactitud.
F Paralelizar los algoritmos secuenciales coleccionados para re-
solver casos del PIVS de tamaños equiparables a los requeridos
en aplicaciones de la ciencia y la ingenierı́a.
F Analizar y evaluar las prestaciones y escalabilidad de los algo-
ritmos paralelos implementados para seleccionar el o los algo-
ritmos con mejores caracterı́sticas para la resolución del PIVS.
F Optimizar los algoritmos secuenciales y paralelos para resolver
particularizaciones del PIVS, a través de la explotación de ca-
racterı́sticas estructurales de las matrices.
F Estudiar y analizar métodos para la resolución simultánea del
PIVS y del PIVP.
1.3. Estado del Arte

Gran parte de los resultados existentes hasta ahora para la resolución del
PIVS se deben a Moody T. Chu. En 1992 propone e implementa un par de méto-
dos numéricos, uno discreto y otro continuo, para la resolución de PIVS [Chu92a].
En el método continuo Chu trata al PIVS como un problema de optimización
para minimizar distancias y plantea que puede derivarse una ecuación diferen-
cial ordinaria para caracterizar un paso de flujo descendente para la función de
distancia. El método discreto se basa en el denominado Method III que Friedland
et. al. [FNO87] proponen para el PIVP y que Chu adapta para la resolución del
PIVS.
11
En 1996 Chu y Chen formulan dos tipos de problemas de mı́nimos cuadra-
dos equivalentes entre sı́ y proponen una resolución para el PIVP llamada
Lift&Project [CC96], que se basa en el Método de Proyección Alternativa.
Nuevamente Chu, en 1999, introduce un método para la construcción de
matrices con valores singulares y elementos de la diagonal prescritos [Chu99].
Considera que el teorema de Schur-Horn caracteriza la relación entre entradas
diagonales y valores propios de matrices Hermitianas; de la misma forma el
teorema de Sing-Thompson caracteriza la relación entre entradas diagonales y
valores singulares de matrices arbitrarias. Basado en el principio de inducción
construye numéricamente esta matriz con un algoritmo recursivo, siempre que
los valores singulares dados y elementos diagonales satisfagan las condiciones
Sing-Thompson.
Posteriormente, en 2000, Chu propone un algoritmo recursivo que no sólo
considera la construcción de matrices con valores singulares prescritos, sino tam-
bién con valores propios prescritos [Chu00]. Para ello utiliza el teorema Weyl-
Horn que caracteriza la relación entre valores propios y valores singulares de
una matriz arbitraria. Basado en esta caracterización desarrolla un algoritmo
recursivo para construir numéricamente una matriz con los valores propios y
singulares deseados.
En el mismo tenor, se puede encontrar un método planteado por Kosowski
y Smoktunowicz [KA00] en 2000, para construir una matriz triangular inferior
unidad con valores singulares prestablecidos. También Li y Mathias [LM01], en
2001, establecen condiciones para la existencia de una matriz compleja n × n,
con n valores singulares deseados y m ≤ n valores propios deseados y diseñan
un algoritmo para generar tal matriz, pudiendo elegir el orden en que los valores
propios aparezcan en la diagonal.
Un trabajo reciente es el de Politi [Pol03] en 2003, quien considera la resolu-
ción de un problema inverso de valores singulares introduciendo la descomposi-
ción de una matriz cuadrada real A = P SQt , con P , Q matrices cuadradas reales
ortogonales, con respecto a un producto interno particular definido a través
de una matriz real diagonal G, de orden n, que tiene sus elementos iguales
a +1, −1, y S es matriz diagonal real con elementos no negativos llamados
valores G − singulares. Cuando G es la identidad, esta descomposición es la
descomposición en valores singulares usual y S es la matriz diagonal de valores
singulares. Ası́, dado un conjunto S1 , S2 , · · · , Sn de n números reales positivos
se considera el problema de encontrar una matriz real A que los tenga como
valores G − singulares.
En la mayorı́a de los trabajos de investigación mencionados se reportan
experimentos numéricos con problemas de tamaño paqueño, por ejemplo, m = 5
y n = 4 en [Chu92a] y [BMX03], m = n = 50 en [KA00], por lo tanto
es necesario observar el comportamiento de los algoritmos para problemas de
12
mayor tamaño. Por otra parte, no se reportan en la literatura aproximaciones
paralelas a la resolución del Problema Inverso de Valores Singulares, teniendo
en este rubro un campo abierto de investigación.
1.4. Planteamiento del Problema

De acuerdo a los objetivos planteados en este trabajo, los problemas inversos
de valores singulares que se abordan son:
Problema Inverso Aditivo de Valores Singulares (PIAVS).

Dado un conjunto de matrices A0 , A1 , ..., An ∈ <m×n (m ≥ n) y un
conjunto de números reales Σ∗ = {S1∗ , S2∗ , ..., Sn∗ }, tales que S1∗ >
S2∗ > ... > Sn∗ > 0, este problema consiste en encontrar un vector de
números reales c = [c1 , c2 , ..., cn ]t , tal que los valores singulares de
A(c) = A0 + c1 A1 + · · · + cn An sean los elementos de Σ∗ .
El PIAVS se caracteriza por tener más de una solución, es decir,
pueden existir cX y cY tales que los valores singulares de A(cX ) y
A(cY ) sean Σ∗ . Por ejemplo, suponer m = n = 3, con
A0 A1 = e1 et1 A2 = e2 et2 A3 = e3 et3

2 3 2 3 2 3 2 3
1 3 5 1 0 0 0 0 0 0 0 0
4 2 1 3 5 4 0 0 0 5 4 0 1 0 5 4 0 0 0 5,
6 7 6 7 6 7 6 7
4 2 1 0 0 0 0 0 0 0 0 1
existen cX = [3, 2, 1]t y cY = [1, 2, 3]t tales que los valores singulares
de A(cX ) y A(cY ) son Σ∗ ={9.5, 1.8, 0.9}. Denotaremos con c∗ a
una de las soluciones del PIAVS, es decir al vector de números reales
c∗ = [c∗1 , c∗2 , ..., c∗n ]t , tal que los valores singulares de A(c∗ ) son Σ∗ .
Tı́picamente el PIAVS se resuelve con aproximaciones calculadas por
métodos iterativos, por lo que se denota con c(0) la aproximación ini-
cial.
Problema Inverso Estructurado de Valores Singulares (PIEVS).

Dado un conjunto de números reales Σ∗ = {S1∗ , S2∗ , ..., Sn∗ }, tales que
S1∗ > S2∗ > ... > Sn∗ > 0, el problema es construir una matriz tipo
Toeplitz T ∈ <n×n cuyos valores singulares sean Σ∗ , es decir:
 
t0 t−1 ... t−(n−2) t−(n−1)

 t1 t0 ... t−(n−3) t−(n−2) 

 .. .. .. .. .. 
 = U diag(S1∗ , S2∗ , ..., Sn∗ )V t ,
T =
 . . . . . 
 
 t(n−2) t(n−1) ... t0 t−1 
t(n−1) t(n−2) ... t1 t0
13
donde U y V son vectores singulares de T correspondientes a Σ∗ .
Una matriz tipo Toeplitz puede representarse únicamente con su
primera columna y su primer renglón; ası́, la matriz T anterior se
puede expresar en una notación simplificada como:
T = toep(primer vector columna de T, primer vector renglón de T ) =

= toep([t0 , t1 , ..., t(n−2) , t(n−1) ], [t0 , t−1 , ..., t−(n−2) , t−(n−1) ]) =
= U diag(S1∗ , S2∗ , ..., Sn∗ )V t .
Si a partir de T se define T̃ como
T̃ = toep([1, t̃1 , ..., t̃(n−2) , t̃(n−1) ], [1, t̃−1 , t̃−2 , ..., t̃−(n−2) , t̃−(n−1) ]) =
= U diag([S̃1∗ , S̃1∗ , ..., S̃n∗ ])V t ,
donde
t̃i = ti /t0 , para i = −(n − 1), ..., 0, ..., n − 1
y
S̃i∗ = Si∗ /t0 , para i = 1, n,
T̃ se puede reescribir como
T̃ = In +t̃1 toep(e2 , 0tn )+...+t̃(n−2) toep(en−1 , 0tn )+t̃(n−1) toep(en , 0tn )+

+ t̃−1 toep(0n , et2 ) + t̃−2 toep(0n , et3 ) + ...+
+ t̃−(n−2) toep(0n , etn−1 ) + t̃−(n−1) toep(0n , etn ),
donde ei es el i-ésimo vector canónico y 0n es un vector columna

de n ceros. El problema de calcular los 2n − 1 elementos de T̃ , de
modo que T̃ tenga los n valores singulares deseados S̃i∗ (i = 1, n),
implica asignar libremente valores a n − 1 elementos, tomando los
n elementos restantes como las incógnitas de un PIAVS. Si las n
incógnitas representan las n diagonales de T̃ , el Problema Inverso
Estructurado de Valores Singulares siguiente:
toep([1, 0, ..., t̃(n/2)+1 , ..., t̃(n−1) ], [1, 0, ..., t̃−((n/2)+1) , ..., t̃−(n−1) ])+
t̃1 toep(e2 , 0tn ) + ... + t̃n/2 toep(e(n/2)+1 , 0tn )+
t̃−1 toep(0n , et2 ) + ... + t̃−(n/2) toep(0n , et(n/2)+1 ) =
= U diag(S̃1∗ , S̃2∗ , ..., S̃n∗ )V t
queda representado como un Problema Inverso Aditivo de Valores

Singulares donde A0 = toep([1, 0, ..., t̃(n−1) ], [1, 0, ..., t̃−(n−1) ]), A1 =
toep(e2 , 0tn ),..., An/2 = toep(e(n/2)+1 , 0tn ), A(n/2)+1 = toep(0n , et2 ),...,
An = toep(0n , et(n/2)+1 ) y c = [t̃1 , ..., t̃n/2 , t̃−1 , ..., t̃−(n/2) ]. Al poder
14
expresar al PIEVS como un PIAVS, el PIEVS puede tener más de
una solución y c∗ denota una de ellas.
Problema Inverso de Valores Singulares y Valores Propios

(PIVSVP). Dados el conjunto de números reales positivos Σ∗ =
{S1∗ , S2∗ , ..., Sn∗ } y el conjunto de números reales Λ∗ = {L∗1 , L∗2 , ..., L∗n },
tales que S1∗ > S2∗ > ... > Sn∗ , |L∗1 | > |L∗2 | > ... > |L∗n | y que cumplen
las condiciones Weyl-Horn:
k
Y k
Y
|L∗j | ≤ Sj∗ para k = 1, n − 1
j=1 j=1
n
Y n
Y
|L∗j | = Sj∗ ,
j=1 j=1
el PIVSVP consiste en construir una matriz de tamaño n × n que
posea tanto los valores singulares Σ∗ como los valores propios Λ∗ .
1.5. Resolución y Casos de Prueba

Habiendo definido los problemas a abordar, a continuación se hace una breve
mención de los métodos que los resuelven, los cuales se analizan, diseñan e im-
plementan secuencial y paralelamente en este trabajo y cuyo estudio se reporta
a lo largo de este documento.
Fuerza Bruta (FB). La forma más simple de expresar el PIAVS

es como un sistema de ecuaciones no lineales de la forma F (z) = 0
que se construye directamente de la definición del PIAVS y que se
resuelve con el método de Newton. Esta forma de abordar el PIAVS
es una aportación de este trabajo [FBGV05].
Método I (MI). Del conjunto de cuatro métodos llamados Method

I, Method II, Method III, Method IV para la resolución del PIVP [FNO87],
en este trabajo se adapta el Method I para la resolución del PI-
AVS [CCFV05], que es un método tipo Newton.
Método III (MIII). Este es el método discreto dado por Chu en

[Chu92a], adaptación del Method III [FNO87]. También es un méto-
do tipo Newton para la resolución del PIAVS.
Elevación-Proyección (EP). Este método [FBVM03] es una adaptación

del método Lift&Project [CC96]. Se basa en el planteamiento del PI-
AVS como un problema de mı́nimos cuadrados. Esta adaptación es
15
un aporte de este trabajo.
Método para la construcción de una matriz triangular in-

ferior unidad (MTriIU). También se estudia este método presen-
tado en [KA00] que construye una matriz triangular inferior unidad
con valores singulares prestablecidos que cumplen las condiciones de
Weyl, resolviendo ası́ un caso particular del PIVSVP.
Método para la construcción de una matriz bidiagonal (MBi-

diag). Este método es un aporte de este trabajo de tesis, consiste
en la construcción de una matriz bidiagonal, con valores singulares
y valores propios prestablecidos que satisfacen las condiciones de
Weyl-Horn. Este es un método alternativo a los presentados por
Chu en [Chu00] y Li y Mathias en [LM01], que construyen matrices
cuasitriangular superior y triangular inferior, respectivamente.
Todos los métodos planteados para la resolución del PIAVS también resuel-
ven el PIEVS.
La experimentación con estos métodos se realiza utilizando los siguientes
casos de prueba:
 


  Chu y Bai (ChuBai)




 No estructurados General (Gral)

 



 Diagonal (Diag)


Casos 


 
 Toeplitz Triangular Inferior (ToepTril)
 



 Toeplitz General (ToepGral)

 Estructurados


 

 Triangular Inferior Unidad (TrilU)

 
Bidiagonal (Bidiag)
Caso ChuBai. El caso Chu es un conjunto de pruebas del PIAVS

dadas en [Chu92a] que consideran 6 matrices, A0 , A1 , ..., A5 , de
tamaño 5 × 4 (m = 5, n = 4), tres conjuntos de valores singulares
prescritos Σ∗A , Σ∗B , Σ∗C , con sus correspondientes soluciones c∗A , c∗B ,
(o) (o) (o)
c∗C y puntos iniciales cA , cB y cC . El caso Bai también es un con-
junto de tres pruebas del PIAVS (A, B, C), con m = 5 matrices de
tamaño m × n = 5 × 4, que se pueden encontrar en [BMX03].
Caso Gral. Con el fin de probar los métodos del PIAVS para casos
aleatorios, se considera que las matrices A0 , A1 , ..., An no tienen es-
tructura ni valores particulares.
16
Caso Diag. Para probar los métodos del PIAVS con tamaños su-
ficientemente grandes, se utilizan las matrices A0 aleatoria sin es-
tructura y Ai = ei eti (i = 1, n); en este caso basta con almacenar
explı́citamente sólo la matriz A0 , disminuyendo sustancialmente el
almacenamiento requerido, pudiendo incrementar los valores de m y
n.
Caso ToepGral. De una matriz aleatoria tipo Toeplitz se generan

las matrices Ai (i = 0, n) para las pruebas de los métodos del PIEVS.
Caso ToepTril. Para probar los métodos en un caso particular del

PIEVS, a partir de una matriz aleatoria tipo Toeplitz triangular in-
ferior, se determinan las matrices Ai (i = 0, n).
Caso TrilU. Este es un caso de prueba del PIVSVP donde no es

necesario determinar las matrices Ai (i = 0, n), basta con especificar
los valores singulares deseados Σ∗ , que satisfagan las condiciones de
Weyl, para probar la construcción de una matriz triangular inferior
unidad que posea tales valores.
Caso Bidiag. Otro caso de prueba del PIVSVP es el que requiere

de la especificación de valores singulares y valores propios prestable-
cidos que satisfagan las condiciones de Weyl y Horn, con los cuales
probar el algoritmo que construye una matriz bidiagonal que posea
tales valores singulares y valores propios.
1.6. Herramientas Hardware y Software de En-

tornos Paralelos
La implementación secuencial y paralela de los algoritmos para el estudio y
observación experimental de los métodos que resuelven en PIVS se ha llevado a
cabo dentro del entorno de programación que se describe en esta sección.
Los problemas que requieren un alto grado de cómputo para su resolución,
como es el caso del PIVS (lo que se constatará en a lo largo de este traba-
jo), requieren ası́ mismo de potentes entornos de programación que garanticen
una resolución eficiente. Entornos de programación secuencial pueden ofrecer
estas garantı́as siempre que se cuente con los recursos suficientes para acceder
a computadores de alta productividad que incorporen los últimos avances tec-
nológicos. Sin embargo, siempre se encontrará una limitación fı́sica que impida
obtener mayor beneficio.
17
El entorno de programación alternativo es el que integra computadoras de
bajo costo unidos en un multicomprocesador. Con este tipo de entornos se logran
resoluciones eficientes sin el problema de las limitaciones fı́sicas ni de los altos
costos de un supercomputador secuencial, al tener la posibilidad de aumentar
el número de procesadores que se integran en el multicomprocesador.
En este trabajo se han utilizado esencialmente multiprocesadores de memoria
distribuida, cuyos componentes son PCs o estaciones de trabajo conectadas
mediante una red de interconexión de paso de mensajes. También se ha podido
contar con el uso de una multicomputadora de memoria compartida distribuida.
El uso de ambos tipos de sistemas ha dado la posibilidad de diseñar algoritmos
donde el control de la distribución y manipulación de los datos es manejada
por el programador, utilizando mecanismos de paso de mensajes; y también se
han podido diseñar algoritmos donde este control se realiza mediante el uso
de directivas, como las ofrecidas por OpenMP. Una breve descripición de los
clusters utilizados se da enseguida.
Cluster Kubrick. Este cluster de memoria distribuida está consti-

tuido de 2 nodos biprocesadores Intel Xeon, a 2.2 GHz y 4 Gbytes
de RAM. Los nodos están interconectados con una red Ethexpress.
Trabaja bajo plataforma LINUX (Red Hat 8).
Cluster Kefren. Kefren es otro cluster de memoria distribuida que

trabaja bajo el ambiente LINUX (Red Hat 8), consta de 20 nodos
biprocesadores Pentium Xeon, a 2 GHz y 1 Gbyte de RAM. Los
nodos están interconectados mediante una red SCI con una topologı́a
de Toro 2D en una malla de 4 × 51 .
Cluster Aldebarán. Aldebarán es un sistema SGI Altix 3700 de

48 procesadores Intel Itanium 2, a 1.5 GHz y 16 Gbytes de RAM.
Los nodos están conectados mediante una red de interconexión SGI
NumaLink en una topologı́a de hipercubo. Funciona bajo el sistema
operativo LINUX (Ren Hat 7.2) y es considerado un sistema de
memoria compartida distribuida2 .
Cluster MareNostrum. Es un cluster JS20, PPC 970 a 2.2 GHz,

dispone de 4564 procesadores POWER y 9 Terabytes de RAM.
Está basado en una red de interconexión de procesadores Myrinet
y trabaja bajo el sistema operativo LINUX (Suse). MareNostrum
representa el computador más potente de Europa y está dentro de
los diez primeros lugares en el Top 500. Al momento de redactar
1 http://www.grycap.upv.es
2 http://www.asic.upv.es
18
este documento, los algoritmos desarrollados en esta tesis se están
poniendo a punto para la experimentación en este cluster3 .
Para el tipo de hardware utilizado existe software adecuado que explota las
caracterı́sticas de la arquitectura y permite obtener el máximo rendimiento; por
eso se ha empleado, para los programas codificados en lenguaje de programación
Fortran90, las siguientes bibliotecas secuenciales:
BLAS (Basic Linear Algebra Subprograms). Colección de rutinas

para realizar operaciones básicas a bloques de matrices y vectores
[HDDCH88].
LAPACK (Linear Algebra PACKage). Biblioteca que contiene ruti-

nas para resolver sistemas de ecuaciones lineales, problemas de mı́ni-
mos cuadrados lineales, problemas de valores propios y problemas de
valores singulares, problemas comunes del álgebra lineal [ABB+ 95].
También se han utilizado las bibliotecas paralelas:
MPI (Message Passing Interface). Es una biblioteca de comunica-

ciones que implementa el mecanismo de paso de mensajes entre
nodos de cómputo que se comunican mediante una red de inter-
conexión [GLS94] [VP00].
BLACS (Basic Linear Algebra Communication Subprograms). Es

una biblioteca que ofrece rutinas de comunicación de paso de men-
sajes que aparecen con frecuencia en cómputos paralelos del álgebra
lineal.
PBLAS (Parallel Basic Linear Algebra Subprograms). Es una ver-

sión de BLAS para computadoras de memoria distribuida [CDO+ 95].
Tanto PBLAS como BLACS proporcionan rutinas necesarias para
el funcionamiento de ScaLAPACK.
ScaLAPACK (Scalable LAPACK). Librerı́a diseñada para resolver

un conjunto de rutinas LAPACK en multicomputadoras de memoria
distribuida con mecanismos de comunicación de paso de mensajes.
Asume que las matrices que maneja se descomponen en bloques cı́cli-
cos bidimensionales sobre una malla lógica de Prc = Pr × Pc proce-
sadores (Pr número de procesadores renglón, Pc número de proce-
sadores columna). Por ejemplo, si la malla de procesadores consta
3 http://www.bsc.org.es
19
de 2 renglones y 3 columnas (Pr = 2, Pc = 3, Prc = 6), se espera
que una matriz de tamaño 9 × 9 y un vector de tamaño 9, que se
descomponen en bloques de tamaño 2 × 2, queden distribuidos en
la malla de procesadores como sigue [BCC97]:
Pc
0 1 2
a11 a12 a17 a18 a13 a14 a19 a15 a16
a21 a22 a27 a28 a23 a24 a29 a25 a26
0 a51 a52 a57 a58 a53 a54 a59 a55 a56
a61 a62 a67 a68 a63 a64 a69 a65 a66
Pr a91 a92 a97 a98 a93 a94 a99 a95 a96
a31 a32 a37 a38 a33 a34 a39 a35 a36

1 a41 a42 a47 a48 a43 a44 a49 a45 a46
a71 a72 a77 a78 a73 a74 a79 a75 a76
a81 a82 a87 a88 a83 a84 a89 a85 a86
La jerarquı́a de software de ScaLAPACK es la siguiente:
ScaLAPACK
↑ ↑
LAPACK PBLAS
↑ % ↑
BLAS BLACS
↑
MPI
Se han utilizado las versiones optimizadas del lenguaje Fortran90 y de las

bibliotecas de álgebra lineal numérica siguientes:
Compilador Fortran del sistema de compiladores de Intel [Cor03]

y del sistema de compiladores IBM4 . Para la codificación de los al-
goritmos diseñados bajo el modelo de memoria compartida, se han
utilizado directivas OpenMP de este compilador.
MKL (Math Kernel Library). Es la biblioteca que contiene funciones

matemáticas optimizadas para aplicaciones cientı́ficas e ingenieriles.
4 http://publib.boulder.ibm.com/infocenter/lnxpcomp/index.jsp
20
Incluye: BLAS, LAPACK, PARDISO, biblioteca matemática vecto-
rial y biblioteca estadı́stica vectorial optimizadas para procesadores
Intel [Cor04].
SCSL (Silicon Computing Scientific Libraries). Es la biblioteca que

contiene las versiones optimizadas de BLAS, LAPACK y ScaLA-
PACK para los sistemas SGI [SG03].
ESSL (Engineering and Scientific Subroutine Library) y PESSL

(Parallel ESSL). Estas bibliotecas proporcionan un conjunto de fun-
ciones matemáticas para aplicaciones cientı́ficas e ingenieriles, opti-
mizadas para sistemas Linux en sistemas POWER de IBM5 .
Todas estas bibliotecas garantizan eficienca, portabilidad y robustez de los

programas secuenciales y paralelos implementados en los cluster descritos.
1.7. Evaluación de Algoritmos Paralelos

La evaluación de los algoritmos paralelos requiere de métricas de presta-
ciones que consideren el tamaño del problema a resolver (m) y el número de
procesadores empleados para ello (Prc ). Las métricas que se utilizan tı́pica-
mente son [KGGKrp94]:
Tiempo de Ejecución, que se denota con la función
T (m, Prc ) = TA (m, Prc )tf + TC (m, Prc )

donde
TA (m, Prc ) es el tiempo empleado por el algoritmo para realizar o-

peraciones aritméticas
tf es el tiempo de ejecución de una operación en punto flotante
TC (m, Prc ) es el tiempo empleado por el algoritmo para realizar

comunicaciones entre procesadores
En el modelo de paso de mensajes, el tiempo de comunicación de un men-

saje de longitud m de un nodo a otro en una red de procesadores se expresa
como [DD95]:
TC (m, Prc ) = tm + mtv
5 http://publib.boulder.ibm.com/infocenter/clresctr/index.jsp
21
donde
tm es el tiempo de establecimiento de comunicación entre los nodos

(latencia)
tv es el tiempo de transferencia de un mensaje de longitud 1 (inverso

del ancho de banda)
Aceleración de ejecución (Speedup), que mide la ganancia de velocidad de

ejecución del algoritmo paralelo con respecto al mejor algoritmo secuencial que
resuelve el mismo problema. El Speedup está dado por:
T (m, 1)
S(m, Prc ) = ,
T (m, Prc )
idealmente se espera que el Speedup sea igual al número de procesadores em-
pleados [KGGKrp94].
Eficiencia, que mide el porcentaje del tiempo de ejecución que los procesadores
se mantienen útilmente empleados. La Eficiencia se define como:
S(m, Prc )
E(m, Prc ) = ,
Prc
donde la eficiencia ideal es igual a 1 [KGGKrp94].
Escalabilidad, que puede, a su vez, evaluarse mediante diferentes métricas que

pueden encontrarse en la literatura especializada [KGGKrp94]. Es conveniente
tener en cuenta las caracterı́sticas de los problemas con los que se está tratando
para elegir la métrica adecuada de escalabilidad [MT97]. En este trabajo se
ha utilizado el Speedup escalado como se ha definido en [KGGKrp94] por su
facilidad de uso cuando resultados experimentales están disponibles. El Speedup
escalado mide la capacidad que tiene el algoritmo paralelo de mantener sus
prestaciones cuando crecen en la misma proporción los recursos del sistema y
el tamaño del problema. Considerando que el costo teórico computacional de
un algoritmo secuencial es W , entonces, escalar el número de procesadores P rc
y el tamaño del problema en la misma proporción, implica que si se escala el
número de procesadores con kPrc , entonces W debe escalarse con kW .
Por lo tanto, para evaluar un algoritmo que se ejecute en los clusters de la
sección anterior, se necesita estimar el valor de los parámetros tf , tm y tv . El
valor de tf depende del tipo de operaciones de punto flotante que se realicen:
escalares, vectoriales o matriciales. Los resultados obtenidos para cada cluster
son:
22
Tiempo de Flop (tf )
Cluster Escalares Vectoriales Matriciales
Kubrick 3e-3 µseg 2e-2 µseg 3e-4 µseg
Kefren 3e-3 µseg 1e-2 µseg 5e-4 µseg
Aldebarán 3e-3 µseg 1e-2 µseg 2e-4 µseg
MareNostrum 1e-5 µseg 1e-3 µseg 1e-4 µseg
Los parámetros de comunicaciones tm y tv se han medido utilizando un

algoritmo tipo ping-pong [DD95]. Para cada cluster los parámetros obtenidos
son:
Cluster tm (latencia) tv (transferencia) ancho de banda

Kubrick 47 µseg 0.12 µseg/doble 66 Mbytes/seg
Kefren 5 µseg 0.048 µseg/doble 166 Mbytes/seg
Aldebarán 2 µseg 0.0012 µseg/doble 6.4 Gbytes/seg
MareNostrum 1 µseg 0.0095 µseg/doble 841 Mbytes/seg
1.8. Estructura del trabajo

Habiendo definido el problema a tratar y especificado las condiciones de
resolución, en el Capı́tulo 2 se abordan los métodos que resuelven el PIAVS,
presentando sus algoritmos secuenciales, las estructuras de datos utilizadas, la
estimación de requerimientos de almacenamiento y pruebas numéricas.
En el Capı́tulo 3 se presenta una implementación eficiente de los algoritmos
secuenciales del PIAVS, haciendo uso de rutinas implementadas en BLAS y
LAPACK, se estima la complejidad de tiempos de los algoritmos y se analizan y
evaluan los métodos del PIAVS de acuerdo a: eficiencia, complejidad de tiempo
de ejecución, requerimientos de memoria, exactitud y convergencia.
En el Capı́tulo 4 se paralelizan los algoritmos del PIAVS y se realizan pruebas
numéricas para analizar sus prestaciones.
En el Capı́tulo 5 se aborda la particularización de los algoritmos del PIAVS
para resolver el PIEVS, tanto secuencial como paralelamente, se analizan las
prestaciones de los algoritmos particularizados y se evalúan con respecto a los
algoritmos generales.
En el Capı́tulo 6 se resuelve una particularización del PIVSVP, proponiendo
algoritmos paralelos bajo el Modelo de Memoria Distribuida y del Modelo de
Memoria Compartida, contrastando ambas implementaciones y analizando sus
ventajas e inconvenientes. También se presenta un método para resolver una
generalización del PIVSVP.
Por último, en el Capı́tulo 7 se dan las conclusiones de este trabajo y las
perspectivas de investigación que se desprenden del mismo.
23
Capı́tulo 2
Métodos y Algoritmos
Secuenciales para la
Resolución del PIAVS
En este capı́tulo se desarrollan los algoritmos secuenciales que dan solución

al PIAVS correspondientes a los métodos FB, MI, MIII y EP.
FB es un algoritmo que resulta de abordar el PIAVS haciendo uso directo
de sus caracterı́sticas inherentes y es uno de los aportes de este trabajo. MI ha
sido adaptado del Method I [FNO87] del PIVP por los autores de este trabajo.
EP es un algoritmo inspirado en el algoritmo Lift&Project [CC96] del PIVP y
es otro de los aportes de este trabajo. MIII se ha tomado directamente de la
literatura [Chu92a].
Todos los algoritmos son de naturaleza iterativa y calculan en cada iteración
una aproximación a la solución c∗ , partiendo de una aproximación inicial c(0) .
Las pruebas numéricas para este capı́tulo se han realizado ejecutando imple-
mentaciones Matlab. Implementaciones secuenciales eficientes se presentan en
el Capı́tulo 3 utilizando el lenguaje de programación Fortran y las herramientas
software de BLAS y LAPACK y en el Capı́tulo 4 se presentan las implementa-
ciones correspondientes a los algoritmos paralelos diseñados, utilizando Fortran,
BLACS y LAPACK, demás de las herramientas software PBLAS, ScaLAPACK,
BLACS y MPI.
Para las pruebas numéricas de este capı́tulo se ha utilizado un nodo del
cluster Kubrick sobre los casos ChuBai y Gral. El caso ChuBai tiene como puntos
iniciales y resultados esperados los de las Tablas 2.1 [Chu92a] y 2.2 [BMX03].
Para las pruebas del caso Gral se han considerado las dimensiones m = n =
(0)
{4, 5, 10, 15, 20, 25, 30, 40, 50}, con puntos iniciales ci = c∗i + δ (i = 1, n), con
δ = {1e − 1, 1e0, 1e1}, con el fin de seleccionar puntos iniciales cercanos a la
24
Tabla 2.1: Puntos iniciales del caso ChuBai
Pruebas Chu Pruebas Bai
casos c(0) S (0) c(0) S (0)
A 4.4029e-1 6.8899e0 1.4922e0 1.0619e1
3.9909e-1 5.1196e0 8.2514e-1 9.5193e0
-1.5330e0 3.9921e0 2.0528e0 5.8848e0
-1.3434e0 1.4204e0 1.3341e0 3.3880e0
B 1.9984e0 1.0936e1 2.8790e0 1.5645e1
1.3802e0 6.5910e0 1.7106e0 1.1566e1
-6.5989e-1 4.4004e0 1.5505e0 6.1310e0
-9.7495e-1 8.0045e-1 5.0169e-1 3.9678e0
C 1.0639e0 6.8109e0 2.7143e0 1.2923e1
1.2202e0 5.6892e0 -5.7860e-1 1.0640e1
-4.4669e-2 3.2544e0 2.2674e0 7.1825e0
6.6640e-3 1.3534e0 5.7221e-1 2.7371e0
Tabla 2.2: Resultados esperados del caso ChuBai

Pruebas Chu Pruebas Bai
casos c∗ S∗ c∗ S∗
A -8.8571e-2 5.2995e0 1.2541e0 7.6932e0
5.1462e-1 3.3937e0 7.8632e-1 6.4255e0
-1.0132e0 2.2206e0 1.1208e0 3.8780e0
-8.8725e-1 1.0707e0 8.2783e-1 2.2199e0
B 2.3693e0 1.3414e1 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 8.8169e-1 6.9200e0 1.8505e0 1.0321e1
1.3168e0 5.1245e0 -1.4848e0 8.4827e0
-2.5081e-1 3.3331e0 2.0673e0 6.1540e0
-1.5865e-1 1.0240e0 -2.8719e-1 1.8127e0
solución, por tratarse de métodos tipo Newton. Pruebas con dimensiones de

mayor orden (m = {O(102 ), O(103 )}) serán consideradas en los Capı́tulos 3 y 4.
En todos los casos considerados se ha aplicado una tolerancia de 5e − 6 para
el criterio de paro propio de cada algoritmo.
Los resultados arrojados por los experimentos numéricos servirán en el si-
guiente capı́tulo para analizar el comportamiento, las ventajas e inconvenientes
de los métodos, con base en aspectos espaciales, temporales, de convergencia y
exactitud.
Un denominador común de los algoritmos es el conjunto de estructuras de
datos que utilizan todos ellos:
Ai para i = 0, n; son n+1 matrices de tamaño m×n (A0 , A1 , ..., An ).
S∗ vector de tamaño n, almacena los valores singulares deseados.
25
c∗ vector de tamaño n, almacena una de las soluciones del PIAVS.
c vector de tamaño n, almacena las aproximaciones a la solución

c∗ , es decir, las n incógnitas del sistema.
A este conjunto de estructuras de datos se añaden las propias de cada algo-

ritmo en el análisis de requerimiento de almacenamiento.
Para evitar problemas de almacenamiento con las dimensiones mayores, la
implementación Matlab va generando las matrices Ai (i = 0, n) al momento de
utilizarlas, requiriendo sólamente una matriz de m × n elementos en memoria,
en lugar de n + 1 matrices de m × n elementos.
2.1. Método Fuerza Bruta (FB)

El PIAVS requiere de encontrar un vector c tal que los valores singulares de
A(c) = A0 + c1 A1 + ... + cn An (2.1)
sean un conjunto de valores dados S ∗ = {S1∗ , S2∗ , ..., Sn∗ }, es decir, tal que la
descomposición en valores singulares de A(c) sea
A(c) = P diag(S ∗ )Qt (2.2)
siendo P ∈ <m×m los vectores singulares izquierdos y Q ∈ <n×n los vectores

singulares derechos de A(c), correspondientes a S ∗ ; éstos son ortonormales, es
decir
P t P = Im (2.3)
Qt Q = I n . (2.4)
Con (2.2), (2.3) y (2.4) se puede construir un sistema de ecuaciones no

lineales de la forma
F (z) = 0 (2.5)
donde
z = [Q1,1 , Q1,2 , ..., Qn,n , P1,1 , P1,2 , ..., Pm,n , c1 , c2 , ..., cn ]t , (2.6)
siendo que las incógnitas del sistema son: el vector c (n incógnitas) y los ele-
mentos de los vectores singulares P (mn incógnitas 1 ) y Q (n2 incógnitas); por
lo que (2.5) se expresa como
F (Q, P, c) = 0
1 Se consideran sólo los min{m, n} vectores singulares de P porque se manejan min{m, n}
valores singulares;
26
que por (2.2), (2.3) y (2.4), es el conjunto de ecuaciones siguientes
Fmn+n n+1 +(i−1)n+j−i+1 (Q, P, c) = (Qt Q − In )i,j ; i = 1, n; j = i, n; (2.7)

2
Fmn+(i−1)n+j−i+1 (Q, P, c) = (P t P − Im )i,j ; i = 1, n; j = i, n; (2.8)

n
X
F(i−1)n+j (Q, P, c) = (A0 + ck Ak − P diag(S ∗ )Qt )i,j ; i = 1, m; j = 1, n;
k=1
(2.9)
Por (2.7) se tienen n n+1 2 ecuaciones, por (2.8) n n+1
2 ecuaciones y por (2.9)
se tienen mn ecuaciones más. Por lo tanto, se ha definido un sistema no lineal
de mn + n2 + n ecuaciones con mn + n2 + n incógnitas. Como es tı́pico de este
tipo de sistemas, se utiliza el método de Newton para calcular una sucesión de
vectores z (0) , z (1) , z (2) , ..., z (k) que aproximen a la solución de F (z) = 0, es decir,
una sucesión de Q(0) , P (0) , c(0) , Q(1) , P (1) , c(1) , Q(2) , P (2) , c(2) , ..., Q(k) , P (k) , c(k)
que aproximen a la solución de F (Q, P, c) = 0. Entonces, si z (k) es el k-ésimo
elemento de la sucesión, el (k + 1)-ésimo elemento está dado por [DS83] [Kel95]:
z (k+1) = z (k) − J(z (k) )−1 F (z (k) ) (2.10)
donde J(z (k) ) es la matriz Jacobiana de F (z) evaluada en z (k) . En este caso, la
matriz Jacobiana de F (Q, P, c) se define como  
h i J1,1 0 0
∂Fr (z)  
J(Q, P, c) = ∂zt =  0 J2,2 0 
r=1:mn+n2 +n,t=1:mn+n2 +n
J3,1 J3,2 J3,3
donde J1,1 , J2,2 , J3,1 , J3,2 y J3,3 son bloques de tamaño n(n + 1)/2 × n2 , n(n +
1)/2 × mn, mn × n2 , mn × mn y mn × n, respectivamente, tales que

∂(Qt Q − In )i,j
J1,1 = ; k = 1, n; t = 1, n (2.11)
∂Qk,t i=1:n n+1 ,j=1:n2
2

∂(P t P − Im )i,j
J2,2 = ; k = 1, m; t = 1, n (2.12)
∂Pk,t i=1:n n+1
2 ,j=1,mn
Pn
∂(A0 + l=1 cl Al − P diag(S ∗ )Qt )i,j
J3,1 = ; k = 1, n; t = 1, n
∂Qk,t i=1:mn,j=1:n2
Pn (2.13)
J3,2 = ; k = 1, m; t = 1, n
∂Pk,t i=1:mn,j=1:mn
Pn (2.14)
J3,3 = ; k = 1, n (2.15)
∂ck i=1:mn,j=1:n
donde
P
para i = 0, n − 1; j = 1, n; row = 1 + i−1
k=0 (n − k); col = i + (j − 1)n + 1
27
(J1,1 )row,col = 2Qj,i+1
(J1,1 )row+1:row+n−i−1,col = Qtj,i+2:n
(J1,1 )row+a,col+a = Qj,i+1 a = 1, n − i − 1;
Pi−1
para i = 0, n − 1; j = 1, m; row = 1 + k=0 (n − k); col = i + (j − 1)n + 1
(J2,2 )row,col = 2Pj,i+1
t
(J2,2 )row+1:row+n−i−1,col = Pj,i+2:n
(J2,2 )row+a,col+a = Pj,i+1 a = 1, n − i − 1;
y para i = 1, m; j = 1, n; t = 1, n
(J3,1 )(i−1)n+j,(j−1)n+t = St∗ Pi,t
(J3,2 )(i−1)n+j,(i−1)n+t = St∗ Qj,t
(J3,3 )(i−1)n+j,t = (At )i,j
Con lo definido hasta ahora se puede aplicar la iteración de Newton (2.10)

al sistema de ecuaciones no lineales (2.5), que convergerá cuadráticamente a
la solución si se parte de un z (0) suficientemente cercano a ésta, tal como se
demuestra en [DS83] [Kel95]. Al algoritmo correspondiente a este método se
da en la siguiente subsección.
2.1.1. Algoritmo Fuerza Bruta

El algoritmo FB está en el algoritmo 1. Éste utiliza, además de Ai (i = 0, n),
S , c∗ , c, las siguientes estructuras de datos:
∗
AoP matriz de tamaño m × n, almacena tanto la matriz A(c) = A0 +

Pn
i=1 ci Ai , como P , los n vectores singulares izquierdos de A(c),
es decir, m × n incógnitas del sistema.
Q matriz de tamaño n × n, almacena Qt , los n vectores singulares

transpuestos derechos de A(c), es decir, n × n incógnitas del sis-
tema.
J matriz de tamaño (mn + n2 + n) × (mn + n2 + n), almacena la

matriz Jacobiana de F (c) y su descomposición lu.
S vector de tamaño n, almacena los valores singulares de A(c).
28
Tabla 2.3: Dimensiones de F y J del algoritmo FB
m = n dimensiones de F dimensiones de J
4 36 × 1 36 × 36
10 210 × 1 210 × 210
30 1830 × 1 1830 × 1830
50 5050 × 1 5050 × 5050
100 20100 × 1 20100 × 20100
500 500500 × 1 500500 × 500500
1000 2001000 × 1 2001000 × 2001000
Tabla 2.4: Requerimiento de memoria del algoritmo FB

Estructuras Número de elementos de doble precisión
F 3.6e01 2.1e02 1.8e03 5.1e03 2.0e04 5.0e05 2.0e06
J 1.3e03 4.4e04 3.3e06 2.6e07 4.0e08 2.5e11 4.0e12
Ai=0,n 8.0e01 1.1e03 2.8e04 1.3e05 1.0e06 1.3e08 1.0e09
AoP 1.6e01 1.0e02 9.0e02 2.5e03 1.0e04 2.5e05 1.0e06
Q 1.6e01 1.0e02 9.0e02 2.5e03 1.0e04 2.5e05 1.0e06
S∗ 4.0e00 1.0e01 3.0e01 5.0e01 1.0e02 5.0e02 1.0e03
c∗ 4.0e00 1.0e01 3.0e01 5.0e01 1.0e02 5.0e02 1.0e03
c 4.0e00 1.0e01 3.0e01 5.0e01 1.0e02 5.0e02 1.0e03
Total
dobles 1.5e03 4.6e04 3.4e06 2.6e07 4.1e08 2.5e11 4.0e12
Memoria
requerida 12 Kb 366 Kb 28 Mb 205 Mb 4 Gb 2006 Gb 32041 Gb
m=n 4 10 30 50 100 500 1000
F vector de tamaño mn+n2 +n, almacena la función F (c) evaluada

en alguna c.
Con la lista de estructuras de datos anterior se vislumbra el alto costo de

almacenamiento que tiene este algoritmo. La Tabla 2.3 ayuda a tener una idea
de las dimensiones de F y J, las estructuras de datos que más almacenamiento
emplean, para diferentes valores de m y n.
Si se calcula el número de bytes necesarios para almacenar dobles en F y
J y si además se contabiliza el resto de vectores y matrices que utiliza FB,
los montos de memoria requeridos son los de la tabla 2.4. Los altos montos
registrados limitarán el tamaño de las pruebas del algoritmo. En este estudio se
ha tomado un tamaño máximo de m = n = 50.
2.1.2. Probando Fuerza Bruta

Se empieza por probar este algoritmo con el caso ChuBai, los resultados
obtenidos están en la Tabla 2.5, en la que se observa que en todos los casos FB
converge sin problemas a los resultados esperados, excepto el caso C del caso Bai
donde se alcanzan los valores singulares deseados bajo la tolerancia establecida,
29
Tabla 2.5: Resultados y convergencia del caso ChuBai con FB
Pruebas Chu Calculadas Pruebas Bai Calculadas
caso k c(k) S (k) k c(k) S (k)
A 5 -8.8570e-2 5.2995e0 9 1.2541e0 7.6932e0
5.1462e-1 3.3937e0 7.8632e-1 6.4255e0
-1.0132e0 2.2206e0 1.1208e0 3.8780e0
-8.8725e-1 1.0707e0 8.2783e-1 2.2199e0
B 6 2.3693e0 1.3414e1 5 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 4 8.8169e-1 6.9200e0 6 1.6635e0 1.0321e1
1.3168e0 5.1246e0 -1.1349e0 8.4827e0
-2.5081e-1 3.3331e0 2.2105e0 6.1540e0
-1.5865e-1 1.0240e0 6.6457e-1 1.8127e0
Pruebas Chu Esperadas Pruebas Bai Esperadas
A -8.8571e-2 5.2995e0 1.2541e0 7.6932e0
5.1462e-1 3.3937e0 7.8632e-1 6.4255e0
-1.0132e0 2.2206e0 1.1208e0 3.8780e0
-8.8725e-1 1.0707e0 8.2783e-1 2.2199e0
B 2.3693e0 1.34141e0 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 8.8169e-1 6.9200e0 1.8505e0 1.0321e1
1.3168e0 5.1245e0 -1.4848e0 8.4827e0
-2.5081e-1 3.3331e0 2.0673e0 6.1540e0
-1.5865e-1 1.0240e0 -2.8719e-1 1.8127e0
pero no ası́ la solución c∗ , véase la Tabla de errores 2.6 que refleja el hecho de
que el PIAVS puede tener más de una solución.
Los resultados arrojados por el algoritmo para el caso Gral están en la Tabla
2.7. Observando esta tabla, para los casos m = n ≤ 10 el algoritmo converge con
todos los puntos iniciales probados, mientras que para los casos m = n > 10 se
observa alta sensibilidad al punto inicial, éste debe ser más cercano a la solución
que para los casos de menor tamaño; ası́, cuando kF (c(0) )k2 > 10e4 el algoritmo
empeora las aproximaciones calculadas en 10 iteraciones.
A la vista de los resultados obtenidos, se puede concluir que, cuanto más
grande sea m será necesario dar un c(0) más cercano a c∗ para converger.
30
Algoritmo 1 Fuerza Bruta (FB)
1. Calcular A(0) de acuerdo a (2.1)
2. Calcular descomposición en valores singulares de A(0)
A(0) = P (0) diag(S (0) )Q(0)t
3. Calcular F (0) de acuerdo a (2.7), (2.8) y (2.9)
4. Para k = 0,1,..., Mientras kF (k) k2 > tol
4.1. Calcular J (k) de acuerdo a (2.11) - (2.15)
4.2. Calcular sol (k) resolviendo el sistema J (k) sol(k) = −F (k)
4.2.1. Calcular descomposición lu de J (k)
4.2.2. Resolver los sistemas triangulares
L(k) x(k) = −F (k)
U (k) sol(k) = x(k)
4.3. [c(k+1) , P (k+1) , Q(k+1) ] ← [c(k) , P (k) , Q(k) ] + sol(k)
4.4. Calcular F (k+1) de acuerdo a (2.7), (2.8) y (2.9)
Tabla 2.6: Errores del caso ChuBai con FB

kc∗ −c(k) k2 kS ∗ −S (k) k2
Caso Chu kc∗ − c(k) k2 kc∗ k
kS ∗ − S (k) k2 kS ∗ k2
2
A 2e-6 1e-6 9e-7 1e-7
B 3e-6 1e-6 4e-7 2e-8
C 1e-6 8e-7 1e-6 1e-7
kc∗ −c(k) k2 kS ∗ −S (k) k2
Caso Bai kc∗ − c(k) k2 kc∗ k2
kS ∗ − S (k) k2 kS ∗ k2
A 7e-11 3e-11 8e-11 7e-12
B 3e-11 1e-11 3e-11 2e-12
C 1e0 3e-1 9e-11 6e-12
31
Tabla 2.7: Resultados del caso Gral con FB
(0)
ci = c∗i + 1e − 1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e1 2e-3 3 4e-12 1e-16
5 1e2 1e-3 2 5e-7 2e-12
10 4e2 2e-3 3 3e-11 1e-16
15 1e3 2e-3 3 5e-10 1e-16
20 1e3 2e-3 3 4e-10 1e-16
25 3e3 2e-3 3 2e-8 1e-15
30 4e3 2e-3 3 9e-9 5e-16
40 8e3 1e-3 3 1e-9 2e-16
50 1e4 1e-3 3 2e-6 1e-14
(0)
ci = c∗i + 1e0 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e2 2e-2 3 3e-6 5e-11
5 1e3 1e-2 3 8e-9 4e-14
10 4e3 2e-2 4 4e-11 8e-17
15 1e4 2e-2 4 1e-6 4e-14
20 1e4 2e-2 5 2e-10 2e-16
25 3e4 2e-2 6 3e-10 1e-16
30 4e4 2e-2 5 5e-10 2e-16
40 8e4 1e-2 4 5e-8 2e-16
50 1e5 1e-2 10 1e10 8e1
(0)
ci = c∗i + 1e1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗k 2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e3 2e-1 4 2e-10 6e-15
5 1e4 1e-1 5 9e-12 8e-17
10 4e4 2e-1 6 2e-8 1e-14
15 1e5 2e-1 10 4e7 2e0
20 1e5 2e-1 10 1e7 7e-1
25 3e5 2e-1 10 9e8 1e1
30 4e5 2e-1 10 9e9 3e1
40 8e5 1e-1 10 5e8 5e0
50 1e6 1e-1 10 1e11 1e1
32
2.2. Método I (MI)
Friedland, Nocedal y Overton presentan en [FNO87] un método llamado
Method I (y habitualmente referenciado ası́ por otros autores) que resuelve el
caso aditivo del PIVP. En esta sección se utiliza la idea del Method I para
desarrollar un algoritmo tipo Newton: el Método I (MI), para resolver el PIAVS.
Por definición del PIAVS, si la descomposicion en valores singulares de la matriz
A(c) (ecuacion (2.1)) es A(c) = P (c)diag(S(c))Q(c)t , se requiere encontrar un c
tal que Si∗ −Si (c) = 0, para i = 1, n (Si∗ valor singular dado, Si (c) valor singular
de A(c)). De aquı́ se puede definir la función
F (c) = [Fi (c)]i=1,n = [Si (c) − Si∗ ]i=1,n
que da lugar al problema de resolver el sistema de ecuaciones no lineales
F (c) = [Si (c) − Si∗ ]i=1,n = 0. (2.16)
para el que se utiliza el método de Newton que, como se vió en 2.1, consiste en
calcular una sucesión de aproximaciones a la solución de (2.16), de modo que si
c(k) es el último elemento de la sucesión, para calcular el siguiente se resuelve

J(c(k) ) c(k+1) − c(k) = −F (c(k) ),
siendo J(c(k) ) la matriz jacobiana de F (c) evaluado en c(k) [DS83][Kel95].

También se sabe que J(c) tiene la forma

∂Fi (c)
J(c) = ,
∂cj i,j=1,n
y si se define S ≡ S(c), J ≡ J(c) y F ≡ F (c), se tiene que

∂Fi
J= ,
∂cj i,j=1,n
donde
∂Fi ∂Si ∂Si∗
= − , i, j = 1, n.
∂cj ∂cj ∂cj
De la descomposición en valores singulares de A(c), y siendo A ≡ A(c),
S ≡ S(c), P ≡ P (c), Q ≡ Q(c), se tiene que
P t AQ = diag(S) ⇒ pti Aqi = Si , i, j = 1, n
∂Si ∂pt Aqi ∂pt ∂A ∂qi

⇒ = i = i Aqi + pti qi + pti A , i, j = 1, n,
∂cj ∂cj ∂cj ∂cj ∂cj
y también que
P t A = diag(S)Qt y AQ = P diag(S),
33
por lo que
∂Si ∂pt ∂A ∂qi

= i pi Si + pti qi + Si qit i, j = 1, n.
∂cj ∂cj ∂cj ∂cj
Como P y Q son ortogonales

 
p t p = 1 (p )2 + · · · + (p )2 = 1
i i i 1 i m
⇒
q t q i = 1 (qi )2 + · · · + (qi )2 = 1
i 1 n

2(p ) ∂(pi )1 + · · · + 2(p ) ∂(pi )m = 0
i 1 ∂cj i m ∂cj
⇒
2(qi )1 ∂(qi )1 + · · · + 2(qi )n ∂(qi )n = 0
∂cj ∂cj
h i
 ∂(pi )1 · · · ∂(pi )m [(pi )1 · · · (pi )n ]t = 0
∂c ∂cj
⇒ h ∂(q j) ∂(qi )n
i
t
i 1
 ···
∂cj ∂cj [(qi )1 · · · (qi )n ] = 0
h i t
 ∂pi pi = 0
∂c
⇒ h j it i, j = 1, n
 ∂qi q = 0
∂cj i
entonces
∂Si ∂A
= pti qi =
∂cj ∂cj
∂(A0 + c1 A1 + · · · + cn An )
= pti qi =
∂cj
= pti Aj qi ; i, j = 1, n,
por lo que
∂Fi ∂Si ∂Si∗
= − = pti Aj qi − 0, para i, j = 1, n.
∂cj ∂cj ∂cj
Por lo tanto, la matriz jacobiana de F es

J = pti Aj qi i,j=1,n . (2.17)
Por otra parte,
F = [Si − Si∗ ]i=1,n = [pti Aqi − Si∗ ]i=1,n =
= [pti (AO + c1 A1 + · · · + cn An ) qi − Si∗ ]i=1,n =
= [pti A0 qi − Si∗ + pti c1 A1 qi + · · · + pti cn An qi ]i=1,n =
34
= [pti A0 qi − Si∗ ]i=1,n +
 
c1
 
 c2 
+ [pti A1 qi , pti A2 qi , · · · , pti An qi ]i=1,n 
 .. ,

 . 
cn
entonces

F = pti A0 qi − Si∗ i=1,n + Jc. (2.18)
De (2.17) y (2.18), el método de Newton queda como sigue

h i
(k)t (k)
J (k) c(k+1) − J (k) c(k) = − pi A0 qi − Si∗ − J (k) c(k) ,
i=1,n
es decir
J (k) c(k+1) = b(k) (2.19)
donde h i
(k)t (k)
b(k) = S ∗ − pi A0 qi . (2.20)
i=1,n
Como se ha aplicado el método de Newton, la convergencia de este algorit-

mo está sujeto a la selección de un punto inicial c(0) cercano a la solución c∗
[DS83] [Kel95].
2.2.1. Automatización del Método I

Para automatizar el Método I se han utilizado las estructuras de datos A i
(i = 0, n), S ∗ , c∗ , c, además de:

Pn
i=1 ci Ai , como P , los n vectores singulares izquierdos de A(c).

transpuestos derechos de A(c).
J matriz de tamaño n × n, almacena la matriz jacobiana de F (c) y

su descomposición lu.
AU X matriz de tamaño m×m, auxiliar en la realización de operaciones

requeridas en el método.
S vector de tamaño n, almacena los valores singulares de A(c).
b vector de tamaño n, almacena el vector de términos independi-

entes del sistema (2.19).
35
Tabla 2.8: Requerimiento de memoria de algoritmo MI
Ai=0,n 8.0e1 1.1e3 2.8e4 1.3e5 1.0e6 1.3e8 1.0e9
J, AoP, Qt 1.6e1 1.0e2 9.0e2 2.5e3 1.0e4 2.5e5 1.0e6
S ∗ , S, c∗ , c 4.0e0 1.0e1 3.0e1 5.0e1 1.0e2 5.0e2 1.0e3
Total
dobles 1.5e2 1.5e3 3.1e4 1.4e5 1.0e6 1.3e8 1.0e9
Memoria
requerida 1.2 Kb 12 Kb 250 Kb 1.1 Mb 8.3 Mb 1 Gb 8 Gb
m=n 4 10 30 50 100 500 1000
Algoritmo 2 Método I
A(0) = P (0) diag(S (0) )Q(0)t
3. Para k = 0,1,..., Mientras kS (k) − S ∗ k2 > tol
3.1. Calcular J (k) de acuerdo a (2.17)
3.2. Calcular b(k) de acuerdo a (2.20)
3.3. Calcular c(k+1) resolviendo el sistema J (k) c(k+1) = b(k)
3.3.1. Calcular descomposición lu de J (k)
3.3.2. Resolver los sistemas triangulares
L(k) x(k) = b(k)
U (k) c(k+1) = x(k)
3.4. Calcular A(k+1) de acuerdo a (2.1)
3.5. Calcular descomposición en valores singulares de A(k+1)
A(k+1) = P (k+1) diag(S (k+1) )Q(k+1)t
Estimando el monto de memoria necesario para manejar dobles en este al-

goritmo, se obtienen los resultados de la Tabla 2.8. Como era de esperarse, el
mayor monto se lo llevan las matrices A, Ai (i = 0, n) si se almacenan como
matrices densas.
Los pasos que sigue el Método I están en el algoritmo 2.
2.2.2. Pruebas Numéricas del Método I

Para el caso ChuBai se han obtenido los resultados de la Tabla 2.9, que
corresponden a los S ∗ esperados en todos los casos y a los c∗ esperados excepto
para las pruebas A y C del caso Bai; los errores con los que se da cuenta de
estos hechos están en la Tabla 2.10.
Se observan ahora los resultados de las pruebas Gral en la Tabla 2.11. Para
los casos m = n ≤ 10 no hay problemas de convergencia para los puntos iniciales
probados, no sucede ası́ para los casos de mayor tamaño, pues cuanto más
36
Tabla 2.9: Resultados del caso ChuBai con MI
A 4 -8.8571e-2 5.2995e0 7 1.6023e0 7.6932e0
5.1462e-1 3.3937e0 5.2371e-1 6.4255e0
-1.0132e0 2.2206e0 9.8096e0 3.8780e0
-8.8725e-1 1.0707e0 8.2035e-1 2.2199e0
B 6 2.3693e0 1.3414e1 4 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 4 8.8169e-1 6.9200e0 5 1.6635e0 1.0321e1
1.3168e0 5.1245e0 -1.1349e0 8.4827e0
-2.5081e-1 3.3331e0 2.2105e0 6.1540e0
-1.5865e-1 1.0240e0 6.6457e-1 1.8127e0
A -8.8571e-2 5.2995e0 1.2541e0 7.6932e0
5.1462e-1 3.3937e0 7.8632e-1 6.4255e0
-1.0132e0 2.2206e0 1.1208e0 3.8780e0
-8.8725e-1 1.0707e0 8.2783e-1 2.2199e0
B 2.3693e0 1.34141e0 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 8.8169e-1 6.9200e0 1.8505e0 1.0321e1
1.3168e0 5.1245e0 -1.4848e0 8.4827e0
-2.5081e-1 3.3331e0 2.0673e0 6.1540e0
-1.5865e-1 1.0240e0 -2.8719e-1 1.8127e0
Tabla 2.10: Errores del caso ChuBai con MI

kc∗ −c(k) k2 kS ∗ −S (k) k2
Pruebas Chu kc∗ − c(k) k2 kc∗ k
kS ∗ − S (k) k2 kS ∗ k2
2
A 1.6612e-08 1.15e-08 2.1301e-08 3.1516e-09
A 3.9907e-06 1.21e-06 4.0914e-07 2.4852e-08
C 2.5826e-11 1.60e-11 4.2425e-11 4.5667e-12
kc∗ −c(k) k2 kS ∗ −S (k) k2
Pruebas Bai kc∗ − c(k) k2 kc∗ k2
kS ∗ − S (k) k2 kS ∗ k2
A 4.5808e-01 2.26e-01 1.1960e-06 1.0898e-07
B 2.5623e-09 8.55e-10 2.1865e-09 1.4138e-10
C 1.0410e+00 3.30e-01 4.6388e-11 3.1300e-12
37
alejados estén de la solución, más casos van teniendo problemas de convergencia.
38
Tabla 2.11: Resultados y convergencia del caso Gral con MI
(0)
ci = c∗i + 1e − 1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e1 2e-3 2 3e-6 1e-10
5 1e2 1e-3 2 1e-7 2e-12
10 4e2 2e-3 2 2e-7 1e-12
15 1e3 2e-3 3 7e-11 1e-16
20 1e3 2e-3 3 6e-10 6e-16
25 3e3 2e-3 3 1e-9 8e-16
30 4e3 2e-3 3 9e-10 4e-16
40 8e3 1e-3 3 1e-0 2e-16
50 1e4 1e-3 3 1e-6 2e-13
(0)
ci = c∗i + 1e0 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e2 2e-2 3 1e-6 5e-11
5 1e3 1e-2 3 1e-9 1e-14
10 4e3 2e-2 3 1e-6 4e-12
15 1e4 2e-2 4 3e-8 8e-14
20 1e4 2e-2 5 2e-10 2e-16
25 3e4 2e-2 5 1e-6 8e-13
30 4e4 2e-2 4 2e-7 1e-13
40 8e4 1e-2 4 5e-10 1e-16
50 1e5 1e-2 10 2e6 3e-1
(0)
ci = c∗i + 1e1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗k 2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e3 2e-1 5 2e-10 1e-14
5 1e4 1e-1 4 1e-7 2e-12
10 4e4 2e-1 6 2e-11 1e-16
15 1e5 2e-1 10 2e7 3e1
20 1e5 2e-1 10 2e5 5e-1
25 3e5 2e-1 10 2e6 1e0
30 4e5 2e-1 10 2e8 7e1
40 8e5 1e-1 10 1e6 8e-1
50 1e6 1e-1 10 1e7 4e0
39
2.3. Método Elevación-Proyección (EP)
El método Elevación-Proyección para resolver el PIAVS se deriva de manera
similar a como lo hace el método Lift&Project propuesto por Chu [Chu98] y
Chen [CC96] para el caso aditivo del PIVP. El método consiste en definir los
conjuntos Γ(S ∗ ) y Λ(c), donde Γ(S ∗ ) es el conjunto de todas las matrices en
<m×n , m ≥ n, cuyos valores singulares son S ∗ = {S1∗ , S2∗ , ..., Sn∗ }
Γ(S ∗ ) = {P diag(S ∗ )Qt |P ∈ <m×n ortogonal, Q ∈ <n×n ortogonal} (2.21)
y Λ(c) es el conjunto de las matrices de la forma A(c) (ecuación (2.1))
Λ(c) = {A(c)|c ∈ <n }, (2.22)
con el propósito de encontrar la intersección de ambos a través de la mini-

mización de distancias, considerando que la distancia entre dos matrices U y V
está definida según dist(U, V ) = kU − V kF .
El método puede organizarse iterativamente en dos fases: la fase de elevación
y la fase de proyección. Para la iteración k, la fase de elevación consiste en,
dado un c(k) , y por consiguiente una A(c(k) ) ∈ Λ(c), encontrar un elemento
X (k) ∈ Γ(S ∗ ) tal que dist(A(c(k) ), X (k) ) = dist(A(c(k) ), Γ(S ∗ )); para ello es
suficiente con calcular la descomposición en valores singulares de A(k) ≡ A(c(k) )
A(k) = P (k) diag(S (k) )Q(k)t
para calcular la distancia más corta entre A(k) y Γ(S ∗ ), que se alcanza en el
punto [Bro91] [Chu92b]
X (k) = P (k) diag(S ∗ )Q(k)t .
La fase de proyección consiste en, dado un X (k) ∈ Γ(S ∗ ), encontrar c(k+1) , y

por lo tanto A(k+1) ∈ Λ(c), tal que dist(X (k) , A(k+1) ) = dist(X (k) , Λ(c)). Esto
se hace encontrando c(k+1) que minimice dist(X (k) , A(k+1) ), es decir, si se define
F (k+1) ≡ F (c(k+1) ) = kA(k+1) − P (k) diag(S ∗ )Qt(k) k2F , (2.23)
se tiene que resolver el siguiente problema de mı́nimos cuadrados no lineales
minF (k+1) = min kA(k+1) − P (k) diag(S ∗ )Qt(k) k2F . (2.24)

c(k+1)
La resolución se lleva a cabo igualando el gradiente de F (k+1) a cero y

resolviendo el sistema de ecuaciones lineales resultante
∇F (k+1) = ∇kA(k+1) − P (k) diag(S ∗ )Qt(k) k2F = 0. (2.25)
40
El gradiente de F (k+1) se desarrolla como sigue. De la función (2.23) se
tiene que
F (k+1) = kA(k+1) − P (k) diag(S ∗ )Q(k)t k2F =

r !2
t t

= tr A(k+1) − P (k) diag(S ∗ )Q(k)t A(k+1) − P (k) diag(S ∗ )Q(k) =
h ih i
= tr A(k+1)t − Q(k) diag(S ∗ )P (k)t A(k+1) − P (k) diag(S ∗ )Q(k)t =
= tr(A(k+1)t A(k+1) − A(k+1)t P (k) diag(S ∗ )Q(k)t −

− Q(k) diag(S ∗ )P (k)t A(k+1) + Q(k) diag(S ∗ )P (k)t P (k) diag(S ∗ )Q(k)t ) =

= tr A(k+1)t A(k+1) − tr A(k+1)t P (k) diag(S ∗ )Q(k)t −

− tr Q(k) diag(S ∗ )P (k)t A(k+1) + tr Q(k) diag(S ∗ )P (k)t P (k) diag(S ∗ )Q(k)t ;

= tr A(k+1)t A(k+1) − 2tr A(k+1)t P (k) diag(S ∗ )Q(k)t +

+ tr Q(k) diag(S ∗ )P (k)t P (k) diag(S ∗ )Q(k)t =
= ϕ1 − 2ϕ2 + ϕ3 ,
donde

ϕ1 = tr A(k+1)t A(k+1)

ϕ2 = 2tr A(k+1)t P (k) diag(S ∗ )Q(k)t

ϕ3 = tr Q(k) diag(S ∗ )P (k)t P (k) diag(S ∗ )Q(k)t ;
con esto, la ecuación (2.25) se puede escribir como sigue
∇F (k+1) = ∇ϕ1 − 2∇ϕ2 + ∇ϕ3 = 0. (2.26)
Desarrollando y calculando los gradientes de ϕ1 , ϕ2 y ϕ3 , se tiene que

ϕ1 = tr A(k+1)t A(k+1) =
t
Pn (k+1) Pn (k+1)
= tr A0 + i=1 ci Ai A0 + i=1 ci Ai =
Pn (k+1) t Pn (k+1)
= tr At0 + i=1 ci Ai A0 + i=1 ci Ai =
Pn (k+1) t Pn (k+1) t
= tr(At0 A0 + i=1 ci A0 Ai + i=1 ci Ai A0 +
Pn Pn (k+1) t (k+1)
+ i=1 j=1 ci Ai cj Aj ) =
41
Pn (k+1)
= tr (At0 A0 ) + 2 i=1 ci tr (At0 Ai ) +
Pn Pn (k+1) (k+1)
+ i=1 j=1 ci cj tr (Ati Aj ),
h i
∂ϕ1
∇ϕ1 = (k+1) =
∂cr r=1,n
Pn (k+1)
= [0 + 2tr (At0 Ar ) + i=1 ci tr (Ati Ar ) +
Pn (k+1)
+ i=1 ci tr (Atr Ai )]r=1,n =
h Pn (k+1) i
= 2tr (At0 Ar ) + 2 i=1 ci tr (Ati Ar ) ;
r=1,n

ϕ2 = 2tr A(k+1)t P (k) diag(S ∗ )Q(k)t =
Pn
(k+1) t
= 2tr At0 + i=1 ci Ai P (k) diag(S ∗ )Q(k)t =
P
n (k+1) t (k)
= 2tr At0 P (k) diag(S ∗ )Q(k)t + 2tr i=1 ci Ai P diag(S ∗ )Q(k)t =
Pn (k+1)
= 2tr At0 P (k) diag(S ∗ )Q(k)t + 2 i=1 ci tr Ati P (k) diag(S ∗ )Q(k)t ,
h i
∂ϕ2
∇ϕ2 = (k+1) = 0 + 2tr Atr P (k) diag(S ∗ )Q(k)t r=1,n ;
∂cr r=1,n
h i
∂ϕ3
∇ϕ3 = (k+1) = 0.
∂cr r=1,n
De los resultados anteriores, la ecuación (2.26) tiene la siguiente forma:
" n
#
X
(k+1) (k+1)
∇F = 2tr Atr A0 +2 ci tr Ati Ar − 2tr Atr P (k) diag(S ∗ )Q(k)t
i=1 r=1,n
=0
entonces
" n
#
X h i
(k+1)
ci tr Ati Ar = tr Atr P (k) diag(S ∗ )Q(k)t − tr Atr A0
r=1,n
i=1 r=1,n
h i
⇒ tr Ati Ar r,i=1,n [c]i=1,n = tr Atr P (k) diag(S ∗ )Q(k)t − A0 ;
r=1,n
(2.27)
42
ahora, si se define

Atr = tr Ati Ar r,i=1,n (2.28)
y
h i h i
btr = tr Atr P (k) diag(S ∗ )Q(k)t − A0 = tr Atr X (k) − A0
r=1,n r=1,n
(2.29)
(2.27) se escribe como
(k)
Atr c(k+1) = btr , (2.30)
que es el sistema de ecuaciones lineales que da solución al problema de mı́nimos

cuadrados (2.24). Se observa que la matriz Atr no depende del valor de c(k+1)
en las diferentes iteraciones, entonces se puede calcular una sóla vez antes de
empezarlas.
Con lo ya visto, se puede construir el algoritmo iterativo Elevación-Proyección
para resolver el PIAVS que converja a un punto estacionario del problema de
minimización definido, en el sentido de que
kA(k+1) − X (k+1) kF ≤ kA(k) − X (k) kF ; (2.31)
es decir, en la k-ésima fase de proyección, se calcula c(k+1) que minimice kA(k+1) −

X (k) kF , entonces
kA(k+1) − X (k) kF ≤ kA(k) − X (k) kF .
Por otra parte, en la (k+1)ésima fase de elevación las matrices que minimizan
kA(k+1) − X (k+1) kF son P (k+1) y Q(k+1) , entonces
kA(k+1) − P (k+1) diag(S∗)Q(k+1)t kF ≤ kA(k+1) − P (k) diag(S ∗ )Q(k)t kF ,
por lo que
kA(k+1) − X (k+1) kF ≤ kA(k+1) − X (k) kF .
2.3.1. Algoritmo secuencial Elevación-Proyección

Elevación-Proyección utiliza las siguientes estructuras de datos en su autom-
atización: Ai (i = 0, n), S ∗ , c∗ , c, además de:

Pn
i=1 ci Ai , como P, los n vectores singulares izquierdos de A(c).

transpuestos derechos de A(c).
Atr matriz de tamaño n × n, almacena los coeficientes del sistema

(2.30).
43
Tabla 2.12: Requerimiento de memoria de EP

A − i = 0, n 8.0e+01 1.1e+03 2.8e+04 1.3e+05 1.0e+06 1.3e+08 1.0e+09
A o P, Q, Atr 1.6e+01 1.0e+02 9.0e+02 2.5e+03 1.0e+04 2.5e+05 1.0e+06
S ∗ , S, c∗ , c, btr 4.0e+00 1.0e+01 3.0e+01 5.0e+01 1.0e+02 5.0e+02 1.0e+03
Total
dobles 1.5e+02 1.5e+03 3.1e+04 1.4e+05 1.0e+06 1.3e+08 1.0e+09
Memoria
requerida 1.2 Kb 12 Kb 250 Kb 1.1 Mb 8.3 Mb 1 Gb 8 Gb
m=n 4 10 30 50 100 500 1000

requeridas en el método, también almacena el vector de términos
independientes del sistema (2.30).
S vector de tamaño n, almacena los valores singulares de A(c) y los

valores de c(k−1) cuando se está en la iteración k.
Si las estructuras de datos anteriores almacenan dobles, el monto de memoria

necesario para almacenarlos, en diferentes tamaños de problema, se registra en
la Tabla 2.12.
Las dos fases de EP se presentan en el algoritmo 3. Aprovechando que Atr
es independiente de c(k) , se calcula una sola vez antes de entrar al ciclo (paso 1
del algoritmo), lo mismo que su inversa (paso 2), con el fin de que el cálculo de
la nueva solución c(k+1) no requiera de resolver el sistema de ecuaciones lineales
(k)
Atr c(k+1) = btr ,
sino solamente realizar una multiplicación matriz-vector, es decir,

(k)
c(k+1) = inversa(Atr )btr ,
como en el paso 4.5.
2.3.2. Pruebas Numéricas de Elevación-Proyección

Los resultados que da Elevación-Proyección en el caso ChuBai están en la
Tabla 2.13. Se observa convergencia en todos los casos (ver kc(k) − c(k−1) k2 en
Tabla 2.14), sin embargo lo hace después de un alto número de iteraciones y
los valores singulares alcanzados tienen, en el peor de los casos, una exactitud
de 1e-3. En el caso C de Bai, c(k) no aproxima a c∗ , sino que representa una
solución diferente con la que alcanzar los valores singulares S ∗ .
Ahora se prueban los casos del tipo Gral, utilizando los mismos c(0) que en
FB y MI, los resultados de la Tabla 2.15 indican que LP converge en todos
44
Tabla 2.13: Resultados del caso ChuBai con EP
A 901 -8.8371e-2 5.2994e0 1080 1.2533e0 7.6933e0
5.1430e-1 3.3936e0 7.8646e-1 6.4254e0
-1.0125e0 2.2208e0 1.1214e0 3.8781e0
-8.8843e-1 1.0710e0 8.2787e-1 2.2201e0
B 4339 2.3670e0 1.3414e1 202 2.6313e0 1.2159e1
1.6615e0 8.0737e0 1.2748e0 8.3927e0
-1.2933e0 5.0769e0 5.7296e-1 3.8462e0
-9.2641e-1 3.8932e-1 -3.5816e-1 2.4688e0
C 115 8.8174e-1 6.9200e0 1947 1.6635e0 1.0321e1
1.3168e0 5.1246e0 -1.1331e0 8.4828e0
-2.5084e-1 3.3331e0 2.2105e0 6.1541e0
-1.5863e-1 1.0239e0 6.6644e-1 1.8131e0
A -8.8571e-2 5.2995e0 1.2541e0 7.6932e0
5.1462e-1 3.3937e0 7.8632e-1 6.4255e0
-1.0132e0 2.2206e0 1.1208e0 3.8780e0
-8.8725e-1 1.0707e0 8.2783e-1 2.2199e0
B 2.3693e0 1.34141e0 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 8.8169e-1 6.9200e0 1.8505e0 1.0321e1
1.3168e0 5.1245e0 -1.4848e0 8.4827e0
-2.5081e-1 3.3331e0 2.0673e0 6.1540e0
-1.5865e-1 1.0240e0 -2.8719e-1 1.8127e0
Tabla 2.14: Errores del caso ChuBai con EP
kc∗ −c(k) k2 kS ∗ −S (k) k2

Pruebas Chu kc(k) − c(k−1) k2 kc∗ − c(k) k2 kc∗ k2
kS ∗ − S (k) k2 kS ∗ k2
A 4.9989e-6 1.4363e-3 9.9438e-4 3.3574e-4 4.9676e-5
B 4.9987e-6 1.6024e-2 4.8499e-3 1.0727e-3 6.5156e-5
C 4.9991e-6 7.5861e-5 4.7052e-5 6.3992e-5 6.8882e-6
kc∗ −c(k) k2 kS ∗ −S (k) k2
Pruebas Bai kc(k) − c(k−1) k2 kc∗ − c(k) k2 kc∗ k2
kS ∗ − S (k) k2 kS ∗ k2
A 4.9794e-6 9.8487e-4 4.8447e-4 2.6098e-4 2.3781e-5
B 4.9336e-6 1.2155e-4 4.0504e-5 7.7979e-5 5.0423e-6
C 4.9934e-6 1.0434e0 3.3018e-1 4.5603e-4 3.0771e-5
45
Algoritmo 3 Elevación-Proyección
1. Calcular Atr de acuerdo a (2.28)
2. Calcular inversa de Atr
3. parar ← F ALSO
4. Para k = 0,1,..., Mientras N O parar
4.1. Calcular A(k) de acuerdo a (2.1)
4.2. Calcular descomposición en valores singulares de A(k)
A(k) = P (k) diag(S (k) )Q(k)t
4.3. X ← P (k) diag(S ∗ )Q(k)t
(k)
(k)
4.4. Calcular btr de acuerdo a (2.29)
(k)
4.5. Calcular c(k+1) resolviendo el sistema Atr c(k+1) = btr
c(k+1) ← inversa(Atr ) ∗ btr
4.6. error ← kc(k+1) − c(k) k2
4.7. Si error < tol entonces parar ← V ERDADERO
los casos, incluso en aquellos donde FB y MI no lo hacen. Lo errores de estas

pruebas están en la Tabla 2.16.
En cuanto a la calidad de los resultados, si la medimos con respecto a los
(k) ∗
errores relativos kS kS−S
∗k
2
k2
, éstos son aceptables.
Por los resultados vistos, se puede concluir que Elevación-Proyección siempre
converge en el sentido (2.31); sin embargo, la calidad de S (k) , con respecto al
error absoluto kS (k) − S ∗ k2 , se ve afectada cuando m se incrementa y c(0) se
aleja de c∗ .
46
Tabla 2.15: Resultados del caso Gral con EP
(0)
ci = c∗i + 1e − 1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e1 2e-3 365 3e-3 1e-7
5 1e2 1e-3 206 3e-3 4e-8
10 4e2 2e-3 561 1e-2 6e-8
15 1e3 2e-3 3398 8e-2 1e-7
20 1e3 2e-3 2629 1e-1 1e-7
25 3e3 2e-3 1998 2e-1 1e-7
30 4e3 2e-3 4048 2e-1 1e-7
40 8e3 1e-3 6304 2e-1 6e-8
50 1e4 1e-3 5303 4e-1 6e-8
(0)
ci = c∗i + 1e0 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e2 2e-2 541 3e-3 1e-7
5 1e3 1e-2 298 3e-3 5e-8
10 4e3 2e-2 829 9e-2 4e-7
15 1e4 2e-2 9107 9e-2 2e-7
20 1e4 2e-2 10944 1e-1 1e-7
25 3e4 2e-2 44409 4e-1 2e-7
30 4e4 2e-2 17584 9e-1 4e-7
40 8e4 1e-2 20959 5e-1 1e-7
50 1e5 1e-2 17542 7e-1 1e-7
(0)
ci = c∗i + 1e1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗k 2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e3 2e-1 661 3e-3 1e-7
5 1e4 1e-1 433 4e-3 6e-8
10 4e4 2e-1 44240 1e-1 5e-7
15 1e5 2e-1 13965 9e-2 2e-7
20 1e5 2e-1 36697 9e1 9e-5
25 3e5 2e-1 86799 7e-1 5e-7
30 4e5 2e-1 674557 2e0 1e-6
40 8e5 1e-1 51290 6e-1 1e-7
50 1e6 1e-1 126822 1e2 1e-5
47
Tabla 2.16: Convergencia de EP para el caso Gral
Errores kc(k) − c(k−1) k2
(0) (0) (0)
m=n ci = c∗i + 1e − 1 ci = c∗i + 1e0 ci = c∗i + 1e1
4 4e-6 4e-6 4e-6
5 4e-6 4e-6 4e-6
10 4e-6 4e-6 5e-6
15 5e-6 5e-6 5e-6
20 5e-6 5e-6 5e-6
25 5e-6 5e-6 5e-6
30 5e-6 5e-6 5e-6
40 5e-6 5e-6 5e-6
50 5e-6 5e-6 5e-6
48
2.4. Método III (MIII)
En [Chu92a], Chu presenta un método para resolver el PIAVS, basado en
el Method III que Friedland Nocedal y Overton dan en [FNO87] para resolver
el caso aditivo del PIVP, y que en esta sección se automatiza en el algoritmo
llamado Método III (MIII).
La idea de MIII, al igual que EP, es encontrar la intersección entre los con-
juntos Γ(S ∗ ) y Λ(c), definidos en (2.21) y (2.22), respectivamente, con el fin
de encontrar el c tal que los valores singulares de A(c) de la ecuación (2.1)
sean S ∗ ; pero, a diferencia de EP, que aplica técnicas de mı́nimos cuadrados
para calcular tal intersección, MIII lo hace a través de un método iterativo tipo
Newton. Se denota con k a la k-ésima iteración del método y se definen dos
problemas:
Problema 1. Dada X (k) ∈ Γ(S ∗ ) encontrar una A(c(k+1) ) ∈ Λ(c)

tal que P (k)t A(c(k+1) )Q(k) = diag(S ∗ ).
Problema 2. Dada A(c(k+1) ) ∈ Λ encontrar X (k+1) ∈ Γ(S ∗ ), tal

que X (k+1) = A(c(k+1) ).
Para resolver el primer problema, como se tiene X (k) ∈ Γ(S ∗ ) dada, entonces
existen matrices P (k) y Q(k) tales que
X (k) = P (k) diag(S ∗ )Q(k)t (2.32)
o bien
diag(S ∗ ) = P (k)t X (k) Q(k) . (2.33)
Por otra parte, se puede probar que la tangente a Γ(S ∗ ) en X (k) es de la
forma [Chu92a] [BMX03]
X (k) + X (k) L(k) − H (k) X (k) (2.34)
donde L(k) y H (k) son matrices hemisimétricas.

Para calcular el punto A(c(k+1) ) por donde pasa la tangente (2.34), se
resuelve el sistema 2
X (k) + X (k) L(k) − H (k) X (k) = A(c(k+1) ) (2.35)
que tiene como incógnitas las matrices H (k) , L(k) y el vector c(k+1) , y que por
(2.32) se puede escribir como

P (k)t P (k) diag(S ∗ )Q(k)t + P (k) diag(S ∗ )Q(k)t L(k) −

−H (k) P (k) diag(S ∗ )Q(k)t Q(k) = P (k)t A(c(k+1) )Q(k) ,
2 El PIAVS requiere de P (k+1)t A(c(k+1) )Q(k+1) = diag(S ∗ ). Suponer que P (k+1) y Q(k+1)
(k) (k)
se aproximan con P (k) eH y Q(k) eL (con H (k) y L(k) hemisimétricas) respectivamente.
49
es decir
diag(S ∗ ) + diag(S ∗ )Q(k)t L(k) Q(k) − P (k)t H (k) P (k) diag(S ∗ ) =

P (k)t A(c(k+1) )Q(k) ,
y si se definen
L̃(k) = Q(k)t L(k) Q(k) ,
H̃ (k) = P (k)t H (k) P (k)
y
W (k) = P (k)t A(c(k+1) )Q(k) , (2.36)
finalmente puede expresarse como el sistema
diag(S ∗ ) + diag(S ∗ )L̃(k) − H̃ (k) diag(S ∗ ) = W (k) . (2.37)
De la diagonal de (2.37), se obtiene el sistema lineal
J (k) c(k+1) = b(k) (2.38)
3
donde
(k) (k)t (k)
Ji,j = pi Aj qi i = 1, n; j = 1, l
(k) (k)t (k)

bi = Si∗ − pi A0 qi i = 1, n
con el que se calcula c(k+1) y por lo tanto A(c(k+1) ) y por lo tanto W (k) .
De los elementos fuera de la diagonal de (2.37) se calculan H̃ (k) y L̃(k)
(k)
(k) (k) Wi,j
H̃i,j = −H̃j,i =− ∗ , i = n + 1, m; j = 1, n. (2.39)
Sj
Entonces
(k) (k)
e−H P (k)t A(c(k+1) )Q(k) eL = diag(S ∗ )
(k) (k)
⇒P (k)t A(c(k+1) )Q(k) = eH diag(S ∗ )e−L
! !
H (k) H (k)2 L(k) L(k)2
⇒P (k)t A(c(k+1) )Q(k) = I+ + + ··· diag(S ∗ ) I− + + ···
1 2 1 2
⇒P (k)t A(c(k+1) )Q(k) ≈ diag(S ∗ ) + H (k) diag(S ∗ ) − diag(S ∗ )L(k) =

= P (k)t P (k) diag(S ∗ )Q(k)t Q(k) + H (k) P (k)t P (k) diag(S ∗ )Q(k)t Q(k) − P (k)t P (k) diag(S ∗ )Q(k)t Q(k)L(k)
⇒P (k)t A(c(k+1) )Q(k) ≈ P (k)t X (k) Q(k) + H (k) P (k)t X (k) Q(k) − P (k)t diag(S ∗ )Q(k) L(k)
⇒A(c(k+1) ) ≈ X (k) + P (k) H (k) P (k)t X (k) − X (k) Q(k) L(k) Q(k)t
⇒A(c(k+1) ) ≈ X (k) + H̃ (k) X (k) − X (k) L̃(k)
3J y b son iguales que en MI
50
(k) (k)
(k) (k) Si∗ Wj,i + Sj∗ Wi,j
H̃i,j = −H̃j,i = , i = 1, n; j = i + 1, n; (2.40)
Si∗2 − Sj∗2
(k) (k)
(k) (k) Si∗ Wi,j + Sj∗ Wj,i
L̃i,j = −L̃j,i = , i = 1, n; j = i + 1, n. (2.41)
Si∗2 − Sj∗2
Se pueden ahora calcular
L(k) = Q(k) L̃(k) Q(k)t
y
H (k) = P (k) H̃ (k) P (k)t
con lo que el sistema (2.35) ha quedado resuelto, y con él el primer problema.
Hay que notar que no es necesario calcular los denominadores de (2.40) y (2.41)
en cada iteración, por lo tanto, se puede definir la matriz

deno = Si∗2 − Sj∗2 i,j=1,n;excepto i=j (2.42)
para calcularlos una sóla vez.

Para resolver el segundo problema que consiste en dada A(c(k+1) ) calcu-
lar X (k+1) , que equivale a calcular P (k+1) y Q(k+1) , se necesita encontrar la
intersección entre Λ(c) y Γ(S ∗ ). Suponiendo que
X (k+1) ≈ A(c(k+1) )
4
y como
(k) (k)
A(c(k+1) ) ≈ e−H X (k) eL
4 Se tiene que
(k) (k)
P (k)t A(c(k+1) )Q(k) = eH diag(S ∗ )e−L
(k) (k) (k) (k)
⇒A(c(k+1) ) = P (k) eH diag(S ∗ )e−L Q(k)t ⇒ A(c(k+1) ) = e−H P (k)t diag(S ∗ )Q(k) eL .
También se sabe que
L2
„ «
L
eL = I+ + + ···
1 2
y
H2
„ «
H
e−H = I− + − ···
1 2
entonces
H2 L2
„ « „ «
(k) (k) H L
e−H X (k) eL = I− + − ··· X (k) I+ + + ···
1 2 1 2
por lo que
(k) (k)
e−H X (k) eL ≈ X (k) − H (k) X (k) + X (k) L(k)
que es tangente a Γ(S ∗ ) en X (k) . Como la intersección de la tangente con A(c(k+1) ) es
X (k) − H (k) X (k) + X (k) L(k) = A(c(k+1) ), entonces
(k) (k)
e−H X (k) eL ≈ A(c(k+1) ).
51
entonces
(k) (k)
X (k+1) ≈ e−H X (k) eL . (2.43)
(k) (k)
Como e−H y eL son costosas de calcular, en su lugar se utiliza (de
manera similar al Method III para el PIVP) la transformación de Cayley para
aproximarlas a través de las matrices ortogonales
−1
H (k) H (k)
R(k) = I+ I−
2 2
y
−1
(k) L(k) L(k)
T = I+ I−
2 2
teniendo, en lugar de (2.43), la siguiente expresión
X (k+1) ≈ R(k)t X (k) T (k) = R(k)t P (k) diag(S ∗ )Q(k)t T (k)

⇒P (k+1) diag(S ∗ )Q(k+1)t ≈ R(k)t P (k) diag(S ∗ )Q(k)t T (k)

P (k+1) = R(k)t P (k)
⇒
Q(k+1)t = Q(k)t T (k)
 −t t
P (k+1) = I − H (k) I + H2
(k)
P (k)
2
⇒ −1
Q(k+1)t = Q(k)t I + L(k) I − L2
(k)
2
 t
 I − H (k) P (k+1) = I + H (k)t P (k)
2 2
⇒
Q(k+1)t I − L(k) = Q(k)t I + L(k)
2 2
 (k)
(k)

H
 I+
2 P (k+1) = I − H2 P (k)
⇒ (k)
t (k)t

L
 I−
2 Q(k+1) = I + L 2 Q(k) .
Entonces, para calcular P (k+1) y Q(k+1) basta con resolver los sistemas de
ecuaciones
H (k) (k+1) H (k)
I+ P = I− P (k) (2.44)
2 2

L(k) (k+1) L(k)
I+ Q = I− Q(k) (2.45)
2 2
con lo que queda resuelto el segundo problema.
De acuerdo a [Chu92a] y [CBM03] este método es cuadráticamente conver-
gente. A diferencia de los métodos desarrollados en las secciones anteriores, este
método aproxima en cada iteración los vectores singulares P (k+1) y Q(k+1) , en
lugar de calcularlos exactamente.
52
2.4.1. Algoritmo Secuencial del Método III
La cantidad de estructuras de datos que requiere este algoritmo se incremen-
ta por el uso de las matrices hemi-simétricas involucradas, a diferencia de los
algoritmos anteriores, teniendo que definir las siguientes: Ai (i = 0, n), S ∗ , c∗ ,
c, además de:
A o W matriz de tamaño m × n, almacena tanto la matriz A(c) = A0 +

Pn t
i=1 ci Ai , como la matriz W = P A(c)Q.
P matriz de tamaño m × m, almacena P , los m vectores singulares

izquierdos de A(c).
Q matriz de tamaño n × n, almacena Q, los n vectores singulares

derechos de A(c).
J matriz de tamaño n × n, almacena los coeficientes del sistema

(2.38).
H matriz de tamaño m × m, almacena las matrices H̃ y H.
L matriz de tamaño n × n, almacena las matrices L̃ y L.
deno matriz de tamaño n × n, almacena los denominadores de H̃ y L̃.

requeridas en el método.
sb vector de tamaño n, almacena los valores singulares de A(c) y los

términos independientes del sistema (2.38).
El monto de memoria requerida, para diferentes tamaños de m = n se pre-

senta en la Tabla 2.17. Estas cantidades pueden manejarse sin problemas para
m ≤ 100.
El algoritmo secuencial de este método está en el Algoritmo 4.
53
Tabla 2.17: Requerimiento de memoria de MIII

Ai=0,n 8.0e+01 1.1e+03 2.8e+04 1.3e+05 1.0e+06 1.3e+08 1.0E+09
A o W, P, Q
J, H, L 1.6e+01 1.0e+02 9.0e+02 2.5e+03 1.0e+04 2.5e+05 1.0E+06
S ∗ , Sb
c∗ , c 4.0e+00 1.0e+01 3.0e+01 5.0e+01 1.0e+02 5.0e+02 1.0E+03
Total
dobles 2.1e+02 1.8e+03 3.4e+04 1.5e+05 1.1e+06 1.3e+08 1.0E+09
Memoria
requerida 1.7 Kb 15 Kb 270 Kb 1.2 Mb 8.6 Mb 1 Gb 8.1 Gb
m=n 4 10 30 50 100 500 1000
Algoritmo 4 Método III

A(0) = P (0) diag(S (0) )Q(0)t 3. Calcular deno de acuerdo a (2.42)
4. Para k = 0,1,..., Mientras kP (k)t A(k) Q(k) − diag(S ∗ )kF > tol
4.2. Calcular b(k) de acuerdo a (2.20)
4.3. Calcular c(k+1) resolviendo el sistema J (k) c(k+1) = b(k)
4.4. Calcular A(k+1) de acuerdo a (2.1)
4.5. W (k) ← P (k)t A(k+1) Q(k)
4.6. Calcular H̃ (k) de acuerdo a (2.39)- (2.40)
4.7. Calcular L̃(k) de acuerdo a (2.41)
4.8. H (k) ← P (k) H̃ (k) P (k)t
4.9. L(k) ← Q(k) L̃(k) Q(k)t
4.10. Calcular
P (k+1)
resolviendo
el sistema

H (k) H (k)
I+ 2 P (k+1) = I − 2 P (k)
(k+1)
4.11. Calcular
Q resolviendo
el sistema

(k)
L (k+1) L(k)
I+ 2 Q = I − 2 Q(k)
2.4.2. Pruebas Numéricas del Método III

En la Tabla 2.18 están los resultados de MIII aplicado al caso ChuBai; las
pruebas A y C del caso Bai no alcanzan la solución c∗ , aunque sı́ alcanzan los
valores singulares deseados S ∗ , con los errores de la Tabla 2.19. Estas pruebas
no representan ningún problema de convergencia para MIII.
Véanse ahora los resultados de aplicar MIII al caso Gral en la Tabla 2.20
para diferentes puntos iniciales c(0) . Se observa que, en cuanto el punto inicial
se va alejando de c∗ , los casos de mayor tamaño dejan de converger. En la Tabla
54
Tabla 2.18: Resultados del caso ChuBai con MIII
casos k c(k) S (k) k c(k) S (k)
A 4 -8.8571e-2 5.2995e0 8 1.6308e0 7.6932e0
5.1462e-1 3.3937e0 4.6572e-1 6.4255e0
-1.0132e0 2.2206e0 9.9241e0 3.8780e0
-8.8725e-1 1.0707e0 7.9056e-1 2.2199e0
B 6 2.3693e0 1.3414e1 4 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 4 8.8169e-1 6.9200e0 7 1.6635e0 1.0321e1
1.3168e0 5.1245e0 -1.1349e0 8.4827e0
-2.5081e-1 3.3331e0 2.2105e0 6.1540e0
-1.5865e-1 1.0240e0 6.6457e-1 1.8127e0
A -8.8571e-2 5.2995e0 1.2541e0 7.6932e0
5.1462e-1 3.3937e0 7.8632e-1 6.4255e0
-1.0132e0 2.2206e0 1.1208e0 3.8780e0
-8.8725e-1 1.0707e0 8.2783e-1 2.2199e0
B 2.3693e0 1.34141e0 2.6314e0 1.2159e1
1.6524e0 8.0733e0 1.2748e0 8.3927e0
-1.3027e0 5.0761e0 5.7291e-1 3.8461e0
-9.3529e-1 3.8912e-1 -3.5826e-1 2.4688e0
C 8.8169e-1 6.9200e0 1.8505e0 1.0321e1
1.3168e0 5.1245e0 -1.4848e0 8.4827e0
-2.5081e-1 3.3331e0 2.0673e0 6.1540e0
-1.5865e-1 1.0240e0 -2.8719e-1 1.8127e0
Tabla 2.19: Errores de ChuBai con MIII
kc∗ −c(k) k2 kS ∗ −S (k) k2

Caso Chu |P (k)t A(k) Q(k) − S ∗ |F kc∗ − c(k) k2 kc∗ k2
kS ∗ − S (k) k2 kS ∗ k2
A 1e-7 6e-8 4e-8 5e-8 8e-9
B 4e-7 3e-6 9e-7 3e-7 1e-8
C 1e-7 5e-8 3e-8 8e-8 9e-9
kc∗ −c(k) k2 kS ∗ −S (k) k2
Caso Bai |P (k)t A(k) Q(k) − S ∗ |F kc∗ − c(k) k2 kc∗ k2
kS ∗ − S (k) k2 kS ∗ k2
A 1e-8 5e-1 2e-1 9e-9 8e-10
B 5e-8 1e-8 4e-9 2e-8 1e-9
C 1e-9 1e0 3e-1 1e-9 8e-11
55
2.21 se puede constatar este hecho a través de los errores alcanzados en el criterio
de parada del algoritmo.
Con MIII se concluye este capı́tulo donde se ha presentado el desarrollo
de cuatro algoritmos para la resolución del PIAVS: FB, MI, EP y MIII. Estos
cuatro algoritmos constituyen cuatro formas diferentes de encarar el PIAVS,
presentando caracterı́sticas propias con respecto a convergencia, exactitud y re-
querimientos de memoria. Para observar las dos primeras caracterı́sticas se han
realizado experimentos que indican que FB, MI y MIII, al ser algoritmos tipo
Newton, son sensibles al punto inicial dado, por lo que se consideran algoritmos
de convergencia local, mientras que EP se considera un algoritmo de convergen-
cia global en el sentido 2.31. Con respecto a la exactitud, se ha observado que
MIII alcanza mejores aproximaciones que el resto de los algoritmos, mientras
que EP es el menos exacto.
Por otra parte, los requerimientos de memoria se han estimado haciendo un
recuento de las estructuras de datos que cada algoritmo utiliza, considerando que
éstas almacenan flotantes de doble precisión. De acuerdo a estas estimaciones es
claro que FB es un algoritmo que demanda mucho almacenamiento, en contraste
con MI y EP que requieren relativamente poco almacenamiento.
Falta por analizar la complejidad de tiempo de ejecución que se presenta en
el siguiente capı́tulo para poder hacer una evaluación global de los métodos del
PIAVS.
56
Tabla 2.20: Resultados del caso Gral con MIII
(0)
ci = c∗i + 1e − 1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e1 2e-3 3 1e-11 3e-16
5 1e2 1e-3 2 1e-7 2e-12
10 4e2 2e-3 2 3e-7 1e-12
15 1e3 2e-3 3 9e-11 1e-16
20 1e3 2e-3 3 2e-10 2e-16
25 3e3 2e-3 3 1e-9 7e-16
30 4e3 2e-3 3 5e-10 2e-16
40 8e3 1e-3 3 1e-9 2e-16
50 1e4 1e-3 4 1e-9 3e-16
(0)
ci = c∗i + 1e0 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S ∗ k2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e2 2e-2 3 1e-6 3e-11
5 1e3 1e-2 3 8e-10 1e-14
10 4e3 2e-2 3 1e-6 7e-12
15 1e4 2e-2 4 8e-9 1e-14
20 1e4 2e-2 5 3e-10 3e-16
25 3e4 2e-2 5 7e-7 4e-13
30 4e4 2e-2 4 2e-7 1e-13
40 8e4 1e-2 4 1e-9 4e-16
50 1e5 1e-2 10 8e6 1e0
(0)
ci = c∗i + 1e1 (i = 1, m)
kS (0) −S ∗ k2 kS (k) −S ∗ k2
m=n kS (0) − S∗k 2 kS ∗ k2
k kS (k) − S ∗ k2 kS ∗ k2
4 8e3 2e-1 5 1e-11 3e-16
5 1e4 1e-1 4 2e-7 3e-12
10 4e4 2e-1 6 1e-8 8e-14
15 1e5 2e-1 10 1e+7 3e1
20 1e5 2e-1 10 3e+6 3e0
25 3e5 2e-1 10 7e+6 4e0
30 4e5 2e-1 10 1e+7 4e0
40 8e5 1e-1 10 1e+8 3e1
50 1e6 1e-1 10 4e+7 7e0
57
Tabla 2.21: Convergencia de MIII para el caso Gral
Errores |P (k)t A(k) Q(k) − S ∗ |F
(0) (0) (0)
m=n ci = c∗i + 1e − 1 ci = c∗i + 1e0 ci = c∗i + 1e1
4 6e-12 3e-6 2e-11
5 2e-7 1e-9 2e-7
10 6e-7 3e-6 3e-8
15 1e-10 4e-8 1e7
20 7e-10 2e-10 3e6
25 3e-9 2e-6 7e6
30 8e-10 2e-6 1e7
40 1e-9 1e-9 1e8
50 1e-9 1e7 4e7
58
Capı́tulo 3
Implementación, Análisis y
Evaluación de los
Algoritmos del PIAVS
En este capı́tulo se presentan los detalles de una implementación eficiente

de los algoritmos diseñados en el capı́tulo anterior, utilizando rutinas eficientes
y portables de BLAS y LAPACK. Por cada algoritmo presentado se estiman
los tiempos teóricos de ejecución para analizar los algoritmos desde este punto
de vista. Con esta implementación se realizan experimentos numéricos para
complementar los del capı́tulo anterior y dar paso al análisis y evaluación de
los algoritmos de acuerdo a: complejidad de tiempos de ejecución, convergencia,
exactitud y requerimientos de memoria.
Los experimentos numéricos para este capı́tulo se han realizado en un nodo
del cluster Kefren, sobre casos del tipo Gral para las dimensiones: 50 < m <
2000, 50 < n < 400, con puntos iniciales c(0) adecuados para garantizar la
convergencia de los algoritmos.
El capı́tulo comienza (Sección 3.1) con una descripción detallada de cada
una de las rutinas que utilizan los métodos FB, MI, EP y MIII, como son: el
cálculo de A(c), el cálculo de las matrices J, JF B, W , Atr, H, L, P y Q, y
el cálculo de los vectores b, btr, F y Z. En cada rutina se señalan las rutinas
BLAS y LAPACK que se invocan.
En la Sección 3.2 se presentan los algoritmos FB, MI, EP y MIII, en los
que se indican también las rutinas BLAS y LAPACK que utilizan. Por cada
algoritmo se estima su tiempo de ejecución secuencial teórico, con base en los
tiempos teóricos que se reportan en la literatura de las rutinas BLAS y LAPACK
y con base en los tiempos teóricos aproximados en este trabajo de las rutinas
descritas en la Sección 3.1.
59
En la última sección (Sección 3.3) se presentan el análisis y la evaluación
antedichos de los algoritmos.
3.1. Detalle de Operaciones de Algoritmos del

PIAVS
Hay pasos que todos los algoritmos realizan, como: el cálculo de A (de acuer-
do a (2.1)), la descomposición en valores singulares de una matriz (svd), la
resolución de sistemas de ecuaciones lineales y el cálculo de normas vectoria-
les (norma-2) o matriciales (norma-Frobenius). Todos estos pasos, excepto el
cálculo de A, están implementados eficientemente en LAPACK y BLAS:
dgesvd LAPACK descomposición en valores singulares de una matriz (svd)

dgesv LAPACK resolución de un sistema de ecuaciones lineales
dnrm2 BLAS norma-2 vectorial
dlange LAPACK norma-Frobenius matricial
Para calcular A se ha diseñado e implementado una rutina especı́fica uti-

lizando como base la rutina daxpy de BLAS (ver Algoritmo 5).
Algoritmo 5 CalculaA
1. A ← A0
2. Para i = 1,n
2.1. A ← daxpy(m ∗ n, ci , Ai )
Además de los pasos en común, se pueden implementar los pasos propios de

cada algoritmo, tales como el cálculo de:
b vector de términos independientes de MI y MIII, ec. (2.20)

J matriz jacobiana de MI, matriz de coefientes de MIII, ec. (2.17)
Atr matriz de coeficientes de EP (2.28)
btr vector de términos independientes de EP (2.29)
JF B matriz jacobiana de FB, ecs. (2.11)− (2.15)
F vector de FB, ecs. (2.7), (2.8), (2.9)
W matriz de MIII, ec. (2.36)
P yQ matrices de vectores singulares aproximados de MIII, ecs. (2.44), (2.45)
Z vector de FB, ec. (2.6)
LyH matrices hemisimétricas de MIII, ecs. (2.39), (2.40), (2.41),
utilizando las rutinas LAPACK y BLAS siguientes (α, β detona escalares; x, y

vectores y A, B, C matrices):
60
ddot BLAS xt y
dscal BLAS αx
daxpy BLAS αx + y
dgemv BLAS αAx + βy
dgemm BLAS αAB + βC
dgetri LAPACK A−1
Los algoritmos para calcular las matrices y vectores que se han listado arriba
se presentan del Algoritmo 6 al 20, indicando las rutinas BLAS y LAPACK
utilizadas.
En el primero de estos algoritmos, para calcular b, se requiere realizar n pro-
ductos matriz-vector (A0 qi ) y n productos escalares (pi A0 qi ). Esto es equivalente
a realizar un producto matriz-matriz (A0 Q) y n productos escalares (pi (A0 Q)i ),
que es más eficiente de implementar. Este proceder se ve en el Algoritmo 6 y se
repite n veces para calcular las n columnas de J en el Algoritmo 7.
Algoritmo 6 Calculab
1. { aux ← [A0 qi ]i=1,n }
aux ← dgemm(m, n, n, A0 , Q)
2. Para k = 1,n
2.1. bi ← ddot(m, pi , auxi )
3. { b ← b − S ∗ }
b ← daxpy(n, −1, S ∗, b)
4. { b ← sAster − b }
b ← dscal(n, −1, b)
Algoritmo 7 CalculaJ
1. Para k = 1,n
1.1 { aux ← [Ak qi ]i=1,n }
aux ← dgemm(m, n, n, Ak , Q)
1.2. Para i = 1,n
1.2.1. Ji,k ← ddot(m, pi , auxi )
Para calcular Atr no es necesario calcular la multiplicación matriz-matriz

Ati Ar ,
pues
 
n
X
t t
Atr = [tr(Ai Ar )]r,i=1,n =  (Ai )j (Ar )j  ,
j=1
r,i=1,n
de este modo es como se diseña el Algoritmo 8 y análogamente el Algoritmo 9

que calcula btr .
61
Algoritmo 8 CalculaAtr
1. Para i = 1,n
1.1. Para j = 1,i
1.1.1. Atri,j ← 0
1.1.2. Para k = 1,n
1.1.2.1. Atri,j ← Atri,j + ddot(m, (Aj )k , (Ai )k )
Algoritmo 9 Calculabtr
1. { P ← P S ∗ }
Para i = 1,n
1.1. P:,i ← dscal(m, Si∗ , P:,i )
2. aux ← A0
3. aux ← dgemm(m, n, n, P, Qt , −aux)
4. Para i=1,n
4.1. btri ← 0
4.2. Para k = 1,n
4.2.1. btri ← btri + ddot(m, Ai:,k , aux:,k )
Más que calcular la matriz Jacobiana del método FB es necesario construirla,

pues requiere de pocas operaciones aritméticas y de distribución y réplica de
datos en sus entradas . El Algoritmo 10, por lo tanto, consiste escencialmente
de asignaciones que se detallan en los Algoritmos del 11 al 15.
Algoritmo 10 CalculaJFB
1. ren ← 1
2. JF B1:n(n+1)/2,1:n2 ← CalculaJ11
3. ren ← n ∗ (n + 1)/2 + 1
4. JF Bn(n+1)/2+1:n(n+1),n2 +1:n2 +mn ← CalculaJ22
5. JF Bn(n+1):n(n+1)+mn,1:n2 ← CalculaJ31
6. col ← n ∗ n + 1
7. JF Bn(n+1):n(n+1)+mn,n2 +1:n2 +mn ← CalculaJ32
8. col ← n ∗ n + m ∗ n + 1
9. JF Bn(n+1):n(n+1)+mn,n2 +mn+1:n2 +mn+n ← CalculaJ33
62
Algoritmo 11 CalculaJ11
1. Para jj = 1,m
1.1. col ← jj
1.2. Para i = 1,m
1.2.1 JF Bren,col ← 2 ∗ Qi,jj
1.2.2. JF Bren+1:ren+n−jj,col ← Qi,jj+1:n
1.2.3. diag(JF Bren+1:ren+n−jj,col+1:col+n−jj ) ← Qi,jj
1.2.4. col ← col + n
1.3. ren ← ren + n − jj + 1
1. Para jj = 1,n
1.1. col ← n ∗ n + jj
1.2. Para i = 1,m
1.2.1. JF Bren,col ← 2 ∗ Pi,jj
1.2.2. JF Bren+1:ren+n−jj,col ← Pi,jj+1:n
1.2.3. diag(JF Bren+1:ren+n−jj,col+1:col+n−jj ) ← Pi,jj
1.2.4. col ← col + n
1.3. ren ← ren + n − jj + 1
1. Para i = 1,n
1.1. aux1:m,i ← dscal(m, −Si∗ , P1:m,i )
2. salvaren ← ren
3. Para i = 1,m
3.1. col ← 1
3.2. Para jj = 1,n
3.2.1. JF Bren,col:col+n−1 ← auxi,1:n
3.2.2. col ← col + n
3.2.3. ren ← ren + 1
1. Para i = 1,n
1.1. aux1:n,i ← dscal(n, −Si∗, Q1:n,i )
2. ren ← salvaren
3. Para i=1,m
3.1. JF Bren:ren+n−1,col:col+n−1 ← aux
3.2. ren ← ren + n
3.3. col ← col + n
63
1. Para i = 1,n
1.1. ren ← salvaren
1.2. Para jj = 1,m
1.2.1. JF Bren:ren+n−1,col ← Aijj,1:n
1.2.2. ren ← ren + n
1.3. col ← col + 1
Para calcular F se necesitan realizar multiplicaciones matriz-matriz escen-

cialmente: Qt Q − In , P t P − Im y A − P diag(S ∗ )Qt , distribuyendo los resultados
en forma vectorial en F , como en el Algoritmo 16.
Algoritmo 16 CalculaF
1. { aux ← Qt Q − In }
aux ← dgemm(n, n, n, Qt, Q, −In )
2. k ← 1
3. { Llena F1:n∗(n+1)/2 }
Para i = 1,n
3.1. Fk:k+n−i+1 ← auxi:n,i
3.2. k = k + n − i + 1
4. { aux ← P t P − Im }
aux ← dgemm(m, m, m, P t , P, −Im )
5. { Llena Fn∗(n+1)/2+1:n∗(n+1) }
Para i = 1,n
5.1. Fk:k+n−i+1 ← auxi:n,i
5.2. k ← k + n − i + 1
6. { aux ← P diag(S ∗ ) }
aux ← dgemm(m, n, n, P, diag(S ∗))
7. Calcular A
8. { A ← A − P diag(S ∗ )Qt }
A ← dgemm(m, n, n, −aux, Qt, A)
9. { Llena Fn∗(n+1)+1:mF }
Para i = 1,m
9.1. Fk:k+n ← Ai,1:n
9.2. k ← k + n
El Algoritmo 17 calcula tanto W como W t en aux, ya que ambas matrices se

utilizan para calcular las matrices hemisimétricas H̃ y L̃, que por estar definidas
como:
(k) (k)
(k) (k) Si∗ Wj,i + Sj∗ Wi,j
H̃i,j = −H̃j,i = , i = 1, n; j = i + 1, n;
Si∗2 − Sj∗2
64
(k) (k)
(k) (k) Si∗ Wi,j + Sj∗ Wj,i
L̃i,j = −L̃j,i = , i = 1, n; j = i + 1, n;
Si∗2 − Sj∗2
pueden expresarse como:
(k) t(k)
(k) (k) Si∗ Wj,i + Sj∗ Wj,i
H̃i,j = −H̃j,i = , i = 1, n; j = i + 1, n;
Si∗2 − Sj∗2
(k) t(k)
(k) (k) Si∗ Wi,j + Sj∗ Wi,j
L̃i,j = −L̃j,i = , i = 1, n; j = i + 1, n.
Si∗2 − Sj∗2
Algoritmo 17 CalculaW
1. W ← dgemm(m, n, m, P t , A)
2. A ← dgemm(m, n, n, W, Q)
3. W ←A
4. aux ← W t
El Algoritmo 18 que aproxima P (los vectores singulares izquierdos de A)

también se utiliza para aproximar Q (para los vectores singulares derechos de
A) sustituyendo P , P+ , H̃, H e Im por Q, Q+ , L̃, L e In , correspondientemente.
65
Algoritmo 18 AproximaP
1. { aux ← P H̃ }
aux ← dgemm(m, m, m, P, H)
2. { H ← −(1/2)P H̃P t }
H ← dgemm(m, m, m, −(1/2)aux, P t)
3. { H ← Im − (1/2)H }
Para i=1,m
Hi,i ← 1
4. { aux ← (Im − (1/2)H)P }
aux ← dgemm(m, m, m, H, P )
5. { P ← (Im − (1/2)H)P }
P ← aux
6. { aux ← Im − (1/2)H }
aux ← H
7. { aux ← −Im + (1/2)H }
aux ← dscal(m ∗ m, −1, aux)
8. { aux ← Im + (1/2)H }
Para i = 1,m
auxi,i ← 1
9. { Calcula ← lu(Im + (1/2)H) }
[L, U ] ← dgetrf (m, aux)
10. { Resuelve (Im + H2 )P+ = (Im − H2 )P }
P+ ← dgetrs(m, L, U, P )
Como sol = [Q1,1 , Q1,2 , ..., Qn,n , P1,1 , P1,2 , ..., Pm,n , c1 , c2 , ..., cn ] es el paso
calculado por el método de Newton y Z representa a P , Q y c, el Algoritmo 19
distribuye los componentes de sol para sumarlos en correspondencia con las
matrices P , Q y con el vector c.
Algoritmo 19 ActulizaZ
{ Z ← Z + sol }
1. Para i = 1,n
1.1. Qi,1:n ← daxpy(n, sol(i−1)n+1:in+1 , Qi,1:n )
2. Para i = 1,m
2.1. Pi,1:n ← daxpy(n, soln2 +(i−1)n+1:n2 +in+1 , Pi,1:n )
3. c ← daxpy(n, soln2 +mn+1:n2 +mn+n , c)
En el Algoritmo 20 se calculan tanto H como L para provechar que se han

calculado W y W t en aux. En el paso 1.1. y 1.3. se escalan las columnas de W
con S ∗ y 1/S ∗ , como se ilustra en la siguiente figura:
66
S1∗ S2∗ S3∗ S4∗ S5∗
↓ ↓ ↓ ↓ ↓
0 * * * *
* 0 * * *
* * 0 * *
* * * 0 *
H←
* * * * 0
× × × × ×
× × × × ×
↑ ↑ ↑ ↑ ↑
1/S1∗ 1/S2∗ 1/S3∗ 1/S4∗ 1/S5∗
W
Los pasos 2.1. y 2.3. del mismo algoritmo escalan con S ∗ y 1/S ∗ los renglores
de W t que está almacenada en aux y suma el resultado a la matriz H, como en
la siguiente figura:
S1∗ → 0 * * * * × × ← 1/S1∗
S2∗ → * 0 * * * × × ← 1/S2∗
S3∗ → * * 0 * * × × ← 1/S3∗
H ← H+ S4∗ → * * * 0 * × × ← 1/S4∗
S5∗ → * * * * 0 × × ← 1/S5∗
Wt
Por último, en el paso 3. se dividen los elementos H1:n,1:n por deno, que
tiene el resultado de las diferencias Si∗2 − Sj∗2 , para i = 1, n; j = 1, n.
67
Algoritmo 20 CalculaHL
1. Para j = 1,n
1.1. { Hi,j = −Hj,i ← Sj∗ Wi,j i = 1, n; j = i + 1, n }
H1:n,j ← daxpy(n, Sj∗ , W1:n,j )
1.2. { Li,j = −Lj,i ← Sj∗ Wj,i i = 1, n; j = i + 1, n }
L1:n,j ← daxpy(n, Sj∗ , aux1:n,j )
1.3. { Hi,j ← −Wj,i /Sj∗ i = n + 1, m; j = 1, n }
Hn+1:m,j ← daxpy(m − n, −1/sAsterj , Wn+1:m,j )
2. Para i = 1,n
2.1. { Hi,j = −Hj,i ← Sj∗ Wi,j + Si∗ Wj,i i = 1, n; j = i + 1, n }
Hi,1:n ← daxpy(n, Si∗ , auxi,1:n )
2.2 { Li,j = −Lj,i ← Sj∗ Wj,i + Si∗ Wi,j i = 1, n; j = i + 1, n }
Li,1:n ← daxpy(n, Si∗ , Wi,1:n )
2.3. { Hj,i (= −Hi,j ) ← −Wi,j /Sj∗ i = n + 1, m; j = 1, n }
∗
Hi,n+1:m ← daxpy(m − n, −1/Si , auxi,n+1:m )
3. Para i = 1,n
3.1. Para j = 1,n
3.1.1. Hi,j ← Hi,j /denoi,j
3.1.2. Li,j ← Li,j /denoi,j
4. diag(H), diag(L) ← 0
Con este algoritmo termina el detalle de las operaciones del PIAVS, lo que
da pie a expresar, también en detalle, los tiempos teóricos de ejecución de FB,
MI, EP y MIII, cuya complejidad de tiempo de ejecución se ha dado en la
Sección 3.3. Mientras tanto, en la siguiente sección se realizan experimentos
numéricos para complementar los realizados en el capı́tulo anterior.
3.2. Algoritmos del PIAVS y Tiempos de Eje-

cución Teóricos
Para estimar los tiempos teóricos de ejecución de los algoritmos del PIAVS,
se da una lista de los tiempos de ejecución las rutinas que se utilizan en ellos,
algunos se encuentran reportados en la literatura [DHvdV93], [BCC97] y otros
se han estimado por los autores de este trabajo:
68
rutina T (n)
ddot 2ntf
dscal ntf
daxpy 2ntf
dnrm2 (2n + 1)tf
dlange (2n2 + 1)tf
dgemv 2n2 tf
dgemm 2n3 tf
dgesv (2/3)n3 tf
dgesvd (38/3)n3 tf
CalcularA 2m3 tf
A continuación se presentan los algoritmos FB, MI, EP y MIII, señalando las
rutinas BLAS y LAPACK que se utilizan y los tiempos de ejecución estimados
(presentados en términos de orden mayor en la sección 3.3), donde k denota el
número de iteraciones que los algoritmos realizan para converger y t f el tiempo
que toma ejecutar una operación en punto flotante.
FB. Los tiempos de ejecución de los pasos 4.1., 4.4. y 4.5. del Algoritmo 21 son,
respectivamente:
TJF B (m, n) = (2mn + 2n2 )tf

TactualizaZ (m, n) = mn + n2 + n tf

TF (m, n) = 6mn2 + 2m3 + 2n3 tf .
Algoritmo 21 FB
1. A(0) ← CalculaA(c(0) , A0 , ..., An )
2. [P (0) , S (0) , Q(0) ] ← dgesvd(A(0) )
3. F (0) ← CalculaF(c(0) , A0 , ..., An , P (0) , S ∗ , Q(0) )
4. Para k = 0,1,..., Mientras dnrm2(F (k) ) > tol
4.1. JF B (k) ← CalculaJFB(S ∗ , A1 , ..., An , P (k) , Q(k) )
4.2. sol(k) ← dgesv(JF B (k) , −F (k) )
4.3. [c(k+1) , P (k+1) , Q(k+1) ] ← ActualizaZ(c(k) , P (k) , Q(k) , sol(k) )
4.4. F (k+1) ← CalculaF(c(k+1) , A0 , ..., An , P (k+1) , S ∗ , Q(k+1) )
Considerando m = n, el tiempo de ejecución de FB es:

74 3 2
TF B (m) = m + 4m + 2m tf +
3

16 6 5 4 32 3 2
+k m + 8m + 4m + m + 10m + 3m tf .
3 3
El término de orden superior (O(m6 )) corresponde a la resolución del sistema
de ecuaciones lineales del paso 4.2., dado que manipulan las estructuras de datos
más grandes del Algoritmo 21: JF B y F .
69
MI. En el Algoritmo 22 las tiempos para calcular b y J son:

Tb (m, n) = 2mn2 + 2mn + 3n tf

TJ (m, n) = 2mn3 + 2mn2 tf .
Algoritmo 22 MI
1. A(0) ← CalculaA(c(0) , A0 , ..., An )
2. [P (0) , S (0) , Q(0) ] ← dgesvd(A(0) )
3. Para k = 0,1,..., Mientras dnrm2(S (k) − S ∗ ) > tol
3.1. J (k) ← CalculaJ(A1 , ..., An , P (k) , Q(k) )
3.2. b(k) ← Calculab(A0 , P (k) , Q(k) , S ∗ )
3.3. c(k+1) ← dgesv(J (k) , b(k) )
3.4. A(k+1) ← CalculaA(c(k+1) , A0 , ..., An )
3.5. [P (k+1) , S (k+1) , Q(k+1) ] ← dgesvd(A(k+1) )
Por lo tanto, el tiempo de ejecución de MI cuando m = n es:

44 3 58
TM I (m) = m + 4m tf + k 2m4 + m3 + 2m2 + 7m tf .
3 3
En este caso el paso más caro es el cálculo de la matriz Jacobiana J y la

eficiencia del algoritmo estará supeditada a este cálculo.
EP. Para estimar el tiempo de ejecución de EP es necesario estimar el del cálculo
de Atr y btr (pasos 1., 2. y 4.4. del Algoritmo 23):

n3 + n 2
TAtr (m, n) = mn3 + mn2 + tf
2

Tbtr (m, n) = mn + 4mn2 + n2 tf .
Algoritmo 23 EP
1. Atr ← CalculaAtr(A1 , ..., An )
2. Atr ← pdgetri(Atr )
3. parar ← F ALSO
4.1. A(k) ← CalculaA(c(k) , A0 , ..., An )
4.2. [P (k) , S (k) , Q(k) ] ← dgesvd(A(k) )
4.3. X (k) ← dgemm(m, n, n, P (k) , dgemm(m, n, n, S ∗, Q(k)t ))
(k)
4.4. btr ← Calculabtr(S ∗ , A0 , P (k) , Q(k) )
(k)
4.5. c(k+1) ← dgemv(n, n, Atr , btr )
4.6. Si dnrm2(c(k+1) − c(k) ) < tol entonces parar ← V ERDADERO
70
A diferencia de FB y MI, que tienen el paso más costoso dentro del ciclo,
EP lo tiene antes del ciclo en el cálculo de Atr, lo que se refleja en su tiempo de
ejecución estimado:

7 m2 56 3
TEP (m) = m4 + m3 + tf + k m + 4m2 + 4m tf ,
2 2 3
cuando m = n.
MIII. Por último, los tiempos de ejecución de los pasos 4.5., 4.6. y 4.7. del
Algoritmo 24 son:

TW (m, n) = 2mn2 + 2m2 n tf

THL (m, n) = 4mn + 6n2 tf

26 3 2
TP (m) = m + m tf
3
Algoritmo 24 MIII
1. A(0) ← CalculaA(c(0) , A0 , ..., An )
2. [P (0) , S (0) , Q(0) ] ← dgesvd(A(0) )

3. denoi,j ← Si∗2 − Sj∗2 i,j=1,n;excepto i=j
4. Para k = 0,1,..., Mientras dlange(P (k)t A(k) Q(k) − diag(S ∗ )) > tol
4.1. J (k) ← CalculaJ(A1 , ..., An , P (k) , Q(k) )
4.2. b(k) ← Calculab(A0 , P (k) , Q(k) , S ∗ )
4.3. c(k+1) ← dgesv(J (k) , b(k) )
4.4. A(k+1) ← CalculaA(c(k+1) , A0 , ..., An )
4.5. W (k) ← CalculaW(P (k) , Q(k) , A(k+1) )
4.6. [H̃ (k) , L̃(k) ] ← CalculaHL(S ∗ , W, deno)
4.7. P (k+1) ← AproximaP(P (k) , H̃ (k) )
4.8. Q(k+1) ← AproximaQ(Q(k) , L̃(k) )
El paso 4.8. tiene el mismo costo que TP , sustituyendo m por n. Por lo tanto,
el tiempo de ejecución de MIII, tomando m = n es:

53 3 11 2 3
TM III (m) = m + m − m tf + k 2m4 + 31m3 + 18m2 + 3m tf .
3 2 2
Como MIII comparte el cálculo de J con MI, el paso más costoso de MIII
es el paso 4.1. que se ejecuta con cada iteración.
Con todos estas estimaciones de tiempos de ejecución se tiene otro parámetro
de comparación de los algoritmos del PIAVS. FB es el algoritmo con más costo
computacional, mietras que EP tiene el menor costo por iteración, sin embargo,
en los experimentos realizados EP requiere muchas iteraciones para converger
que el resto de los algoritmos. Entonces, los tiempos de ejecución no están
71
supeditados sólamente al tamaño del problema (m) sino también al número de
iteraciones (k).
Estimar los tiempos de ejecución también ayuda a identificar las secciones
más costosas de cada algoritmo, permitiendo centrar la atención en ellas para
valorar si el algoritmo es susceptible de mejora. En los algoritmos que se manejan
en este trabajo, dado que se han hecho estimaciones de tiempos suponiendo
el empleo de rutinas eficientes, es difı́cil, en primera instancia, vislumbrar una
mejora sustancial que disminuya la complejidad de tiempo, quedando por aplicar
alternativas de solución con en el empleo de la programación paralela para
distribuir la carga de trabajo en un conjunto de procesadores, que es el tema
del Capı́tulo 4.
3.3. Análisis y Evaluación de los Algoritmos Se-

cuenciales del PIAVS
En esta sección se contrastan los algoritmos FB, MI, EP y MIII, de acuerdo
a diversos aspectos, como: cantidad de almacenamiento requerido, convergencia,
exactitud, criterios de parada, número de iteraciones requeridas y tiempos de
ejecución, a través de estimaciones y con ayuda de los resultados arrojados por
los experimentos realizados.
3.3.1. Requerimientos de Memoria

En sı́ mismo el PIAVS es un problema que requiere grandes cantidades de
memoria para almanecar, al menos, n + 1 matrices de tamaño m × n (Ai , i =
0, n) y dos vectores de tamaño n (S ∗ , c); a esto hay que añadir las matrices y
vectores propios de cada algoritmo (para almacenar valores y vectores singulares,
matrices jacobianas, matrices hemisimétricas, etc.). Haciendo una estimación de
la cantidad de Kbytes necesarios para cada algoritmo, se obtienen los siguientes
datos:
m=n 4 10 30 50 100 500 1000
FB 12 366 20000 205000 4.0e6 2.0e9 3.2e10
MI 1.2 12 250 1100 8.3e3 1.0e6 8.0e3
EP 1.2 12 250 1100 8.3e3 1.0e6 8.0e3
MIII 1.7 15 270 1200 8.6e3 1.0e6 8.1e3
Fácilmente se observa que FB requiere mucho más memoria que el resto

de los algoritmos, siendo poco factible de implementar para experimentos de
tamaños mayores a 50. Los mejores algoritmos en este aspecto son MI y EP.
72
3.3.2. Convergencia
En los experimentos numéricos realizados se ha reflejado el carácter new-
toniano de todos los métodos, excepto EP, con respecto a la sensibilidad a los
puntos iniciales c(0) dados a los algoritmos; en la siguiente relación se resumen
(0)
estos comportamientos para diferentes puntos iniciales ci = c∗i + δ (i = 1, n).
δ 1e − 1 1e0 1e1
FB converge converge para m < 50 converge para m ≤ 10
MI converge converge para m < 50 converge para m ≤ 10
EP converge converge converge
MIII converge converge para m < 50 converge para m ≤ 10
Se ha observado que, cuando c(0) es cercano a la solución, ningún algoritmo

tiene problemas de convergencia, pero en cuanto c(0) se aleja de la solución los
algoritmos convergen para tamaños de problema (m, n) cada vez más pequeños.
EP es el algoritmo que mejores caracterı́sticas de convergencia tiene, dado que
se ha demostrado que converge en el sentido (2.31).
Los criterios con los que se determina que un algoritmo ha convergido son:
FB kS (k) − S ∗ k2 < tol

MI kS (k) − S ∗ k2 < tol
EP kc(k) − c(k−1) k2 < tol
MIII kP (k)t A(k) Q(k) − S ∗ kF < tol
de ellos el menos costoso de calcular y más fácil de alcanzar es el de EP, aunque

con éste podrı́a convergerse no necesariamente a c∗ y no se involucra en absoluto
a S ∗ ; mientras que el criterio más costoso, ya que deben calcularse no sólo los
valores sino también los vectores singulares de A(k) , al menos aproximadamente,
donde no se involucra c∗ , pero sı́ S ∗ , es el de MIII.
Aunque EP es un algoritmo que siempre converge, su punto débil se encuen-
tra en la cantidad de iteraciones y la calidad de la solución calculada, como se
verá en los siguientes párrafos.
3.3.3. Exactitud de la solución

Ahora se contrasta la calidad de la solución dada por cada algoritmo para
los mismos casos experimentales, de los cuales se han tomado aquellos en los
(0)
que todos los algoritmos convergen (con ci = c∗i + 1e − 1, i = 1, n). Para medir
la calidad, se toman los errores relativos de los valores singulares calculados con
(k) ∗
respecto a los deseados: kS kS−S ∗k
2
k2
, y no los errores con respecto a c(k) y c∗ ,
debido a que el PIAVS puede tener más de una solución:
73
m=n FB MI EP MIII
4 1.21e-16 1.15e-10 1.17e-07 3.05e-16
5 2.35e-12 2.37e-12 4.68e-08 2.34e-12
10 1.67e-16 1.23e-12 6.80e-08 1.74e-12
15 1.90e-16 1.59e-16 1.87e-07 1.99e-16
20 1.18e-16 6.33e-16 1.42e-07 2.75e-16
25 1.26e-15 8.89e-16 1.79e-07 7.72e-16
30 5.41e-16 4.29e-16 1.13e-07 2.57e-16
40 2.35e-16 2.44e-16 6.43e-08 2.39e-16
50 1.76e-14 2.23e-13 6.66e-08 3.11e-16
EP es el menos exacto de los algoritmos y en la mayorı́a de los casos MIII

es el que aproxima mejor a los valores singulares deseados.
3.3.4. Estimación de la complejidad de tiempo y tiempos

de ejecución
La estimación de la complejidad de tiempo está en función del tamaño del
problema (m,n) y del número de iteraciones para converger (k); para los algo-
ritmos que se presentan en este trabajo, esta estimación puede dividirse en el
costo de la fase de inicio (T (m, n)inicio ) y el costo de cada iteración dentro del
ciclo (T (m, n)ciclo ), de modo que la complejidad de tiempo es
T (m, n, K) = T (m, n)inicio + kT (m, n)ciclo .
Entonces, la estimación para cada método (para m = n) puede expresarse

como:
T (m, k)F B ≈ (62/3)m3 + O(m2 ) + k{(16/3)m6 + O(m5 )}
T (m, k)M I ≈ (44/3)m3 + O(m) + k{2m4 + O(m3 )}
T (m, k)EP ≈ m4 + O(m3 ) + k{(56/3)m3 + O(m2 )}
T (m, k)M III ≈ (53/3)m3 + O(m2 ) + k{2m4 + O(m3 )}
La estimación de FB muestra que es el algoritmo más costoso de todos.

Por otra parte, EP tiene la estimación menos costosa en la parte iterativa, pero
necesita más iteraciones para converger que el resto de los algoritmos. Esto puede
verificarse en la siguiente tabla donde se muestra k, el número de iteraciones
que necesitan los algoritmos para converger en experimentos con δ = 1e − 1:
m=n 4 5 10 15 20 25 30 40 50
FB 3 2 3 3 3 3 3 3 3
MI 2 2 2 3 3 3 3 3 3
EP 365 206 561 3398 2629 1998 4048 6304 5303
MIII 3 2 2 3 3 3 3 3 4
74
y en la siguiente figura se muestran los tiempos de ejecución correspondientes a
los mismos experimentos:
3
10
FB
MI
EP
MIII
2
10
Tiempos de ejecución (Seg)

1
10
0
10
−1
10
−2
10
0 5 10 15 20 25 30 35 40 45 50
m=n
donde se verifica que LP requiere más tiempo de ejecución, mientras que MI es

el más eficiente y el que requiere menos iteraciones.
3.3.5. Conclusiones
Se han diseñado y analizado un conjunto de algoritmos para resolver el
PIAVS. Los resultados experimentales dados en [Chu92a] y [BMX03] para
resolver el PIAVS corresponden a matrices de tamaño 5 × 4, por lo que se ha
experimentado con matrices de mayor tamaño.
Lo que se observa en este estudio es que FB es un algoritmo de alto coste,
tanto por las dimensiones de las estructuras de datos que maneja (O(m4 )), como
por la cantidad de cálculos requeridos para operar con ellas (O(m6 )).
Desde el punto de vista espacial MI y EP son los de menores requerimientos
de memoria y desde el punto de vista temporal MI es el más eficiente. La más
alta exactitud de las soluciones, en la mayorı́a de los casos probados, se alcanza
con MIII.
El inconveniente más importante de MI y MIII, que es un inconveniente más
de FB, es la sensibilidad que tienen al punto inicial para converger, que se agraba
conforme m aumenta su tamaño. En cambio, EP no observa este problema.
Para ilustrar las ventajas e inconvenientes de los algoritmos en una tabla, se
ha asociado un valor del intervalo [1,4] (1=alta valoración, 4=baja valoración),
a cada caracterı́stica de los algoritmos, que de acuerdo a los experimentos rea-
lizados se obtiene lo siguiente:
Memoria Convergencia Exactitud Iteraciones Tiempo de ejecución

FB 3 2 3 1 3
MI 1 2 2 1 1
EP 1 1 4 3 4
MIII 2 2 1 2 2
75
En términos generales, los algoritmos que mejor equilibran los diferentes
aspectos son MI y MIII.
Los algoritmos que se han implementado trabajan con matrices Ai (i = 0, n)
de estructura general. El manejo de matrices estructuradas conlleva un rediseño
de los algoritmos para explotar la estructura y aminorar los costos de cálculo y
almacenamiento, tema que se aborda en el capı́tulo 5.
Aplicar estos algoritmos a problemas de mayor tamaño (m > 50) implica
lidiar con altos costos de almacenamiento y ejecución. Una forma de solventar
los problemas de memoria es manteniendo las estructuras de datos almacenadas
en memoria secundaria y tenerlas en memoria principal sólamente cuando se
accedieran. Otra forma, que también solventarı́a el alto costo de ejecución, es
paralelizando los algoritmos, de modo que cada procesador involucrado alma-
cenara sólamente una parte de las estructuras de datos y ejecutara parte de
los cálculos del algoritmo. La paralelización de los algoritmos es el tema del
siguiente capı́tulo.
76
Capı́tulo 4
Algoritmos Paralelos para

la Resolución del PIAVS
El diseño, la experimentación numérica y la evaluación de los algoritmos

paralelos de los métodos que resuelven el PIAVS se presentan en este capı́tulo. La
paralelización de estos métodos tiene como fin poder aplicarlos para tamaños de
problema grandes (para valores de m del orden de O{102 , 103 }) y disminuir los
costos de ejecución y almacenamiento que, como se vió en el Capı́tulo anterior,
son muy altos.
La paralelización realizada está en función del entorno paralelo selecciona-
do: distribución de matrices y vectores por bloques en mallas lógicas de proce-
sadores, ejecución de un mismo conjunto de instrucciones sobre diferentes con-
juntos de datos en las unidades de procesamiento y empleo del modelo de paso
de mensajes entre las unidades de procesamiento.
Una buena parte de las operaciones de los algoritmos del PIAVS pueden pa-
ralelizarse utilizando directamente rutinas de ScaLAPACK, PBLAS y BLACS;
otras son paralelizables diseñando rutinas especı́ficas que se basan en llamadas
a rutinas del mismo ScaLAPACK, de LAPACK, BLAS, PBLAS y BLACS (in-
clusive de MPI).
La primera tarea en este capı́tulo (Sección 4.1) es detallar los diseños pa-
ralelos de las operaciones que conforman a los algoritmos FB, MI, EP y MIII,
especificando las rutinas utilizadas. En la Sección 4.2 se presentan los algoritmos
paralelos de FB, MI, EP y MIII y se estiman los tiempos de ejecución teóricos
de cada uno. Posteriormente, en la Sección 4.3 se reportan tiempos de ejecución
de experimentos realizados, analizando y constrastando las pretaciones que de
estos experimentos se obtegan.
77
4.1. Paralelización de Operaciones de Algorit-
mos del PIAVS
Los algoritmos paralelos del PIAVS trabajan con estructuras de datos cuya
distribución sigue la convención establecida por ScaLAPACK. Ası́, todas las es-
tructuras de datos: A0 , A1 , ..., An , A, c, S ∗ , los vectores singulares (P , Q), matri-
ces hemisimétricas (H, L), matrices jacobianas (JF B, J), vectores de términos
independientes (b, btr , F ) y matrices de coeficientes (Atr ) se han particionado
en bloques y distribuido cı́clicamente en una malla lógica de procesadores de
Prc = Pr × Pc procesadores (Pr renglones y Pc columnas). Para evitar al máxi-
mo las comunicaciones entre nodos, S ∗ y c también se han replicado en cada
procesador. Por lo tanto, en cada nodo de procesamiento se manejan matrices
y vectores con los siguientes tamaños locales (resultado de dividir la dimensión
global de la estructura por el número de procesadores):
Estructura Dimensión global Dimensión local

A, Ai (i = 0, n) m×n m/Pr × n/Pc
P, H m×m m/Pr × m/Pc
Q, Atr , L, J n×n n/Pr × n/Pc
JF B (mn + n2 + n)× (mn + n2 + n)/Pr ×
(mn + n2 + n) (mn + n2 + n)/Pc
c, b, btr m m/Pr
F mn + n2 + n (mn + n2 + n)/Pr
Al igual que en el caso secuencial, las operaciones comunes a todos los algo-
ritmos, excepto el cálculo de A, están paralelizadas en rutinas de ScaLAPACK
y PBLAS:
pdgesvd, ScaLAPACK, svd de una matriz
pdgesv, ScaLAPACK, resolución de un sistema de
ecuaciones lineales
pdnrm, PBLAS, norma-2 vectorial
pdlange, ScaLAPACK, norma-Frobenius matricial.
La paralelización del cálculo de A está en el Algoritmo 25. Nótese que este
algoritmo no tiene comunicaciones entre nodos, al estar c replicada.
Algoritmo 25 ParaleloCalculaA
1. A ← A0
2. Para i = 1,n
2.1. A ← daxpy( Pmr ∗ n
Pc , c i , A i )
Otras rutinas utilizadas en las paralelización de los algoritmos del PIAVS

son:
78
Rutinas Aritméticas de PBLAS y ScaLAPACK (con escalares α, β replicados;
vectores x, y y matrices A, B, C distribuidas en los procesadores):
pddot PBLAS xt y
pdscal PBLAS αx
pdaxpy PBLAS αx + y
pdgemv PBLAS αAx + βy
pdgemm PBLAS αAB + βC
pdlaset ScaLAPACK asigna valores a la triangular
superior o inferior de una matriz
pdgetri ScaLAPACK, A−1
Rutinas de comunicaciones y redistribución de datos de MPI, BLACS y ScaLA-
PACK:
MPI REDUCE MPI reduce valores de todos los procesadores

a un sólo valor en un sólo procesador
(comunicación todos a uno)
dgesd2d,dgerv2d BLACS envı́o-recepción de datos punto a punto
dgebs2d,dger2d BLACS dispersión de datos (envı́o uno a todos
o broadcast)
dgsum2d BLACS suma componente a componente matrices
almacenadas en diferentes procesadores
replicando el resultado en todos ellos
pdgemr2d ScaLAPACK redistribuye un vector de datos
pdelset ScaLAPACK asigna un valor a un componente
de una matriz distribuida
A continuación se paralelizan las rutinas de FB, MI, EP y MIII, detallando
algorı́tmicamente la paralelización y esquematizándola cuando sea necesario.
4.1.1. Paralelización de rutinas necesarias para FB

Primero se presenta la paralelización de las operaciones medulares del al-
goritmo FB, como son: cálculo del vector F , de la matriz Jacobiana JF B y
actualización del vector Z = [Q, P, c].
Paralelizar el cálculo de JF B implica mover elementos de Q, P y Ai (i =
1, n) a posiciones especı́ficas de JF B. Se ilustran, por ejemplo, los movimientos
de elementos de Q para la construcción de los bloques JF B11 y JF B3,2 . Cada
elemento de Q, qi,j (i = 1, n; j = 1, n) se dispersa en la malla de procesadores
y éstos lo colocan en la posición de JF B requerida (con previa multiplicación
por 2 o por Sj∗ , según sea el caso) . Para construir las columnas de JF B11
simplemente se utiliza la rutina de PBLAS pdcopy y para construir los elementos
79
diagonales se utiliza la rutina pdlaset de ScaLAPACK. De forma análoga a Q se
redistribuyen los elementos de P en JF B22 y JF B31 . Finalmente, para construir
JF B33 se vuelve a hacer uso de pdlacpy.
La paralelización del cálculo de F requiere calcular A, realizar cuatro mul-
tiplicaciones matriz-matriz distribuidas (pdgemm) y redistribuir los resultados
en F (pdcopy) (Algoritmo 26).
Algoritmo 26 ParaleloCalculaF
1. k ← 1
2. { aux ← Qt Q − In }
aux ← pdgemm(n, n, n, Qt, Q, −In )
3. { Llena F1:n∗(n+1)/2 , comunicando n2 datos }
Para i = 1,n
a. Fk:k+n−i+1 ← pdcopy(n − i + 1, auxi:n,i )
b. k ← k + n − i + 1
4. { aux ← P t P − Im }
aux ← pdgemm(m, m, m, P t, P, −Im )
5. { Llena Fn∗(n+1)/2+1:n∗(n+1) , comunicando n2 datos }
Para i = 1,n
5.1. Fk:k+n−i+1 ← pdcopy(n − i + 1, auxi:n,i )
5.2. k ← k + n − i + 1
6. { aux ← P diag(S ∗ ) }
aux ← pdgemm(m, n, n, P, diag(S ∗))
7. A ← ParaleloCalculaA(c(k), A0 , ..., An )
8. { A ← A − P S ∗ Qt }
A ← pdgemm(m, n, n, −aux, Q, A)
9. { Llena Fn∗(n+1)+1:mF , comunicando mn datos }
Para i=1,m
9.1. Fk:k+n ← pdcopy(n, Ai,1:n )
9.2. k ← k + n
Para actualizar Z en paralelo se tiene el Algoritmo 27. Como c debe con-

tenerla todo procesador, se construye completamente en el procesador 0 (paso
3) para que éste lo disperse al resto de procesadores.
80
Algoritmo 27 ParaleloActualizaZ
1. Para i = 1,n
1.1. Qi,1:n ← pdaxpy(n, sol(i−1)n+1:in+1 , Qi,1:n )
2. Para i = 1,m
2.1. Pi,1:n ← pdaxpy(n, soln2 +(i−1)n+1:n2 +in+1 , Pi,1:n )
3. { Redistribuir el subvector de sol correspondiente a c
de modo que el procesador 0 lo contenga completamente en aux }
aux ← pdgemr2d( Pnr , Fn2 +mn+1:n2 +mn+n )
4. { Replicar c (aux) en todos los procesadores, realizando una
dispersión uno a todos de un mensaje de longitud n }
Si procesador 0 entonces { enviar }
c ← daxpy(n, aux, c)
dgebs2d(0 All0 , n, c)
Sino { recibir }
c ← dger2d(0 All0 , n, c)
4.1.2. Paralelización de rutinas necesarias para MI

Para paralilizar MI hay que paralelizar escencialmente dos procesos: el cálcu-
lo de la matriz Jacobiana J y el vector de términos independientes b. Ası́ como
en el caso secuencial, en el cálculo paralelo de J no es necesario realizar n multi-
plicaciones matriz-vector distribuidas para calcular Aj qi , para j = 1, n; es más
eficiente realizar una sóla multiplicación matriz-matriz distribuida AQ para te-
ner el mismo resultado. La matriz resultante se multiplica columna a columna
con P utilizando el producto escalar (pti (Aj qi ) = pti (Aj Q)i para i = 1, n) y
se hace uso de la herramienta pdelset de ScaLAPACK para colocar el resul-
tado del producto escalar en el correspondiente componente de J (Ji,j ). Este
procedimiento se describe en el Algoritmo 28.
Algoritmo 28 ParaleloCalculaJ
1. Para j = 1, n
1.1. aux ← pdgemm(m, n, n, Aj , Q)
1.2. Para i = 1, m
1.2.1. prodEsc ← pddot(m, pi , auxi )
1.2.2. Ji,j ← pdelset(prodEsc)
La paralelización del cálculo de b obedece a la misma idea de calcular una

columna de J, sustituyendo la matriz Aj con A0 , como se ve en el Algoritmo 29.
81
Algoritmo 29 ParaleloCalculab
1. aux ← pdgemm(m, n, n, Aj , Q)
2. Para i = 1, m
2.1. prodEsc ← pddot(m, pi , auxi )
2.2. bi ← pdelset(prodEsc)
2.3. b ← pdscal(m, −1,0d0, b)
2.4. { b ← S ∗ − b }
b ← pdaxpy(m, S ∗ , b)
4.1.3. Paralelización de rutinas necesarias para EP

Los algoritmos a paralelizar en EP son el cálculo de la matriz de coefientes
Atr y el del vector de términos independientes btr . En el cálculo paralelo de Atr
intervienen todos los procesadores porque cada Ai (i = 0, n) está distribuida
en la malla lógida de procesadores. Ası́, para realizar los cálculos con A i y
Aj , cada procesador realiza el producto escalar de las columnas de Ai con Aj
que tiene almacenadas, obteniendo un resultado parcial de Atrji . Mediante dos
operaciones de reducción y suma, el resultado de la suma de todos los resultados
parciales se coloca en las posiciones (i, j) y (j, i) de Atr . Esta operación se realiza
para cada par de componentes (i, j) y (j, i) de Atr (ver Algoritmo 30).
Algoritmo 30 ParaleloCalculaAtr
1. Para i = 1,n
1.1. Para j = 1,i
1.1.1. tr ← 0
1.1.2. Para k = 1,n/Pc
1.2.2.1. tr ← tr + ddot(n/Pr , Aj:,k , Ai:,k )
1.1.3. { Reducción−Suma de tr de todos los procesadores al
procesador P roc que tiene el componente (i, j) de Atr }
Atri,jP roc ← M P I ReduceSum(1,tr,P roc)
btr se paraleliza con los mismos criterios que Atr (ver Algoritmo 31).
82
Algoritmo 31 ParaleloCalculabtr
1. { P ← P S ∗ }
Para i = 1,n/Pc
1.1. P:,i ← dscal(n/Pr , sAsteri , P:,i )
2. aux ← A0
3. aux ← pdgemm(m, n, n, P, Qt , −aux)
4. Para i=1,n
4.1. tr ← 0
4.2. Para k = 1,n/Pc
4.2.1. tr ← tr + ddot(n/Pr , Ai:,k , aux:,k )
4.3. { Reducción−Suma de tr de todos los procesadores
al procesador P roc que tiene el componente i de btr }
btriP roc ← M P I ReduceSum(1,tr,P roc)
4.1.4. Paralelización de rutinas necesarias para MIII

Las operaciones a paralelizar en MIII son: el cálculo de W , H y L y la
actualización de P y Q. El cálculo paralelo de W es muy sencillo, se deja toda
la tarea a rutinas de PBLAS (ver Algoritmo 32).
Algoritmo 32 ParaleloCalculaW
1. W ← pdgemm(m, n, m, P t , A)
2. A ← pdgemm(m, n, n, W, Q)
3. W ←A
4. {aux ← W t }
Para j = 1,n
4.1. auxj,1:m ← pdcopy(m, W1:m,j )
La paralelización de la aproximación de P y Q también es sencilla, el algorit-

mo se limita a realizar las correspondientes llamadas de BLAS en PBLAS (ver
Algoritmo 33). Como se ha visto antes, aproximar Q es análogo a aproximar P .
83
Algoritmo 33 ParaleloAproximaP
1. { aux ← P H̃ }
aux ← pdgemm(m, m, m, P, H)
2. { H ← −(1/2)P H̃P t }
H ← pdgemm(m, m, m, −(1/2)aux, P t)
3. { H ← Im − (1/2)H }
Para i=1,m
3.1. El procesador que almacena Hi,i global ejecuta: Hilocal,ilocal ← 1
4. { aux ← (Im − (1/2)H)P }
aux ← pdgemm(m, m, m, H, P )
5. { P ← (Im − (1/2)H)P }
P ← aux
6. { aux ← Im − (1/2)H }
aux ← H
7. { aux ← −Im + (1/2)H }
aux ← dscal(ldA ∗ nqP, −1, aux)
8. { aux ← Im + (1/2)H }
Para i = 1,m
8.1. El procesador que almacena auxi,i global ejecuta: auxilocal,ilocal ← 1
9. { Calcula lu(Im + (1/2)H) }
[L, U ] ← pdgetrf (m, aux)
10. { Resuelve (Im + H2 )P+ = (Im − H2 )P }
P+ ← pdgetrs(m, L, U, P )
En el cálculo de H y L no hay necesidad de comunicar datos entre proce-

sadores, ya que las operaciones con las estructuras de datos que están dis-
tribuidas en ellos se realizan operaciones componente a componente, por estos
motivos se han diseñado algoritmos paralelos que calculen tanto W como W t .
El algoritmo correspondiente es el Algoritmo 34.
84
Algoritmo 34 ParaleloCalculaHL
1. Para j = 1,n/Pc
1.1. { Hi,j = −Hj,i ← Sj∗ Wi,j i = 1, n; j = i + 1, n }
∗
H1:n/Pr ,j ← daxpy(n/Pr , Sjglobal , W1:1/Pr ,j )
∗
1.2. { Li,j = −Lj,i ← Si Wi,j i = 1, n; j = i + 1, n }
∗
L1:n/Pr ,j ← daxpy(n/Pr , Sjglobal , aux1:n/Pr ,j )
∗
1.3. { Hi,j ← −Wi,j /Sj i = n + 1, m; j = 1, n }
∗
Hn/Pr +1:m/Pr ,j ← daxpy(m/Pr − n/Pr , −1/Sjglobal , Wn/Pr +1:m/Pr ,j )
2. Para i = 1,n/Pr
2.1. { Hi,j = −Hj,i ← Si∗ Wj,i + Sj∗ Wi,j i = 1, n; j = i + 1, n }
∗
Hi,1:n/pc ← daxpy(n/Pc , Siglobal , auxi,1:n/Pc )
2.2. { Li,j = −Lj,i ← Si∗ Wi,j + Sj∗ Wj,i i = 1, n; j = i + 1, n }
∗
Li,1:n/Pc ← daxpy(n/Pc , Siglobal , auxi,1:n/Pc )
2.3. { Hj,i ← Wi,j /Sj∗ i = n + 1, m; j = 1, n }
∗
Hi,n/Pc +1:m/Pc ← daxpy(m/Pc − n/Pc , −1/Siglobal , auxi,n/Pc +1:m/Pc )
3. Para i = 1,n/Pr
3.1. Para j = 1,n/Pc
3.1.1. Hi,j ← Hi,j /denoi, j
3.1.2. Li,j ← Li,j /denoi, j
La paralelización del cálculo de b y J ya se han visto en MI.

Con esta rutina se termina el desarrollo de rutinas paralelas de los pasos de
los métodos del PIAVS. A continuación se presentan los algoritmos paralelos de
FB, MI, EP y MIII y se estiman los tiempos de ejecución teóricos de cada uno.
4.2. Algoritmos Paralelos para el PIAVS y Tiem-

pos de Ejecución Teóricos
Para estimar los tiempos de ejecución de las algoritmos paralelos diseñados,
se da una lista de los tiempos de ejecución de las rutinas paralelas aritméticas
de ScaLAPACK y PBLAS utilizadas [KGGKrp94], [CDD+ 95], [BCC97], con-
siderando matrices de dimensión m×m y vectores de dimensión m (recordar que
tf detona el tiempo de ejecución para operar con un flotante, tm es la latencia y
tv es el tiempo de transferencia de un dato entre dos nodos de procesamiento):
pdgesvd (ScaLAPACK)
38 m3 14m2 log2 Prc
T (m, Prc ) = tf + 17mtm + √ tv
3 Prc Prc
pdgesv (ScaLAPACK)

2 m3 log2 Prc m2
T (m, Prc ) = tf + (6 + log2 Prc ) mtm + 3 + √ tv
3 Prc 4 Prc
85
pddot (PBLAS)
2m p
T (m, Prc ) = tf + 2( Prc − 1)tm + tv
Prc
pdaxpy (PBLAS)
m Pr + P c m
T (m, Prc ) = √ tf + t m + √ tv
Prc 2 Prc
pdgemv (PBLAS)
m2 p
T (m, Prc ) = tf + 2 Prc tm + 3mtv
P rc
pdgemm (PBLAS)
2m3
T (m, Prc ) = tf + m(log2 Pc + log2 Pr )tm +
Prc

m2 m2
+ log2 Pc + log2 Pr tv
Pr Pc
ParaleloCalculaA
2m3
T (m, Prc ) = tf
Prc
También se listan los tiempos de ejecución estimados de las rutinas de co-
municación utilizadas, considerando la comunicación de un mensaje de longitud
m [KGGKrp94]:
Comunicación Punto a Punto (dgesd2d-dgerv2d (BLACS), pdelset (ScaLA-
PACK))
Pr + P c
T (m, Prc ) = tm + mtv
2
Comunicación Uno a Todos o Dispersión (dgebs2d-dgebr2d (BLACS))

Pr + P c
T (m, Prc ) = + 1 (tm + mtv )
2
Comunicación Todos a Uno o Reducción (pdgemr2d1 (ScaLAPACK))

Pr + P c
T (m, Prc ) = + 1 (tm + mtv )
2
Reducción con Suma (MPI REDUCE)

Pr + P c Pr + P c
T (m, Prc ) = + 1 mtf + + 1 (tm + mtv )
2 2
Comunicación Todos a Todos
T (m, Prc ) = (Pr + Pc − 2) (tm + mtv )

1 Aunque pdgemr2d se utiliza en general para redistribuir una matriz en una malla de
procesadores, en este trabajo se utiliza para una sóla redistribución especı́fica: construir el
vector global c en el procesador 0 del vector distribuido c
86
Comunicación Todos a Todos con suma (dgsum2d (BLACS)
T (m, Prc ) = (Pr + Pc − 2) mtf + (P r + Pc − 2)(tm + mtv )
A continuación se presentan los algoritmos paralelos de FB, MI, EP y MIII y

la estimación de sus tiempos de ejecución con base en los tiempos arriba listados.
FB Paralelo. La paralelización de FB está en el Algoritmo 35.
Algoritmo 35 FBParalelo
1. A(0) ← ParaleloCalculaA(c(0), A0 , ..., An )
2. [P (0) , S (0) , Q(0) ] ← pdgesvd(A(0) )
3. F (0) ← ParaleloCalculaF(c(0), A0 , ..., An , P (0) , S ∗ , Q(0) )
4. error ← pdnrm2(F (0) )
5. {Difunde por renglones error replicado en la columna 0 de procesadores}
error ← dgsum2d(0 Ren0 , 1, error)
6. Para k = 0,1,..., Mientras error > tol
6.1. JF B (k) ← ParaleloCalculaJFB(S ∗, A1 , ..., An , P (k) , Q(k) )
6.2. sol(k) ← pdgesv(JF B (k) , −F (k) )
6.3. [c(k+1) , P (k+1) , Q(k+1) ] ← ParaleloActualizaZ(c(k), P (k) , Q(k) , sol(k) )
6.4. F (k+1) ← ParaleloCalculaF(c(k+1), A0 , ..., An , P (k+1) , S ∗ , Q(k+1) )
6.5. error ← pdnrm2(F (k) )
6.6. {Difunde por renglones error replicado en la columna 0 de procesadores}
error ← dgsum2d(0 Ren0 , 1, error)
Los tiempos de ejecución de los pasos 6.1., 6.3. y 6.4. de este algoritmo son,
respectivamente:

2mn + 2n2 Pr + P c
TJF B (m, n, Prc ) = tf + n3 + 3mn2 + m2 n tm + tv
Prc 2

mn n2 2Pr + Pc + 3
TZ (m, n, Prc ) = √ +√ + n tf + n + m + tm +
Prc Prc 2

Pr + P c Pr + 1 Pr + P c + 2
+ √ (mn + n2 ) + + n tv
2 Prc 2Pr 2

6mn2 2n3 2m3
TF (m, n, Prc ) = + + tf +
Prc Prc Prc

(log2 Pc + log2 Pr )(3n + m) + mn + 2n2 tm +

Pr + P c 2 log2 Pc 2 2 log2 Pr 2 2
(2n + mn) + (2mn + m + n ) + (3n + m ) tv
2 Pr Pc
87
Considerando m = n, el tiempo de ejecución de las operaciones aritméticas
de FB es:

74m3 4m2 2m Pr + Pc
TA (m, Prc ) = + + + tf +
3Prc Prc Prc 2

16m6 8m5 4m4 32m3 8 2
+K + + + + +√ m2 +
3Prc Prc Prc 3Prc Prc Prc

2
+ 1+ m tf
Prc
y el tiempo de comunicaciones es:

Pr + P c
TCm (m, Prc ) = 3m2 + (4log2 Pc + 4log2 Pr + 17)m + tm +
2

+ K 5m3 + (2log2 Prc + 15)m2 + (log2 Prc + 4log2 Pr + 4log2 Pc + 8)m+

3Pr
+ + P c tm
2

14log2Prc 4log2 Pr 4log2 Pc 3 2 Pr + P c
TCv (m, Prc ) = √ + + + (Pr + Pc ) m + tv +
Prc Pc Pr 2 2

m4 Pr + P c log2 Prc + 12
+ K (log2 Prc + 12) √ + 5 + √ m3 +
Prc 2 Prc

log2 Prc + Pr + Pc + 12 Pr + P c 4log2 Pc 4log2 Pr
+ √ +3 + + m2 +
Prc 2 Pr Pc

1 m Pr + P c
+ Pr + P c + +3 + tv
Pr 2 2
MI Paralelo. Además de la paralelización de las operaciones de MI ya presen-

tadas, el cálculo del error también se paraleliza como se explica enseguida. Como
S ∗ y S están replicados en los procesadores, para que ninguno de ellos quede
ocioso al manipular estos vectores en el cálculo del error, cada procesador ma-
nipula una parte de los mismos. Por ejemplo, si se tienen Prc = 4 procesadores
(ya sea en una malla 2 × 2, 1 × 4 o 4 × 1) y la longitud de S y S ∗ es m = 13,
entonces tres de los procesadores manipulará 3 elementos y el cuarto procesador
manipulará 4 elementos. Para controlar esto, se utilizan las estructuras de datos:
longi, low, up, que en este ejemplo tendrán los valores:
Procesador longi low up

0 4 1 4
1 3 5 7
2 3 8 10
3 3 11 13
Este proceso paralelo se escribe en el Algoritmo 36.
88
Algoritmo 36 ParaleloCalculaError
∗
1. { Slow:up ← Slow:up − Slow:up }
∗
Slow:up ← daxpy(longi, −1,0d0, Slow:up , Slow:up )
q
2 2 2
2. { error ← Slow + Slow+1 + ... + Sup }
error ← dnrm2(longi, Slow:up )
2 2 2
3. { error ← Slow + Slow+1 + ... + Sup }
error ← error ∗ error
4. { Calcula error total, error = S12 + S22 + ... + Sn2 en procesador 0 }
error ← dgsum2d(0 All0 , 1, error)
5. Si procesador 0 entonces { enviar }
dgebs2d(0 All0 , 1, error)
Sino { recibir }
error ← dger2d(0 All0 , 1, error)
6. error ← sqrt(error)
Entonces, el algoritmo MI paralelo es el Algoritmo 37 y los tiempos para

calcular b, J y el error son:

2mn2 2mn Pr + 1 n n
Tb (m, n, Prc ) = + + + tf +
Prc Prc 2 Pc Pr

Pr + 1
+ (lpgPc + logPr + 1) n + − b tm +
2
2

mn n Pr + 1 n Pr + P c Pr + P c
+ logPc + logPr + + n− b tv
Pr Pc 2 Pc 2 2

mn3 mn2 P r + 1 n2
TJ (m, n, Prc ) = 2 +2 + tf +
Prc Prc 2 Pc

2 Pr + 1
+ (logPc + logPr + 1) n + − b n tm +
2

mn2 n3 P r + 1 n2 Pr + P c 2 Pr + P c
+ logPc + logPr + + n − bn tv
Pr Pc 2 Pc 2 2

4n Pr + P c Pr + P c
Terror = + tf + (tm + tv )
Prc 2 2
donde b es el tamaño de bloque en la distribución cı́clica de las matrices y
vectores en la malla lógica de procesadores.
89
Algoritmo 37 MIParalelo
2. [P (0) , S (0) , Q(0) ] ← pdgesvd(A(0) )
3. error ← ParaleloCalculaError(S (0), S ∗ )
4. Para k = 0,1,..., Mientras error > tol
4.1. J (k) ← ParaleloCalculaJ(A1, ..., An , P (k) , Q(k) )
4.2. b(k) ← ParaleloCalculab(A0, P (k) , Q(k) , S ∗ )
4.3. c(k+1) ← pdgesv(J (k) , b(k) )
4.4. { Redistribuye c(k+1) de modo que el procesador 0 lo
contenga completamente }
c ← pdgemr2d( Pnr , c(k+1) )
4.5. { Replica c(k+1) en todos los procesadores realizando
una dispersión uno a todos de un mensaje de longitud n }
dgebs2d(0 All0 , n, c(k+1) )
Sino { recibir }
c(k+1) ← dgebr2d(0 All0 , n, c(k+1) )
(k+1)
4.6. A ← ParaleloCalculaA(c(k+1), A0 , ..., An )
4.7. [P (k+1) , S (k+1) , Q(k+1) ] ← pdgesvd(A(k+1) )
4.8. error ← ParaleloCalculaError(S (k+1), S ∗ )
Por lo tanto, el tiempo de ejecución aritmético de MI cuando m = n es:

44 m3 m Pr + P c
TA (m, Prc ) = +4 + tf +
3 Prc Prc 2

2m4 58 m3
+K + +
Prc 3 Prc

Pr + 1 2 2 1 4 Pr + 1 Pr + P c
+ + m + + m+ + tf ,
2Pc Prc Pr Prc 2Pc 2
y el de comunicaciones es:

Pr + P c
TCm (m, Prc ) = 17m + tm +
2

2 Pr
+ K (log2 Pc + log2 Pr + 1) m + log2 Prc + log2 Pr + log2 Pc + − b m+
2
+2Pr + Pc − b} tm

14logPrcm2 Pr + P c log2 Pc log2 Pr
TCv (m, Prc ) = √ + tv + K + m3 +
Prc 2 Pr Pc

57 log2 Prc log2 Pr log2 Pc Pr + P c Pr + 1 3
+ √ + + + + +√ m2 +
4 Prc Pc Pr 2 2Pc Prc

Pr + 1 1 Pr + P c Pr + P c
+ Pr + P c + + Pr − b m + (1 − b) tv
2Pc 2 2 2
90
EP Paralelo. Para estimar el tiempo de ejecución de EP es necesario estimar
el del cálculo de Atr y btr (pasos 1.y 4.4. del Algoritmo 38, donde el cálculo del
error es igual que en MI.):

mn3 n3 Pr + P c + 2 2
TAtr (m, n, Prc ) = + + n tf +
Prc 2Pc 4

mn2 n2 Pr + P c + 2
+ + + n tf +
Prc 2Pc 4
Pr + P c + 2 2
+ (n + n)(tm + tv )
4

mn 4mn2 n2 Pr + P c + 2
Tbtr (m, n, Prc ) = + + +n tf +
Prc Prc Pc 2

Pr + P c + 2
+ n log2 Pc + log2 Pr + tm +
2

Pr + P c + 2 mn n2
+ n + logPc + log2 Pr tv
2 Pr Pc
Algoritmo 38 EPParalelo
1. Atr ← ParaleloCalculaAtr(A1, ..., An )
2. Atr ← pdgetri(Atr )
3. parar ← F ALSO
4.1. A(k) ← ParaleloCalculaA(c(k), A0 , ..., An )
4.2. [P (k) , S (k) , Q(k) ] ← pdgesvd(A(k) )
4.3. X (k) ← pdgemm(m, n, n, P (k) , pdgemm(m, n, n, S ∗, Q(k)t ))
(k)
4.4. btr ← ParaleloCalculabtr(S ∗, A0 , P (k) , Q(k) )
(k)
4.5. c(k+1) ← pdgemv(n, n, Atr , btr )
Sino { recibir }
c(k+1) ← dgebr2d(0 All0 , n, c(k+1) )
4.8. error ← ParaleloCalculaError(c(k+1) − c(k) )
4.9. Si error < tol entonces parar ← V ERDADERO
Ası́, el tiempo de ejecución de EP se estima como:
91

m4 3 1
TA (m, Prc ) = + + m3 +
Prc Prc 2Pc

Pr + P c + 2 1 Pr + P c + 2
+ + m2 + m tf +
4 2Pc 4

56 m3 2 1 4 Pr + P c
+k + + m2 + P r + P c + m+ tf
3 Prc Prc Pc Prc + 1 2

Pr + Pc + 2 2 Pr + Pc + 8log2 Pr + 2
TCm (m, Prc ) = m + m tm +
4 4

Pr + P c
+k log2 Pr + log2 Pc + + 18 m+
2
3Pr p
+ + Pc + 2 Prc tm
2

Pr + P c log2 Pr 1 1 2 Pr + P c + 2
TCv (m, Prc ) = + + + m + m tv +
4 2Pc Pr 2 4

14log2Prc log2 Pr log2 Pc 2 1 11
+k √ + + m + Pr + P c + + m+
Prc Pc Pr 2Pr 2

Pr + P c
+ tv
2
cuando m = n.
MIII Paralelo. Por último, los tiempos de ejecución de los pasos 5.5., 5.6. y
5.7. del Algoritmo 39 son:
2m2 n + 2mn2
TW (m, n, Prc ) = tf +
Prc
+ ((log2 Pc + log2 Pr ) m + (log2 Pc + log2 Pr + 1) n) tm +

mn n2 Pr + Pc mn
+ log2 Pc + log2 Pr + tv
Pr Pc 2 Pr

mn n2
THL (m, n, Prc ) = 4 +6 tf
Prc Prc

20 m3 2m3 m2 2m2
TP (m, n, Prc ) = + + + + 4m2 tf +
3 Prc Pr Prc Pr
2

+ m (Pr + 3) + m(3log2 Pc + 5log2 Pr ) tm +
3
m Pc m2 Pc
+ + 3log2 Pc + +1 tv +
2Pr Pr 2
2
m log2 Pr
+ 3log2 Pr + + m2 (Pr + 1) tv
Pc 2
92
Algoritmo 39 MIIIParalelo
2. [P (0) , S (0) , Q(0) ] ← pdgesvd(A(0) )

3. denoi,j ← Si∗2 − Sj∗2 i=1,n/P ; j=1,n/P ; excepto i=j
r c
4. W (0) ← P araleloCalculaW (P (0), Q(0) , A(0) )

5. Para k = 0,1,..., Mientras pdlange(W (k) − diag(S ∗ )) > tol
5.1. J (k) ← ParaleloCalculaJ(A1, ..., An , P (k) , Q(k) )
5.2. b(k) ← ParaleloCalculab(A0, P (k) , Q(k) , S ∗ )
5.3. c(k+1) ← pdgesv(J (k) , b(k) )
Sino { recibir }
c(k+1) ← dgebr2d(0 All0 , n, c(k+1) )
5.6. A(k+1) ← ParaleloCalculaA(c(k+1), A0 , ..., An )
5.7. W (k) ← ParaleloCalculaW(P (k), Q(k) , A(k+1) )
5.8. [H̃ (k) , L̃(k) ] ← ParaleloCalculaHL(S ∗, W (k) , deno)
5.9. P (k+1) ← ParaleloAproximaP(P (k), H̃ (k) )
5.10. Q(k+1) ← ParaleloAproximaQ(Q(k), L̃(k) )
5.11. W (k+1) ← P araleloCalculaW (P (k+1), Q(k+1) , A(k+1) )
El paso 5.8. tiene el mismo costo que TP , sustituyendo m por n. Por lo tanto,
el tiempo de ejecución de MIII, tomando m = n es:

53m3 7m2
TA (m, Prc ) = + tf +
3Prc Prc

2m4 27m3 18 4 Pr m Pr + 1
k + + + + + 8 m2 + + tf
Prc Prc Prc Pr 2Pc Pr 2Pc
TCm (m, Prc ) = [(log2 Pr + log2 Pc + 17) m + Pr + Pc ] tm +

2 Pr 15
k (Pr + log2 Pr + log2 Pc + 4) m + log2 Prc + 10log2Pc + 14log2 Pr + −b+ m+
2 2

3Pc
2Pr + tm
2
93

14log2 Prc log2 Pr log2 Pc
TCv (m, Prc ) = √ + + m2 + P r + P c tv +
Prc Pc Pr

log2 Pc log2 Pr Pc
+k + + m3 +
Pr Pc 2Pr

log2 Prc + 12 13log2Pr 6log2 Pc Pr + 1 Pc + 1 Pc + 3Pr 3
+ √ + + + + + + m2 +
4 Prc Pc Pr 2Pc Pr 2 2

Pr + P c Pr + 1 1 Pr + P c
+ 3 + + − b m+
2 2Pc 2Pr 2

Pr + P c
+ Pr + Pc − b tv
2
Era de esperarse que, como se utilizan rutinas eficientes de ScaLAPACK y
PBLAS, los tiempos de ejecución paralelos son aproximadamente los tiempos
secuenciales divididos por el número de procesadores más el tiempo de comu-
nicaciones entre éstos. En términos de orden superior, los tiempos de ejecución
aritméticos paralelos son:
5
74m3 m2 16m6 m
TF B : +O +k +O
3Prc Prc 3Prc Prc
3
44m3 m 2m4 m
TM I : +O +k +O
3Prc Prc Prc Prc
4
3 3
2
m m 56m m
TEP : +O +k +O ;
Prc Prc 3Prc Prc
2 3
53m3 m 2m4 m
TM III : +O +k +O √
3Prc Prc Prc Prc
los tiempos de establecimiento de comunicación son:
p n p o
TF B : 3m2 + O log2 Prc + k 5m3 + O Prc m2
n p p o
TM I : 17m + k 2log2 Prc m2 + O Prc m
√ √
Prc m2 p Prc m
TEP : +O Prc m + k ;
2 2
p np p o
TM III : 2log2 Prc m + k Prc m2 + O Prc m ,
a lo largo de todo F B se establecen más comunicaciones que en resto de los
algoritmos. Observando los tiempos del ciclo, el que menos establece comuni-
caciones es EP, sin embargo en las operaciones anteriores al ciclo es el más
costoso. MI y MIII observan el fenómeno inverso de EP. Por último, los tiempos
de transferencia son:

14log2Prc m2 log2 Prc m4 p
3
TF B : √ +k √ +O Prc m
Prc Prc
√
14log2 Prc m2 2log2 Prc m3 p
TM I : √ +k √ +O Prc m2
Prc Prc
94
√
Prc m2 p 14log2Prc m2 p
TEP : +O Prc m + k √ +O Prc m ;
4 Prc

14log2Prc m2 log2 Prc m3 p
2
TM III : √ +k √ +O Prc m ,
Prc Prc
dentro del ciclo, F B realiza más redistribución de datos que el resto de los
algoritmos, el más barato sigue siendo EP ; en las operaciones previas al ciclo,
prácticamente no hay diferencias entre ellos.
Con estos tiempos de ejecución teóricos y los tiempos de ejecución teóricos
secuenciales del Capı́tulo 3 se puede estimar la tendencia asintótica del Speedup
cuando crece el tamaño del problema (m → ∞). Se puede comprobar que para
todos los algoritmos paralelos del PIAVS el Speedup teórico alcanza el óptimo:
−1
T (m, 1) 3Prc 3Prc
lim SF B (m, Prc ) = lim = Prc
m→∞ m→∞ T (m, Prc ) 16m6 tf 16m6 tf
−1
T (m, 1) Prc Prc
lim SM I (m, Prc ) = lim = Prc
m→∞ m→∞ T (m, Prc ) 2m4 tf 2m4 tf
−1
T (m, 1) Prc Prc
lim SEP (m, Prc ) = lim = Prc
m→∞ m→∞ T (m, Prc ) m4 tf m4 tf
−1
T (m, 1) Prc Prc
lim SM III (m, Prc ) = lim = Prc
m→∞ m→∞ T (m, Prc ) 2m4 tf 2m4 tf
Con los tiempos de ejecución estimados también se pueden prever los tiempos
de ejecución experimentales de los algoritmos paralelos si se eligen adecuada-
mente los parámetros tf , tm y tv . Si los experimentos se llevaran a cabo en el
cluster Kefren, remitiéndose a la parametrización de éste presentada en la intro-
ducción, los parámetros de comunicaciones se toman con los valores: tm = 5e−6
segundos y tv = 4e − 8 segundos/doble. El valor de tf dependerá del tipo de
operaciones que realice cada algoritmo. En FB se aplican operaciones vectoriales
y en menor medida operaciones matriciales, por eso se utiliza tf =0.001e − 6
segundos. En MIII predominan las operaciones matriciales, por lo tanto se toma
tf =0.0005e − 6 segundos; mientras que MI puede verse como un algoritmo que
aplica un subconjunto de las operaciones de MIII, por lo que se toma el mismo
valor para tf . EP utiliza en su mayor parte operaciones vectoriales y escalares,
por lo que se toma tf = 0,003e − 6 segundos.
Habiendo elegido los parámetros de flop y de comunicaciones, se investiga
bajo qué configuración de malla de procesadores se obtienen los mejores tiempos
de ejecución en el cluster Kefren, para ello se estiman tiempos para algunos
valores de m y Prc . Los resultados obtenidos son:
95
Prc FB (seg)
1×9 37.671 182.583 653.527
9×1 37.669 182.579 653.520
3×3 37.562 182.327 653.031 ←
1 × 12 30.328 142.119 500.850
12 × 1 30.325 142.115 500.842
2×6 30.192 141.802 500.234
6×2 30.192 141.801 500.232
3×4 30.165 141.738 500.110 ←
4×3 30.165 141.738 500.110 ←
m=n 60 80 100
Prc MI (seg)
1×6 3.1324e+02 3.7607e+03 1.7104e+04
6×1 3.1342e+02 3.7614e+03 1.7105e+04
2×3 2.4310e+02 3.2000e+03 1.5212e+04 ←
3×2 2.4313e+02 3.2001e+03 1.5212e+04
1×9 2.8784e+02 3.1010e+03 1.3364e+04
9×1 2.8809e+02 3.1019e+03 1.3366e+04
3×3 1.8624e+02 2.2888e+03 1.0623e+04 ←
m=n 1000 2000 3000
Prc EP (seg)
1×6 5.2471e+02 8.1479e+03 4.0944e+04
6×1 5.2352e+02 8.1381e+03 4.0910e+04
2×3 5.2136e+02 8.1315e+03 4.0900e+04
3×2 5.2111e+02 8.1295e+03 4.0893e+04 ←
1×9 3.5827e+02 5.4677e+03 2.7381e+04
9×1 3.5700e+02 5.4572e+03 2.7345e+04
3×3 3.5210e+02 5.4390e+03 2.7307e+04 ←
m=n 1000 2000 3000
Prc MIII (seg)

1×4 4.8459e+02 5.7285e+03 2.5917e+04
4×1 4.1035e+02 5.0715e+03 2.3629e+04
2×2 3.6933e+02 4.7874e+03 2.2720e+04 ←
1×8 5.0650e+02 4.8809e+03 1.9656e+04
8×1 3.5371e+02 3.5136e+03 1.4878e+04
2×4 2.8269e+02 3.0736e+03 1.3537e+04
4×2 2.5702e+02 2.8269e+03 1.2658e+04 ←
m=n 1000 2000 3000
En todos los algoritmos, las mallas de procesadores con mejores tiempos de

ejecución corresponden a las cuadradas, tal como lo establece ScaLAPACK.
Ahora, con los parámetros establecidos tf , tm y tv y conociendo la mejor
configuración de malla con mejores tiempos de ejecución, se calculan los tiem-
pos de ejecución teóricos en el cluster Kefren para mallas cuadradas y diversos
valores de m = n, siendo los resultados obtenidos los de las Tablas 4.1 para FB,
4.2 para MI, 4.3 para EP y 4.4 para MIII, cuando los algoritmos ejecutan una
sóla iteración.
96
Tabla 4.1: Tiempos de Ejecución Teóricos de FB en Kefren
Prc Tiempo estimado en segundos
1 9.29e+01 2.68e+02 6.64e+02 1.46e+03 2.93e+03 5.49e+03
2 4.91e+01 1.39e+02 3.40e+02 7.44e+02 1.48e+03 2.77e+03
4 2.70e+01 7.41e+01 1.77e+02 3.83e+02 7.62e+02 1.41e+03
6 1.96e+01 5.22e+01 1.23e+02 2.63e+02 5.18e+02 9.57e+02
8 1.58e+01 4.12e+01 9.57e+01 2.02e+02 3.96e+02 7.29e+02
9 1.46e+01 3.75e+01 8.65e+01 1.82e+02 3.56e+02 6.53e+02
10 1.36e+01 3.46e+01 7.92e+01 1.66e+02 3.23e+02 5.91e+02
12 1.20e+01 3.01e+01 6.81e+01 1.41e+02 2.74e+02 5.00e+02
14 1.10e+01 2.70e+01 6.03e+01 1.24e+02 2.39e+02 4.34e+02
16 1.01e+01 2.45e+01 5.43e+01 1.11e+02 2.12e+02 3.85e+02
m 50 60 70 80 90 100
mF J 5050 7260 9870 12880 16290 10100
Tabla 4.2: Tiempos de Ejecución Teóricos de MI en Kefren

1 6.58e+01 1.02e+03 5.13e+03 1.61e+04 3.93e+04 8.15e+04
2 4.10e+01 5.67e+02 2.74e+03 8.49e+03 2.04e+04 4.21e+04
4 2.62e+01 3.18e+02 1.47e+03 4.48e+03 1.06e+04 2.18e+04
6 2.24e+01 2.43e+02 1.07e+03 3.20e+03 7.52e+03 1.52e+04
8 2.09e+01 2.08e+02 8.91e+02 2.58e+03 5.98e+03 1.19e+04
9 1.91e+01 1.86e+02 7.90e+02 2.28e+03 5.30e+03 1.06e+04
10 2.04e+01 1.90e+02 7.84e+02 2.22e+03 5.09e+03 1.01e+04
12 1.78e+01 1.60e+02 6.54e+02 1.85e+03 4.22e+03 8.38e+03
14 2.03e+01 1.72e+02 6.74e+02 1.84e+03 4.12e+03 8.05e+03
16 1.66e+01 1.38e+02 5.41e+02 1.49e+03 3.37e+03 6.62e+03
m 500 1000 1500 2000 2500 3000
Tabla 4.3: Tiempos de Ejecución Teóricos de EP en Kefren

1 1.97e+02 3.07e+03 1.54e+04 4.85e+04 1.18e+05 2.44e+05
2 9.97e+01 1.54e+03 7.72e+03 2.43e+04 5.91e+04 1.22e+05
4 5.11e+01 7.75e+02 3.87e+03 1.21e+04 2.96e+04 6.12e+04
6 3.51e+01 5.21e+02 2.59e+03 8.13e+03 1.97e+04 4.09e+04
8 2.73e+01 3.94e+02 1.95e+03 6.11e+03 1.48e+04 3.07e+04
9 2.45e+01 3.52e+02 1.73e+03 5.43e+03 1.32e+04 2.73e+04
10 2.27e+01 3.19e+02 1.57e+03 4.90e+03 1.19e+04 2.46e+04
12 1.94e+01 2.68e+02 1.31e+03 4.09e+03 9.93e+03 2.05e+04
14 1.78e+01 2.34e+02 1.13e+03 3.53e+03 8.54e+03 1.76e+04
16 1.56e+01 2.05e+02 9.94e+02 3.08e+03 7.47e+03 1.54e+04
m 500 1000 1500 2000 2500 3000
97
Tabla 4.4: Tiempos de Ejecución Teóricos de MIII en Kefren
1 7.46e+01 1.07e+03 5.27e+03 1.64e+04 3.99e+04 8.24e+04
2 5.24e+01 6.38e+02 2.96e+03 8.98e+03 2.14e+04 4.36e+04
4 3.57e+01 3.69e+02 1.62e+03 4.78e+03 1.12e+04 2.27e+04
6 3.33e+01 3.05e+02 1.26e+03 3.59e+03 8.25e+03 1.64e+04
8 3.34e+01 2.82e+02 1.11e+03 3.07e+03 6.90e+03 1.35e+04
9 2.98e+01 2.41e+02 9.41e+02 2.60e+03 5.87e+03 1.15e+04
10 3.43e+01 2.76e+02 1.04e+03 2.81e+03 6.20e+03 1.19e+04
12 2.95e+01 2.23e+02 8.31e+02 2.23e+03 4.92e+03 9.53e+03
14 3.72e+01 2.82e+02 1.01e+03 2.62e+03 5.60e+03 1.05e+04
16 2.86e+01 1.97e+02 7.03e+02 1.83e+03 3.97e+03 7.60e+03
m 500 1000 1500 2000 2500 3000
De acuerdo a las estimaciones presentadas en las tablas anteriores, de los

algoritmos paralelos MI, EP y MIII, se espera que EP sea el más costoso y MI
el menos costoso cuando se ejecuten las operaciones anteriores al ciclo y una sóla
vez las del ciclo. Por otra parte, al trabajar FB con m pequeñas y con mF J del
orden O(m4 ), los tiempos de ejecución esperados dependerán de la manipulación
de estructuras del orden de mF J, de ahı́, por ejemplo, las 17 horas empleadas
en un problema de tamaño m = 150.
El siguiente paso es realizar pruebas experimentales de tiempos de ejecución
de los algoritmos paralelos (que pueden cotejarse con las estimaciones de las
tablas anteriores) para, con base en los resultados arrojados, calcular y analizar
sus prestaciones experimentales.
4.3. Prestaciones Experimentales de los Algorit-

mos Paralelos del PIAVS
Como se especificó en la introducción, las métricas para analizar y evaluar
los algoritmos paralelos son: el tiempo de ejecución, speedup, eficiencia y esca-
labilidad. Para entrar en materia, primero se corrobora experimentalmente que
las mejores mallas de procesadores en el cluster Kefren son las cuadradas, como
se ve en las siguientes tablas:
Prc FB (seg) MI (seg)

1×4 0.87 7.77 39 454
4×1 1.22 10.2 42 425
2×2 0.78 7.35 30 372
1×6 0.84 5.76 109 1246
6×1 1.23 9.01 117 1247
2×3 0.69 5.65 66 1029
3×2 0.87 6.53 69 1059
m=n 25 40 512 1024
98
Prc EP (seg) MIII (seg)
1×8 32 575 45 578
8×1 34 626 51 547
2×4 35 694 37 482
4×2 31 570 33 466
1×9 497 539 46 560
9×1 498 559 53 543
3×3 493 508 33 417
m=n 512 1024 512 1024
A continuación se presentan los tiempos de ejecución de un conjunto de

experimentos del tipo Toep1, con m = n = {1000, 2000, 3000} para MI, EP y
MIII y con m = n = {50, 60, 70, 80, 90, 100} para FB, realizados en el cluster
Kefren con mallas cuadradas. Los tiempos de ejecución miden una sóla iteración
de los algoritmos (en segundos) y se registran de la Tabla 4.5 a la 4.8, para
los algoritmos FB, MI, EP y MIII. En particular, con FB paralelo se pueden
resolver problemas que secuencialmente no serı́a posible, como son los casos
m = n = {80, 90, 100}.
Tabla 4.5: Tiempos de Ejecución Experimentales de FB

Prc Segundos
1 83 244 609 - - -
2 44 125 309 679 - -
4 26 71 167 359 729 1323
6 18 50 114 244 493 882
8 15 39 90 189 377 674
9 13 36 87 173 336 612
10 13 33 74 154 309 547
12 11 29 68 134 257 468
14 10 26 56 115 228 401
16 9 25 53 106 207 365
m 50 60 70 80 90 100
mF J 5050 3260 2870 12880 16290 20100
Tabla 4.6: Tiempos de Ejecución Experimentales de MI

Prc Segundos
1 1026 16147 84410
2 661 8837 42864
4 332 4583 22538
6 250 3323 15707
8 226 2744 12759
9 175 2297 10789
10 227 2488 11039
12 165 1949 8870
14 203 1977 8785
16 140 1537 6885
m 1000 2000 3000
99
Tabla 4.7: Tiempos de Ejecución Experimentales de EP
Prc Segundos
1 3122 50060 249612
2 1651 25029 128532
4 880 12782 64990
6 650 8717 43285
8 458 6644 36787
9 409 5989 32608
10 445 5454 26406
12 320 4729 22176
14 385 3890 20209
16 337 4372 19493
m 1000 2000 3000
Tabla 4.8: Tiempos de Ejecución Experimentales de MIII

Prc Segundos
1 1181 17124 86131
2 692 9407 43306
4 402 4973 22160
6 351 3586 15813
8 265 2909 12774
9 237 2493 10792
10 265 2747 11059
12 200 2111 8745
14 233 2108 8790
16 169 1686 6882
m 1000 2000 3000
Puede observarse en las tablas anteriores que en todos los casos de todos los
algoritmos hay una reducción sustancial de los tiempos de ejecución secuenciales
cuando se utiliza más de un procesadores, por lo que el paralelismo aplicado
a estos algoritmos altamente costosos del PIAVS cumple con el cometido de
disminuir los costos temporales para resolver el problema. Esta disminución de
costos se aprecia en las Figuras 4.1, 4.2, 4.3 y 4.4, donde también se contrastan
los tiempos de ejecución experimentales con los estimados teóricamente en la
sección anterior y se puede observar que los algoritmos se han comportado muy
similarmente a como se estimó.
100
100 700
Experimental Experimental
Teórico Teórico
90 FB, m=50 FB, m=70
600
80
Tiempos de ejecución de FB (segundos)
Tiempos de ejecución de FB (segundos)

70 500
60
400
50
300
40
30 200
20
100
10
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Procesadores Procesadores
Figura 4.1: Tiempos de ejecución teóricos vs. experimentales de FB
18000 x 10
4
Experimental 9
Teórico Experimental
MI, m=2000 Teórico
16000 MI, m=3000
8
14000
7
Tiempos de ejecución de MI (segundos)
Tiempos de ejecución de MI (segundos)
12000
6
10000
5
8000 4
6000 3
4000 2
2000 1
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 4.2: Tiempos de ejecución teóricos vs. experimentales de MI
3500 x 10
4
Experimental 6
EP, m=1000 Teórico
EP, m=2000
3000
5
Tiempos de ejecución de EP (segundos)
2500
Tiempos de ejecución de EP (segundos)
2000
1500
2
1000
1
500
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 4.3: Tiempos de ejecución teóricos vs. experimentales de EP
101
18000 x 10
4
Experimental 9
MIII, m=2000 Teórico
16000 MIII, m=3000
8
14000
7
Tiempos de ejecución de MIII (segundos)
Tiempos de ejecución de MIII (segundos)

12000
6
10000
5
8000 4
6000 3
4000 2
2000 1
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 4.4: Tiempos de ejecución teóricos vs. experimentales de MIII
Con estos tiempos de ejecución experimentales se puede medir el Speedup de

los algoritmos paralelos. Para FB, el Speedup en todos los experimentos es bueno
con 2 y 4 procesadores; con 6 y 8 procesadores el caso m = 70 (mF J = 9870)
sigue teniendo un Speedup aceptable. El Speedup de MI (Figura 4.5) indica que
las prestaciones son mejores a medida que m se incrementa (m = 3000), sin
embargo, utilizando hasta 4 procesadores se obtienen buenos Speedups en todos
los casos.
12 14
m=1000
m=50 m=2000
m=60 m=3000
m=70
12
10
10
8
Speedup de FB
Speedup de MI
4
4
2
2
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 4.5: Speedup experimental de FB y MI para m = {1000, 2000, 3000}
Hasta con 8 procesadores el Speedup de EP es bueno para m = 3000 y

aceptable para m = 2000 y m = 1000. Para el caso m = 3000 el Speedup se
mantiene aceptable hasta con 12 procesadores (ver Figura 4.6).
Por último, MIII presenta buenos Speedups con 2 procesadores en todos los
casos. Con 4 procesadores y m = {2000, 3000} el Speedup también es bueno y se
mantiene aceptable con 6, 8 y 9 procesadores para m = 3000, como se observa
en la Figura 4.6.
102
14 14
m=1000 m=1000
m=2000 m=2000
m=3000 m=3000
12 12
10 10
Speedup de MIII
Speedup de EP
8 8
6 6
4 4
2 2
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 4.6: Speedup experimental de EP y MIII para m = {1000, 2000, 3000}
Se ha observado que el Speedup disminuye, en la mayorı́a de los experimen-

tos, cuando Prc = {10, 14} debido a que ScaLAPACK indica que las mejores
prestaciones se obtienen cuando se trabaja con mallas lógicas de procesadores
cuadradas, lo que no es posible construir con 10 ni 14 procesadores (Prc = 2 × 5
y Prc = 2 × 7 procesadores, respectivamente). Sin embargo, este disminución es
menor conforme m se incrementa, como es el caso de FB que para m = 70 se
manipulan matrices y vectores de dimensión mF J = 9870.
Una forma equivalente al Speedup para observar las prestaciones de FB, MI,
EP y MIII paralelos es la Eficiencia, con la que se determina el porcentaje de
aprovechamiento de los procesadores que se han utilizado en los experimentos.
Los resultados obtenidos están en las Tablas 4.9, 4.10, 4.11 y 4.12.
Tabla 4.9: Eficiencia Experimental de FB

Prc Aprovechamiento
1 100 % 100 % 100 %
2 94 % 97 % 98 %
4 79 % 85 % 91 %
6 76 % 81 % 89 %
8 69 % 78 % 84 %
9 70 % 75 % 77 %
10 63 % 73 % 82 %
12 62 % 70 % 74 %
14 59 % 67 % 77 %
16 57 % 61 % 71 %
m 50 60 70
mF J 5050 7260 9870
103
Tabla 4.10: Eficiencia Experimental de MI
Prc Aprovechamiento
1 100 % 100 % 100 %
1×2 77 % 91 % 98 %
2×2 77 % 88 % 93 %
2×3 68 % 80 % 89 %
2×4 56 % 73 % 82 %
3×3 65 % 78 % 86 %
2×5 45 % 64 % 76 %
3×4 51 % 69 % 79 %
2×7 36 % 58 % 68 %
4×4 45 % 65 % 76 %
m 1000 2000 3000
Tabla 4.11: Eficiencia Experimental de EP

Prc Aprovechamiento
1 100 % 100 % 100 %
1×2 94 % 98 % 97 %
2×2 88 % 97 % 96 %
2×3 80 % 95 % 96 %
2×4 85 % 94 % 84 %
3×3 84 % 92 % 85 %
2×5 70 % 91 % 94 %
3×4 81 % 88 % 93 %
2×7 57 % 91 % 88 %
4×4 57 % 71 % 80 %
m 1000 2000 3000
Tabla 4.12: Eficiencia Experimental de MIII

Prc Aprovechamiento
1 100 % 100 % 100 %
1×2 85 % 91 % 99 %
2×2 73 % 86 % 97 %
2×3 56 % 79 % 90 %
2×4 55 % 73 % 84 %
3×3 55 % 76 % 88 %
2×5 44 % 62 % 77 %
3×4 49 % 67 % 82 %
2×7 36 % 58 % 69 %
4×4 43 % 63 % 78 %
m 1000 2000 3000
EP es el algoritmo paralelo que mejor aprovechamiento hace de los proce-

sadores, pues alcanza un 84 % con m = 1000 y 9 procesadores; FB también
presenta aprovechamientos aceptables, pues alcanza al menos un 80 % con 4, 6
104
y 8 procesadores para los casos m = {50, 60, 70} (mF J = {5050, 7260, 9870};
MI tiene aprovechamientos de procesador aceptables con 6 y 9 procesadores
para los casos m = {2000, 3000}; MIII mejora un poco el comportamiento de
MI, logrando un 85 % para m = 1000 pero con 2 procesadores. En todos los
casos las mejores eficiencias se alcanzan con m = 3000 para MI,EP y MIII y
con m = 70 para FB.
Por último, se analiza la escalabilidad de los algoritmos paralelos, es decir, la
capacidad que tienen de mantener sus prestaciones haciendo crecer en la misma
proporción el número de procesadores y el tamaño del problema. Para analizar
la escalabilidad se calcula el Speedup escalado de los algoritmos. Como el costo
computacional secuencial de FB es O(m6 ), se han realizado experimentos en
Kefren con los siguientes tamaños de problema: m = {30, 33, 37, 40, 42, 43, 44,
45, 46, 47} correspondientes a Prc = {1, 2, 4, 6, 8, 9, 10, 12, 14, 16}. El costo
computacional secuencial de MI, EP y MIII es O(m4 ), entonces se han hecho
experimentos en Kefren con los tamaños de problema: m = {1000, 1189, 1414,
1565, 1681, 1732, 1861, 2000} que corresponden con Prc = {1, 2, 4, 6, 8, 9, 12,
16}. Los resultados están en la Figura 4.7.
8 12
FB MI
EP
MIII
7
10
6
8
SpeedUp Escalado
Speedup Escalado
4
3
2
2
1 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 4.7: SpeedUp Escalado de los algoritmos paralelos del PIAVS
FB es un algoritmo poco escalable. EP mantiene su escalabilidad muy cerca

de la curva ideal, lo que lo convierte en un algoritmo de muy buena escalabilidad.
MI y MIII tienen un comportamiento similar y escalan aceptablemente bien.
4.4. Conclusiones
Muchas operaciones de los algoritmos FB, MI, EP y MIII han sido direc-
tamente paralelizadas utilizando rutinas eficientes y portables de PBLAS y
ScaLAPACK. Otras operaciones han sido diseñadas en este trabajo, cuidando
disminuir en lo posible las comunicaciones de datos entre procesadores y evi-
105
tando también en lo posible que los procesadores quedaran ociosos, de ahı́ que
en el diseño paralelo se haya decidido la réplica de estructuras de datos en los
procesadores.
Teóricamente los algoritmos disminuyen el tiempo de ejecución secuencial
y tienen buenas prestaciones asintóticas. La disminución de tiempos de ejecu-
ción se ha podido comprobar experimentalmente en el cluster Kefren: todos los
algoritmos disminuyen sustancialmente los tiempos secuenciales, con lo que se
cumple el objetivo de disminuir costos temporales para resolver el PIAVS; una
muestra de este resultado se da a continuación (con k = 1):
FB MI EP MIII
1.3 min 23 hrs 2.8 dı́as 1 dı́a
44 seg 11 hrs 1.4 dı́as 12 hrs
26 seg 6.2 hrs 18 hrs 6.1 hrs
13 seg 2.9 hrs 9 hrs 3 hrs
13 seg 3 hrs 7.3 hrs 3.1 hrs
11 seg 2.4 hrs 5.6 hrs 2.4 hrs
m = 50 m = 3000 m = 3000 m = 3000
Además de la disminución de tiempos de ejecución, la paralelización en el

caso de FB ha permitido también aplicar este algoritmo a problemas de tamaños
que secuencialmente no pueden abordarse, como por ejemplo m ≥ 90.
El análisis del Speedup experimental de MI, EP y MIII indica que: todos
ellos tienen buenos Speedup con 2 y 4 procesadores en todos los experimentos y
el que mejores Speedup alcanza es EP hasta con 8 procesadores. FB, en general,
tiene buenos Speedup con 2 procesadores en todos los experimentos, pero es el
algoritmo con más bajas prestaciones. Los algoritmos alcanzan el mejor Speedup
con los problemas de mayor tamaño (m = 3000 para MI, EP y MIII; m = 70
para FB), un par de gráficas de los Speedup para m = 70 y m = 3000 son las
siguientes:
106
12 14
FB MI
m=70 EP
mFJ=2870 MIII
12 m=3000
10
10
8
Speedup Experimental
Speedup Experimental
8
4
4
2
2
0 0
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Con respecto a la eficiencia, EP tiene la mejor y en todos los experimentos

FB, MI, EP y MIII tienen buenas eficiencias con 2 y 4 procesadores. Como
sucede con el Speedup, se obtienen mejores eficiencias cuando el tamaño del
problema es grande, por ejemplo, las eficiencias experimentales para m = 70
(mF J = 2870) y m = 3000 son:
Prc FB MI EP MIII
1 100 % 100 % 100 % 100 %
2 98 % 98 % 97 % 99 %
4 91 % 93 % 96 % 97 %
6 89 % 89 % 96 % 90 %
8 84 % 82 % 84 % 84 %
9 77 % 86 % 85 % 88 %
10 82 % 76 % 94 % 77 %
12 74 % 79 % 93 % 82 %
14 77 % 68 % 88 % 69 %
16 71 % 76 % 80 % 78 %
El algoritmo que mejor escala es EP, como ya se mostró en la Figura 4.7. En

general, MI y MIII escalan suficientemente bien, mientra que FB es el algoritmo
de menor escalabilidad.
En vista del análisis realizado, FB queda en calidad de una aproximación
sencilla a la resolución de PIAVS que paraleliza aceptablemente desde el punto
de vista de la disminución de los tiempos de ejecución secuenciales, permitiendo
resolver problemas que secuencialmente no podrı́a hacerse. Sin embargo, además
de ser un algoritmo con importantes costos temporales y espaciales, su versión
paralela no presenta muy buenas prestaciones.
MI, EP y MIII paralelos también cumplen con su cometido de disminuir
de manera importante los tiempos de ejecución secuenciales. MI y MIII pre-
sentan comportamientos similares en su paralelización y sus prestaciones son
aceptables, pero en este rubro EP es el que presenta las mejores prestaciones,
107
sin embargo es el que consume mayor tiempo de ejecución, como se ha podido
observar en las pruebas experimentales presentadas.
Por lo tanto, el algoritmo que mejor equilibra costos temporales y presta-
ciones es MI, mientras que FB es el algoritmo que menos flexibilidad ofrece al
PIAVS.
Todos estos algoritmos se han diseñado e implementado considerando que en
el PIAVS intervienen matrices Ai (i = 0, m) no estructuradas. Considerar ma-
trices estructuradas puede repercutir en beneficio de la complejidad de tiempo
de ejecución de los algoritmos y del requerimiento de almacenamiento, tópico
que se estudia en el siguiente capı́tulo.
108
Capı́tulo 5
Resolución Paralela del

PIEVS
Como se vió en la introducción, el Problema Invserso Estructurado de Va-

lores Singulares (PIEVS) puede verse como una particularización del PIAVS, al
ser las matrices Ai (i = 0, m) de tipo Toeplitz, lo que da posibilidad de aplicar
directamente cualquiera de los algoritmos estudiados en capı́tulos anteriores
(FB, MI, EP, MIII); sin embargo, estos algoritmos no toman ventaja de la
estructura de las matrices tipo Toeplitz. Por lo tanto, el objetivo de este capı́tulo
es diseñar e implementar algoritmos que tomen ventaja de la estructura de las
matrices del PIEVS para construir algoritmos eficientes que lo resuelvan.
Los algoritmos desarrollados para la resolución eficiente del PIEVS son los
algoritmos MI y EP rediseñados y adaptados para explotar la estructura Toeplitz
de las matrices. MI y EP son dos métodos de caracterśiticas complementarias:
MI de rápida convergencia local a una aproximación de alta exactitud y EP de
lenta convergencia global a una aproximación de mediana exactitud; MI paralelo
de medianas prestaciones y EP paralelo de buenas prestaciones.
Para alcanzar el objetivo de este capı́tulo, en primera instancia (Sección 5.1)
se hace un recordatorio del PIEVS y de los algoritmos MI y EP, aplicándolos
tal y como se han diseñado e implementado para el PIAVS a la resolución de
algunos PIEVS experimentales. Los resultados de estos experimentos servirán
para contrastar los resultados obtenidos con MI y EP adaptados al PIEVS.
En la Sección 5.2 se diseñan e implementan MIE (MI Estructurado, MI
adaptado el PIEVS) y EPE (EP Estructurado, EP adaptado al PIEVS) para
el PIEVS, especificando las estructuras de datos utilizadas para representar las
matrices Toeplitz. Se hace un análisis de cómo se lleva a cabo la adaptación de
los algoritmos y la forma en que se logran disminuir los tiempos de ejecución
a través del uso de la FFT [VL92] en operaciones medulares de los métodos
(operaciones matriz Hankel-vector). Este tipo de operaciones aparecen al dejar
109
de lado el uso de la rutina dgesvd de LAPACK (y pdgesvd de ScaLAPACK) para
calcula la svd de una matriz general y en su lugar diseñar una rutina eficiente
que calcule la svd de una matriz tipo Hankel, matriz que resulta de transformar
una matriz tipo Toeplitz.
La paralelización de MIE y EPE se desarrolla en la Sección 5.3, donde se
presenta el cuidado que se tiene en asegurar que los procesadores se mantengan
ociosos el mı́nimo de tiempo posible. En la Sección 5.4 se estima la complejidad
de tiempo de MIE paralelo y EP paralelo y se presenta un conjunto de experi-
mentos para analizar sus prestaciones. Los experimentos se han realizado en el
cluster Kefren sobre casos Toep2.
5.1. Resoluciones Generales del PIEVS

En la introducción se ha definido el PIEVS como sigue: dado el conjunto de
valores reales S ∗ = {S1∗ , S2∗ , ..., Sn∗ }, donde S1∗ > S2∗ > ... > Sn∗ > 0, se requiere
construir una matriz tipo Toeplitz T con valores singulares S ∗ , es decir:
t0 t−1 t−2 ... t−(n−1)

t1 t0 t−1 ... t−(n−2)
T = t2 t1 t0 ... t−(n−3) = U diag(S ∗ )V t . (5.1)
.. .. .. .. ..
. . . . .
t(n−1) t(n−2) t(n−3) ... t0
Utilizando la siguiente notación simplificada para representar una matriz

tipo Toeplitz:
toep(primer vector columna de T, primer vector renglón de T ),
la matriz Toeplitz de la ecuación (5.1) se puede representar como:

T = toep t0 , t1 , ..., t(n−2) , t(n−1) , t0 , t−1 , ..., t−(n−2) , t−(n−1)
De acuerdo a los valores de las 2n − 1 incógnitas t0 , t1 , ..., tn−1 , t−1 , t−2 ,

..., t−(n−1) , T puede ser: simétrica, triangular inferior o no simétrica. El caso
simétrico ha sido estudiado en [Tre97] y [BV99]. Este trabajo, por lo tanto, se
enfoca en la resolución de los casos triangular inferior (PIEVSti) y no simétrico
(PIEVSns).
En el caso PIEVSti, la matriz Toeplitz T es:
t0 0 0 ... 0
t1 t0 0 ... 0
T = t2 t1 t0 ... 0 (5.2)
.. .. .. .. ..
. . . . .
t(n−1) t(n−2) t(n−3) ... t0
110
es decir

T = toep t0 , t1 , t2 , ..., t(n−1) , [t0 , 0, 0, ..., 0] ,
que puede expresarse como:
0 0 ... 0 0 0 0 0 ... 0
1 0 ... 0 0 0 0 0 ... 0
T = t 0 I n + t1 0 1 ... 0 0 +t 1 0 0 ... 0 + ...
2
.. .. .. .. .. .. .. ..
. . 1 . . . 1 . . .
0 0 ... 1 0 0 0 1 ... 0
0 0 0 ... 0 0 0 0 ... 0
0 0 0 ... 0 0 0 0 ... 0
... + tn−2 0 0 0 ... 0 +t 0 0 0 ... 0 ,
n−1
.. .. .. .. .. .. .. .. ..
1 . . . . . . . . .
0 1 0 ... 0 1 0 0 ... 0
si se etiqueta cada matriz Toeplitz de la ecuación anterior, el PIEVSti toma la

siguiente estructura
T = t0 G0 + t1 G1 + t2 G2 + ... + t(n−2) Gn−2 + t(n−1) Gn−1
que coincide con la estructura del PIAVS cuando
c = [c1 , c2 , c3 , ..., cn ]t = [t0 , t1 , t2 , t3 , ..., tn−1 ]t
y
A0 = 0, A1 = G0 , A2 = G1 , A3 = G2 , ..., An = G(n−1) .
En el caso PIEVSns, (5.1) puede expresarse como:
1 t−1 /t0 t−2 /t0 ... t−(n−1) /t0

t1 /t0 1 t−1 /t0 ... t−3 /t0
1 t2 /t0 t1 /t0 1 ... t−2 /t0 1
T = = U diag(S ∗ )V t ,
t0 .. .. .. .. .. t 0
. . . . .
t(n−1) /t0 t(n−2) /t0 t(n−3) /t0 ... 1
y puede reescribirse como:
1 t̃−1 t̃−2 ... t̃−(n − 1)

..
t̃1 1 t̃−1 . t̃−(n−2)
T̃ = .. = U diag(S̃ ∗ )V t ,
t̃2 t̃1 1 . t̃−(n−3)
.. .. .. .. ..
. . . . .
t̃n−1 t̃n−2 t̃n−3 ... 1
donde
ti
t̃i = , para i = −(n − 1), −(n − 2), ..., 1, 2, ..., n − 2, n − 1
t0
111
y
Si∗
S̃i∗ = , para i = 1, n.
t0
T̃ en notación simplificada queda como
h i
T̃ = toep 1, t̃1 , t̃2 , ..., t̃ n−1 , t̃ n−1 +1 , ..., t̃n−2 , t̃n−1 ,
2 2
h i
1, t̃−1 , t̃−2 , ..., t̃−( n−1 +1) , t̃−( n−1 +2) , ..., t̃−(n−2) , t̃−(n−1) , (5.3)
2 2
que también puede expresarse como
T̃ = toep ([1, 0, 0, ..., 0, 0, ..., 0, 0] , [1, 0, 0, ..., 0, 0, ..., 0, 0]) +

+ t̃1 toep ([0, 1, 0, ..., 0, 0, ..., 0, 0] , 0n ) + t̃2 toep ([0, 0, 1, ..., 0, 0, ..., 0, 0] , 0n ) +
+ ... + t̃n−1 toep ([0, 0, 0, ..., 0, 0, ..., 0, 1] , 0n ) +
+ t̃−1 toep (0n , [0, 1, 0, ..., 0, 0, ..., 0, 0]) + t̃−2 toep (0n , [0, 0, 1, ..., 0, 0, ..., 0, 0]) +
+ ... + t̃−(n−1) toep (0n , [0, 0, 0, ..., 0, 0, ..., 0, 1]) , (5.4)
donde 0n es un vector de n ceros. En la ecuación (5.4) se pueden identificar:
2n − 2 parámetros t̃i (i = −(n − 1), −(n − 2), ..., 1, 2, ..., n − 1)

2n − 1 matrices tipo Toeplitz, donde
n×n es la dimensión de cada matriz
y para poder expresarla como un PIAVS, será necesario manejar:
n parámetros ci (i = 1, 2, ..., n)
n+1 matrices Ai (i = 0, 1, ..., n), donde
n×n es la dimensión de cada matriz
Como la cantidad de parámetros t̃i es mayor que la de ci (por consiguiente, la

cantidad de matrices tipo Toeplitz es mayor que la cantidad de matrices Ai ),
se pueden asignar valores cualesquiera a n − 2 parámetros t̃i . Por ejemplo, si se
asignan valores ai (i = 1, n − 2) a los siguientes parámetros:
t̃ n−1 +1 , t̃ n−1 +2 , ..., t̃n−1 , t̃−( n−1 +2) , ..., t̃−(n−2) , t̃−(n−1) ,
2 2 2
⇓ ⇓ ... ⇓ ⇓ ... ⇓ ⇓
a1 , a2 , ..., a n−1 , a n−1 +1 , ..., an−3 , an−2 ,
2 2
(5.3) queda como:

h i
T̃ = toep 1, t̃1 , t̃2 , ..., t̃ n−1 , a1 , ..., a n−1 −1 , a n−1 ,
2 2 2
h i
1, t̃−1 , t̃−2 , ..., t̃−( n−1 +1) , a n−1 +1 , ..., an−3 , an−2 , (5.5)
2 2
112
es decir,
h i h i
T̃ = toep 1, 0, 0, ..., 0, a1, ..., a n−1 −1 , a n−1 , , 1, 0, 0, ..., 0, a n−1 +1 , ..., an−3 , an−2 +
2 2 2
+ t̃1 toep ([0, 1, 0, ..., 0, 0, ..., 0, 0] , 0n ) + t̃2 toep ([0, 0, 1, ..., 0, 0, ..., 0, 0] , 0n ) + ...+
+ t̃ n−1 toep ([0, 0, 0, ..., 1, 0, ..., 0, 0] , 0n ) + t̃−1 toep (0n , [0, 1, 0, ..., 0, 0, ..., 0, 0]) +
2
+t̃−2 toep (0n , [0, 0, 1, ..., 0, 0, ..., 0, 0])+...+t̃−( n−1 +1) toep (0n , [0, 0, 0, ..., 1, 0, ..., 0, 0]) .
2
Etiquetando cada matriz Toeplitz de la ecuación anterior con Fi (i = 0, n):
T̃ = F0 + t̃1 F1 + t̃2 F2 + ... + t̃( n−1 ) F n−1 + t̃−1 F n−1 +1 + ... + t̃−( n−1 +1) Fn
2 2 2 2
es claro ver que se tienen n parámetros t̃i y n + 1 matrices tipo Toeplitz, de

tamaño n × n, que coincide con el PIAVS cuando
c = [c1 , c2 , ..., c n−1 , c n−1 +1 , ..., cn ]t = [t̃1 , t̃2 , t n−1 , t−1 , ..., t−( n−1 +1) ]t
2 2 2 2
A0 = F0 , A1 = F1 , A2 = F2 , ..., A n−1 = F n−1 , ..., An = F−( n−1 ) .

2 2 2
Por lo tanto, se ha mostrado que el PIEVS puede expresarse como un PI-

AVS, por lo que se pueden utilizar, entre otros, los algoritmos MI y LP para
resolverlo. En capı́tulos anteriores, estos algoritmos se han definido como:
Algoritmo MI
P
1. Calcular A = A0 + i=1 ci Ai
2. Calcular [U, diag(S), V ] = svd(A)
3. Para k=1,2,...Mientras kS − S ∗ k2 > tol
a. Calcular J = [ui Aj vit ]i,j=1,n
b. Calcular b = [ui A0 vit − Si∗ ]i=i,n
c. Resolver Jc = b
P
d. Calcular A = A0 + ni=1 ci Ai
e. Calcular [U, diag(S), V ] = svd(A)
Algoritmo EP
1. Calcular Atr = [tr(Ati ∗ Aj )]i,j=1,n
2. Para k=1,2,...Mientras kS − S ∗ k2 > tol
Pn
a. Calcular A = A0 + i=1 ci Ai
b. Calcular [U, diag(S), V ] = svd(A)
c. Calcular btr = [tr(Ati (U diag(S ∗ )V t − A0 ))]i=1,n
d. cvieja = c
d. Resolver Atrc = btr
Hasta kc − cviejak2 < tol
113
y la complejidad de tiempo para un problema de tamaño n de los pasos que los
conforman se han estimado como:
TA (n) = 2n3 tf
TJ (n) = (2n4 + O(n3 ))tf
Tb (n) = (2n3 + O(n2 ))tf
TAtr (n) = (n4 + O(n3 ))tf
Tbtr (n) = (4n3 + O(n2 ))tf
Tsvd (n) = 38 3
3 n tf
TresoluciónDeSistema(n) = 23 n3 + O(n2 ) tf
Algunos experimentos realizados para resolver el PIEVS con estos métodos

arrojan los resultados de la Tabla 5.1.
Tabla 5.1: Tiempos de ejecución experimentales de MI y EP para el PIEVS

MI LP
n Iter kS − S ∗ k2 Segundos Iter kS − S ∗ k2 Segundos
20 3 8e-7 0.01 4867 1e-3 2.9
30 6 7e-7 0.03 1570 1e-3 2.3
39 4 2e-6 0.04 453 3e-4 1.4
40 3 5e-8 0.04 211 2e-4 0.69
50 4 3e-10 0.10 230 2e-4 1.3
60 – — — 77521 3e-2 691
90 7 6e-9 1.44 508 9e-4 15
100 5 1e-7 1.55 425 3e-4 17
150 4 3e-6 6.17 215 2e-4 36
200 3 8e-9 17.7 49 3e-4 35
250 4 2e-6 69 113 3e-4 173
300 3 6e-9 124 161 8e-4 454
350 – — — 55 4e-4 324
400 4 1e-7 532 267 7e-4 1893
450 – — — 58 3e-4 792
500 2 1e-6 644 56 2e-4 1199
Como es sabido (y ası́ se ve en la Tabla 5.1), la ventaja de MI es que re-

quiere pocas iteraciones para converger, siempre que se parta de un punto ini-
cial suficientemente cercano a la solución (condición que no se cumple para
n = {60, 350, 450}), mientras que LP siempre llega a una solución, indepen-
dientemente del punto de partida, aunque debe realizar un número elevado de
iteraciones para hacerlo. Se hace notar también otro hecho conocido con respecto
a la exactitud de MI que es de mejor calidad que la de EP.
Habiendo recordado MI y EP, en la siguiente sección se desarrollan éstos de
forma que tomen ventaja de la estructura de las matrices Toeplitz del PIEVS.
114
5.2. Propuestas de Resoluciones Especı́ficas del
PIEVS
Con el objeto de resolver eficientemente el PIEVS, se ha adaptado el cálculo
de A, J, b, Atr, btr y svd de los algoritmos MI y EP para manejar matrices
tipo Toeplitz, las cuales se representan como se especifica a continuación. Una
matriz tipo Toeplitz de tamaño n × n se representa con un vector de tamaño
2n − 1, en este vector se almacena el primer renglón de la matriz tipo Toeplitz
(desde el último hasta el primer componente), seguido de la primera columna,
como en el siguiente diagrama:
Matriz Toeplitz General Representación Vectorial
2 − n t−(n−1)
.. ..
. .
t0 t−1 t−2 t−3 ... t−(n−1) −2 t−3
t1 t0 t−1 t−2 ... t−(n−2) −1 t−2
t2 t1 t0 t−1 ... t−(n−3) 0 t−1
t3 t2 t1 t0 ... t−(n−4) → 1 t0
. . . . .. . 2 t1
.. .. .. .. . ..
3 t2
t(n−1) t(n−2) t(n−3) t(n − 4) ... t0 4 t3
.. ..
. .
n t(n−1)
Para representar una matriz tipo Toeplitz de la forma Ai , como en el siguien-

te diagrama, de tamaño n × n, se utiliza una estructura de ı́ndices (REN S) en
cuya entrada i se almacena el número de renglón donde Ai tiene un 1 (renglón
3):
Matriz Toeplitz Especı́fica RENS (Representación vectorial)
0
0
0 0 0 0 ... 0
..
0 0 0 0 ... 0 .
1 0 0 0 ... 0 i 3
Ai = 0 1 0 0 ... 0 → .
..
.. .. .. .. .. ..
. . . . . . j 0
0 0 0 1 ... 0 ..
.
0
Análogamente a la matriz Ai , para una matriz tipo Toeplitz como la Aj

siguiente, se almacena en el componente j del vector de ı́ndices COLS el número
de columna donde Aj tiene un 1 (columna 2):
115
Matriz Toeplitz Especı́fica COLS (Representación vectorial)
0
0
0 1 0 0 ... 0
.
0 0 1 0 ... 0 ..
0 0 0 1 ... 0 i 0
Aj = 0 0 0 0 ... 0 → ..
.. .. .. .. .
..
. . . . . 1 j 2
0 0 0 0 ... 0 ..
.
0
El almacenamiento de los datos requeridos para la resolución del PIEVS

es drásticamente menor al requerido para la resolución del PIAVS, basta con
estimar el monto de memoria requerido para almacenar Ai (i = 1, n) en ambos
problemas, como en la siguiente tabla:
PIAVS PIEVS
A0 1 matriz de tamaño 1 vector de tamaño
n×n 2n − 1
A1,2,...,n n matrices de tamaño 2 vectores de ı́ndices
n×n de tamaño n
Total dobles n3 + 2n2 4n − 4
Total enteros 2n
El producto de una matriz como Ai o Aj por un vector v consiste sólamente

en el corrimiento de los elementos del vector, por lo que esta operación no tiene
costo de operaciones en punto flotante; por ejemplo, con las matrices Ai y Aj
anteriores se tiene que:
v1 0 v1 v2
v2 0 v2 v3
v3 v1 v3 v4
Ai v = A i . = . ; Aj v = A j . = .
.. .. .. ..
vn−1 vn−3 vn−1 vn
vn vn−2 vn−2 0
P
Bajo estas condiciones, calcular A = A0 + ni=1 ci Ai consiste en sustituir
las sumas y multiplicaciones involucradas originalmente por asignaciones de ci
en A, como se hace en el Algoritmo 40.
116
Algoritmo 40 CalculaAestucturado
1. A ← dcopy(2 ∗ n − 1, A0 )
2. j ← 1
3. Para i = 1, n
3.1. Si REN Si 6= 0 entonces
AREN Si ← cj
j ←j +1
4. Si j ≤ n entonces
4.1. Para i = 1, n
4.1.1. Si COLSi 6= 0 entonces
A2−COLSi ← cj
j ←j +1
Por otra parte, como A es una matriz tipo Toeplitz, se puede transformar
en una matriz tipo Hankel, H, permutando sus columnas con una matriz de
permutación R de la forma:
1
1
R= 1
.
..
1
es decir, H = AR ⇒ A = HRt . Partiendo de este hecho, para calcular la
descomposición en valores singulares de A, se obtiene la descomposición en
valores propios de H (aprovechando que H es tipo Hankel y, por lo tanto,
simétrica):
H = Q̃diag(L)Q̃t ,
donde Q̃ es ortogonal, L = {L1 , L2 , ..., Ln } es un conjunto de reales, con |L1 | ≥
|L2 | ≥ ... ≥ |Ln |. Si se expresa diag(L) como
diag(L) = signos(diag(L))|diag(L)| = G|diag(L)|,
con
signo(L1 )
signo(L2 )
G = signos(diag(L)) = ..
.
signo(Ln )
y
|L1 |
|L2 |
|diag(L)| = .. ,
.
|Ln |
117
entonces A = HRt queda como
A = Q̃G|diag(L)|Q̃t Rt = U diag(S)V t ,
con U = Q̃G, diag(S) = |diag(L)| y V = RQ̃. Una forma de obtener H =

Q̃diag(L)Q̃t es tridiagonalizando H:
H = QT Qt,
donde Q es ortogonal y T es la tridiagonal
a1 b2
b2 a2 b3
b3 a3 b4
T = .. .. .. ;
. . .
bn−1 an−1 bn
bn an
y después calculando la descomposición en valores propios de T :
H = QP LP t Qt ,
de donde se define Q̃ = QP . Con esto, los vectores U y V de la ecuación (5.2), que

representan los vectores singulares izquierdos y derechos de A, respectivamente,
quedan definidos como:
U = QP G(diag(L)) (5.6)
y
V = RQP. (5.7)
Por lo tanto, calculando L, P , Q y G, se obtiene la descomposición en valores
singulares de A. Estas operaciones minimizan los costos temporales de cálculo
porque la tridiagonalización de una matriz tipo Hankel involucra operaciones
MatrizHankel−vector, que pueden calcularse eficientemente utilizando la FFT,
por lo que el tiempo teórico de ejecución de la tridiagonalización más el de la des-
composición en valores propios de una matriz tridiagonal es de n2 log2 n + O(n2 ),
que es menor que el orden O(n3 ) de la descomposición en valores singulares de
una matriz densa.
Se identifican, entonces, dos pasos fundamentales para la descomposición en
valores singulares (svd) de una matriz tipo Toeplitz:
Paso 1. Tridiagonalización ortogonal de una matriz tipo Hankel

Paso 2. Descomposición en valores propios de una matriz tridiagonal,
El Paso 1 tiene dos posibles implementaciones: la primera utilizando la

FFT [GvL96] (como en el algoritmo Tridiag1) y la segunda utilizando ruti-
nas de librerı́as numéricas, como dsytrd que tridiagonaliza una matriz y dorgtr
118
que construye la matriz de transformación Q, ambas de LAPACK (como en
el algoritmo Tridiag2). Estas implementaciones, que utilizan los vectores a y b
para representar la diagonal y subdiagonal de la matriz tridiagonal T , respecti-
vamente, son:
Algoritmo Tridiag1
1. Inicializa q1
2. Para j=1,m
a. r ← F F T (H, qj )
b. aj ← productoEscalar(qj , r)
c. r ← r − aj qj − bj−1 qj−1
d. r ← reortogonaliza(r, Q)
e. bj ← norma2(r)
f. qj+1 ← r/bj
Algoritmo Tridiag2
1. [a, b, T au, Ref lecHouse] ← dsytrd(H)
2. Q ← dorgtr(Ref lecHouse, T au)
Algunos ejemplos del comportamiento temporal de ambas implementaciones

se dan enseguida:
n svd con Tridiag1 svd con Tridiag2

250 0.13 0.16
500 0.59 1.01
1000 2.83 6.47
1500 7.59 20.1
2000 15.3 47.3
Tiempo(Seg)
con los tiempos de ejecución de estos experimentos se confirma que la svd de

una matriz Hankel es más eficiente cuando se utiliza Tridiag1.
Ahora bien, el cálculo de J y b del algoritmo MI involucra a los vectores
singulares de A definidos como en (5.6) y (5.7) y, por lo tanto, involucra las
siguientes operaciones:
Ji,j = ui Aj vit = (QPi Gii ) Aj (RQPi ) =

= Q Pi Gii Aj R Q Pi
| {z } | {z }
producto matriz-vector producto matriz-vector
| {z } | {z }
escalamiento de vector permutación de renglones de vector
| {z }
corrimiento de elementos de vector
| {z }
producto escalar
119
bi = ui A0 vit − Si∗ = (QPi Gii ) A0 (RQPi ) − Si∗ =
= Q Pi Gii A0 R Q Pi −Si∗
| {z } | {z }
producto matriz-vector producto matriz-vector
| {z } | {z }
escalamiento de vector permutación de renglones de vector
| {z }
multiplicación FFT
| {z }
producto escalar
cuyas complejidades de tiempo son
TJ (n) = 2n3 + O(n2 )
y
Tb (n) = 2n3 + n2 log2 n + O(n2 ),
respectivamente. La complejidad de tiempo de J es menor que 2n4 + O(n3 )

y la complejidad de tiempo de b es del mismo orden que 4n3 + O(n2 ), las
complejidades de tiempo del cálculo de J y b con matrices no estructuradas,
respectivamente (como se vió en el Capı́tulo 3).
Por otra parte, en el PIEVS la matriz Atr del algoritmo EP es una matriz
diagonal cuyos elementos son:
(
n − REN Si + 1 si REN Si 6= 0
Atri,i =
n − COLSi + 1 si COLSi 6= 0
Como los componentes del vector btr del algoritmo EP son
btri = tr(Ati (U diag(S ∗ )V t − A0 )) = tr(Ati X),
entonces X = U diag(S ∗ )V t − A0 se calcula una sóla vez. Las operaciones para

calcular X también utilizan los vectores singulares de A definidos en (5.6) y 5.7,
éstas son:
X = U diag(S ∗ )V t − A0 = (QP G)diag(S ∗ )(QP R)t − A0 =

QP G diag(S ∗ ) ( QP R)t −A0
|{z} |{z}
producto matriz-matriz producto matriz-matriz
| {z } | {z }
escalamiento de columnas permutación de columnas
| {z }
escalamiento de columnas
| {z }
producto matriz-matriz
| {z }
suma matriz-matriz
y su complejidad de tiempo es 6n3 + O(n2 ). Habiendo calculado X el cálculo de

btr se reduce a seleccionar elementos de X:
120
n
X
btri = tr(Ati X) = Aij Xjt
j=1
| {z }
selección de un elemento del vectorXj
por lo que su complejidad de tiempo es 6n3 +O(n2 ). En este caso no se involucran

matrices Toeplitz de las que se pueda tomar ventaja para minimizar los costos
del cálculo de btr .
Con estas nuevas rutinas se pueden construir los algoritmos MIE (MI Es-
tructurado) y EPE (EP Estructurado) que resuelven el PIEVS eficientemente
y con un tiempo de ejecución drásticamente menor al conseguido con MI y EP
aplicados al PIEVS, ya que el orden de complejidad de cada algoritmo es:
T (n)
3
MI (44/3)n + O(n) + k{2n4 + O(n3 )}
MIE log2 n n2 + O(n2 ) + k{(20/3)n3 + 2log2 n n2 + O(n2 )}
EP n4 + O(n3 ) + k{(46/3)n3 + O(n2 )}
EPE n + k{6n3 + log2 n n2 + O(n2 )}
es decir, MIE es de un orden menor que MI y EPE es dos órdenes menor que
EP en la operación más costosa localizada antes del ciclo (el cálculo de A tr ) y
la constante 46/3 de n3 de EP se reduce a 6 en EPE. La reducción del orden
de complejidad se puede comprobar experimentalmente, algunos resultados de
pruebas realizadas en el cluster Kefren se muestra en la Tabla 5.2, que corres-
ponden a los mismos casos de la Tabla 5.1.
Tabla 5.2: Tiempos de ejecución experimentales de MIE y EPE para el PIEVS

MIE EPE
n iter kS − S ∗ k2 seg iter kS − S ∗ k2 seg
20 3 8e-7 0.01 4867 1e-3 1.85
30 6 7e-7 0.01 1570 1e-3 1.48
40 3 5e-8 0.03 211 2-4 0.42
50 4 3e-10 0.03 230 2-4 0.79
90 7 6e-9 0.18 508 9-4 8.22
100 5 1e-7 0.19 425 3-4 9.01
150 4 3e-6 0.45 215 2-4 14.5
200 3 8e-9 0.76 49 3-4 7.73
250 4 2e-6 1.93 113 3-4 40
300 3 6e-9 2.84 161 8-4 107
400 4 1e-7 8.6 267 7-4 494
500 2 1e-6 9.48 56 2-4 183
El contraste de tiempos de ejecución para estos experimentos entre MI y

MIE, y entre EP y EPE se ilustra en la Figura 5.1.
121
700
MI
MIE
600
500
Tiempo Experimental (segundos)

400
300
200
100
0
0 50 100 150 200 250 300 350 400 450 500
m
2000
EP
EPE
1800
1600
1400
Tiempo Experimental (segundos)
1200
1000
800
600
400
200
0
0 50 100 150 200 250 300 350 400 450 500
m
Figura 5.1: Tiempos de ejecución experimentales con algoritmos PIAVS vs PIEVS sobre los
mismos casis de prueba
Por lo tanto, se ha diseñado e implementado MIE y EPE, un par de algorit-

mos eficientes que resuelven el PIEVS y cuyas complejidades de tiempo son de
un orden menor al ofrecido por MI y EP. En la siguiente sección se plantean las
versiones paralelas de MIE y EPE con el fin de reducir aún más los tiempos de
122
ejecución y poder resolver el PIEVS para n de mayor tamaño.
5.3. Paralelización de Resoluciones Especı́ficas

del PIEVS
El kernel de MIE y EPE es la descomposición en valores singulares (svd) de
una matriz tipo Hankel, ya que sus valores y vectores singulares se utilizan en
el cálculo de J, b y btr ; por lo tanto, la paralelización de MIE y EPE depende
de la paralelización de la svd.
Para paralelizar la svd se trata de aprovechar los bajos costos de la FFT
(operación secuencial) y se trata de distribuir la carga de cálculo entre los proce-
sadores, de modo que queden ociosos el menor tiempo posible.
Después de haber probado varios diseños para paralelizar la svd de la matriz
Toeplitz A, teniendo en cuenta que el resultado de este cálculo deje replicados los
valores singulares y distribuidos los vectores singulares de A en los procesadores,
se optó por el siguiente (el más eficiente):
Suponer que se tiene una malla de Prc = Pr × Pc procesadores. Cada proce-
sador aplica el algoritmo Tridiag1 para reducir la matriz Hankel RA a una
tridiagonal T :
a1 b2
b2 a2 b3
b3 a3 b4
RA = QT Qt = Q .. .. .. Qt ,
. . .
bn−1 an−1 bn
bn an
con esto los vectores a (diagonal de T ) y b (subdiagonal de T ) y la matriz
Q quedan replicados en los procesadores y listos para calcular en paralelo los
valores y vectores propios de T :
T = P diag(L)P t = P |diag(L)|GP t = P diag(S)GP t
Para calcular los valores propios de T se hace uso nuevamente de las estruc-
turas de datos longi, low y up para que cada procesador se encargue de calcular
un subconjunto de valores propios. Por ejemplo, si Prc = 2 × 2 y n = 9, entonces
Pr ,Pc P rocesador longi low up Valores propios calculados

0,0 0 3 1 3 {L1 , L2 , L3 }
0,1 1 2 4 5 {L4 , L5 }
1,0 2 2 6 7 {L6 , L7 }
1,1 3 2 8 9 {L8 , L9 }
123
Después los valores propios se replican y se ordenan decrecientemente de
acuerdo a su valor absoluto (como se espera tener los valores singulares de A).
Por ejemplo, suponer que en el caso Prc = 2 × 2 y n = 9 los valores propios
quedan replicados en el siguiente orden:
|L5 | > |L3 | > |L1 | > |L8 | > |L2 | > |L7 | > |L4 | > |L9 | > |L6 | =
= S1 > S2 > S3 > S4 > S5 > S6 > S7 > S8 > S9 .
El siguiente paso es calcular los vectores propios de T . Este cálculo debe

distribuirse a conveniencia para facilitar los futuros cálculos de J, b y btr . Para
el caso de J (y análogamente para b):
Jik = uti Ak vi = (RQPi )t Ak (QPi Sgni )
cada renglón i de J requiere el i-ésimo vector propio de T . Entonces, en el

ejemplo de Prc = 2 × 2 y n = 9, si el tamaño de bloque es 2, J se encuentra
distribuida de acuerdo a ScaLAPACK como:
P rocesador0,0 P rocesador0,1
J11 J12 J15 J16 J19 J13 J14 J17 J18
J21 J22 J25 J26 J29 J23 J24 J27 J28
J51 J52 J55 J56 J59 J53 J54 J57 J58
J61 J62 J65 J66 J69 J63 J64 J67 J68
J91 J92 J95 J96 J99 J93 J94 J97 J98
J31 J32 J35 J36 J39 J33 J34 J37 J38
J41 J42 J45 J46 J49 J43 J44 J47 J48
J71 J72 J75 J76 J79 J73 J74 J77 J78
J81 J82 J85 J86 J89 J83 J84 J87 J88
por lo que cada procesador requiere de los siguientes subconjuntos de vectores

propios:
PS1 PS2 PS5 PS6 PS9 PS1 PS2 PS5 PS6 PS9
P L5 P L3 P L2 P L7 P L6 P L5 P L3 P L2 P L7 P L6
PS3 PS4 PS7 PS8 PS3 PS4 PS7 PS8
P L1 P L8 P L4 P L9 P L1 P L8 P L4 P L9
124
cuya distribución corresponde a una cı́clica por renglones de procesadores. Por
lo tanto, los pasos para calcular los valores y vectores propios de T están en el
Algoritmo 41, éstos se esquematizan para el ejemplo Prc = 2 × 2 y n = 9 como
sigue:
paso P rocesador0,0 P rocesador0,1

1 L = [L1 , L2 , L3 , −, −, −, −, −, −] L = [−, −, −, L4 , L5 , −, −, −, −]
2 L = [L1 , L2 , L3 , L4 , L5 , L6 , L7 , L8 , L9 ] L = [L1 , L2 , L3 , L4 , L5 , L6 , L7 , L8 , L9 ]
3 S = [L5 , L3 , L1 , L8 , L2 , L7 , L4 , L9 , L6 ] S = [L5 , L3 , L1 , L8 , L2 , L7 , L4 , L9 , L6 ]
4 P = [P5 , P3 , P2 , P7 , P6 ] P = [P5 , P3 , P2 , P7 , P6 ]
5 G = [sig(L5 ), sig(L3 ), sig(L2 ), sig(L7 ), sig(L6 )] G = [sig(L5 ), sig(L3 ), sig(L2 ), sig(L7 ), sig(L6 )]
6 S = abs[L5 , L3 , L1 , L8 , L2 , L7 , L4 , L9 , L6 ] S = abs[L5 , L3 , L1 , L8 , L2 , L7 , L4 , L9 , L6 ]
S = [S1 , S2 , S3 , S4 , S5 , S6 , S7 , S8 , S9 ] S = [S1 , S2 , S3 , S4 , S5 , S6 , S7 , S8 , S9 ]
1 L = [−, −, −, −, −, L6 , L7 , −, −] L = [−, −, −, −, −, −, −, L8 , L9 ]
4 P = [P1 , P8 , P4 , P9 ] P = [P1 , P8 , P4 , P9 ]
5 G = [sig(L1 ), sig(L8 ), sig(L4 ), sig(L9 )] G = [sig(L1 ), sig(L8 ), sig(L4 ), sig(L9 )]
Notar en el esquema anterior (y en el Algoritmo 41) que el paso 1 es una ope-

ración paralela distribuida entre todos los procesadores de la malla, y los pasos
4 y 5 son operaciones distribuidas entre renglones de procesadores.
Algoritmo 41 ParaleloCalculaEigJb
1. Llow:up ← dstebz(longi, a, b)
2. L ← Replicar(L) /* Dispersión Todos a Todos */
3. S ← OrdenarPorValorAbsoluto(L)
4. P:,1:n/Pr ← dstein(n/Pc , S1:n/Pr , a, b)
5. Sgn ← sig(S)
6. S ← abs(S)
Para el caso btr:
btri = tr(Ati X), (i = 1, n) (5.8)
donde
X = U diag(S ∗ )V t − A0 = QP Gdiag(S ∗ )(RQP )t − A0 (5.9)
la idea es distribuir el cálculo de la multiplicación matriz-matriz QP entre todos

los procesadores, haciendo uso de longi, low y up; para el ejemplo Prc = 2 × 2
y n = 9 la distribución serı́a la siguiente:
125
QP:,1:3 = U:,1:3 QP:,4:5 = U:,4:5
QP:,6:7 = U:,6:7 QP:,8:9 = U:,8:9
por lo que cada procesador requiere de los siguientes subconjuntos de vectores

propios de T :
PS1 PS2 PS3 PS4 PS5
P L5 P L3 P L1 P L8 P L2
PS6 PS7 PS8 PS9
P L7 P L4 P L9 P L6
En este caso, para calcular los valores y vectores propios de T se tiene el Algo-
ritmo 42, cuyo esquema para el ejemplo Prc = 2 × 2 y n = 9 es:

1 L = [L1 , L2 , L3 , −, −, −, −, −, −] L = [−, −, −, L4 , L5 , −, −, −, −]
4 P = [P5 , P3 , P1 , −, −, −, −, −, −] P = [−, −, −, P8 , P2 , −, −, −, −]
5 Sgn = [sig(L5 ), sig(L3 ), sig(L1 ), −, −, −, −, −, −] Sgn = [−, −, −, sig(L8 ), sig(L2 ), −, −, −, −]
1 L = [−, −, −, −, −, L6 , L7 , −, −] L = [−, −, −, −, −, −, −, L8 , L9 ]
4 P = [−, −, −, −, −, P7 , P4 , −, −] P = [−, −, −, −, −, −, −, P9 , P6 ]
5 Sgn = [−, −, −, −, −, sig(L7 ), sig(L4 ), −, −] Sgn = [−, −, −, −, −, −, −, sig(L9 ), sig(L6 )]
En este esquema, tanto el paso 1, como los pasos 4 y 5, están completamente

paralelizados, pues los cálculos involucrados están distribuidos entre todos los
procesadores de la malla.
126
Algoritmo 42 ParaleloCalculaEigbtr
1. Llow:up ← dstebz(longi, a, b)
2. L ← Replicar(L) /* Dispersión Todos a Todos */
3. S ← OrdenarPorValorAbsoluto(L)
4. P:,low:up ← dstein(longi, Slow:up, a, b)
5. Sgn ← sig(S)
6. S ← abs(S)
Ya sea que se utilice el Algoritmo 41 o 42, la svd de la matriz Hankel RA

sigue los pasos del Algoritmo 43.
Algoritmo 43 ParaleloCalculaSVD
1. [a, b, Q] ← Tridiag1(H)
2. [P, S, Signos] ← ParaleloCalculaEig(a, b)
Al igual que en el caso secuencial, otra alternativa para tridiagonalizar la

matriz Hankel es utilizar la rutina paralela de ScaLAPACK pdsytrd. Si se susti-
tuye esta rutina en el paso 1 del Algoritmo ParaleloCalculaSVD, experimentos
numéricos muestran en la Tabla 5.3 que los tiempos de ejecución resultantes son
mayores que cuando se utiliza Tridiag1.
Tabla 5.3: Tiempos de ejecución experimentales de dos implementaciones paralelas de la svd

SVD Paralelo usando
n Prc Trid1 pdsytrd
500 1 0.61 1.14
2 0.41 1.03
4 0.34 1.25
1000 1 2.8 7.01
2 2.1 5.81
4 1.6 5.31
1500 1 7.7 12.9
2 5.9 17.1
4 5.1 14.8
2000 1 15.8 52.1
2 12.2 39.9
4 10.8 34.4
Segundos
Habiendo paralelizado la svd de la matriz Toeplitz A, la tarea ahora es

diseñar los algoritmos paralelos para calcular J, b y btr. Con la distribución
adecuada de P y Sgn que da el Algoritmo 41 para calcular J y b se utiliza
el Algoritmo 44 que deja la matriz J y el vector b particionados en bloques y
distribuidos cı́clicamente en los procesadores conforme la distribución ScaLA-
PACK.
127
Algoritmo 44 ParaleloCalculaJbEstructurado
1. Para i = 1,n/Pr
1.1. v ← dgemm(n, n, n, Q, Pi )
1.2. u ← reverso(v)
1.3. x ← multRapF ourier(n, n, ut, A0 )
1.4. v ← dscal(n, Sgni , v)
∗
1.5. bi ← Siglobal − ddot(n, x, v)
1.6. Para k=1,n/Pc
1.6.1. Si REN Skglobal 6= 0
xREN Skglobal :n ← v1:n−REN Skglobal
1.6.2. Si COLSkglobal 6= 0
x1:n−COLSkglobal ← vCOLSkglobal :n
1.6.3. Ji,k ← ddot(n, u, x)
Para calcular en paralelo el vector btr (de acuerdo a 5.8) se utiliza la distribu-
ción de P y Sgn dada por el Algoritmo 42, que permite, como se especificó en
párrafos anteriores, la distribución de la multiplicación matriz-matriz QP de la
ecuación (5.9) entre todos los procesadores, como se ve en el paso 1 del siguiente
esquema:

1 [U1 , U2 , U3 ] = Q[P1 , P2 , P3 ] [U4 , U5 ] = Q[P4 , P5 ]
2 [V1 , V2 , V3 ] = [U1 , U2 , U3 ] [V4 , V5 ] = [U4 , U5 ]
3 [U1 , U2 , U3 ] = [G11 U1 , G22 U2 , G33 U3 ] [U4 , U5 ] = [G44 U4 , G55 U5 ]
4 [U1 , U2 , U3 ] = [S1∗ U1 , S2∗ U2 , S3∗ U3 ] [U4 , U5 ] = [S4∗ U4 , S5∗ U5 ]
5 Replicar U ,V (Replicar QP Gdiag(S ∗ ), QP )
6 V =permuta renglones(V ) V =permuta renglones(V )
2 3 2 3
(U t )1 (U t )1 " # " #
(U t )4 (U t )4
7 4 (U t )2 5 = 4 (U t )2 5 V t = Vt
6 7 6 7
t t (U t )5 (U t )5
(U )3 (U )3
8 Replicar U (Replicar U diag(S ∗ )V t )
9 aux ← U diag(S ∗ )V t − A0 aux ← U diag(S ∗ )V t − A0
10 t
btr1,2,3 = tr(auxA1,2,3 ) btr4,5 = tr(auxAt4,5 )
1 [U6 , U7 ] = Q[P6 , P7 ] [U8 , U9 ] = Q[P8 , P9 ]
2 [V6 , V7 ] = [U6 , U7 ] [V8 , V9 ] = [U8 , U9 ]
3 [U6 , U7 ] = [G66 U6 , G77 U7 ] [U8 , U9 ] = [G88 U8 , G99 U9 ]
4 [U6 , U7 ] = [S6∗ U6 , S7∗ U7 ] [U8 , U9 ] = [S8∗ U8 , S9∗ U9 ]
5 Replicar U ,V (Replicar QP Gdiag(S ∗ ), QP )
6 V
" =premuta # renglones(V
" #) V
" =permuta # renglones(V
" #)
(U t )6 (U t )6 (U t)
8 (U t)
8
7 = Vt = Vt
(U t )7 (U t )7 (U t )9 (U t )9
8 Replicar U (Replicar U diag(S ∗ )V t )
9 ∗
aux ← U diag(S )V t − A0 aux ← U diag(S ∗ )V t − A0
10 btr6,7 = tr(auxA6,7 ) t btr8,9 = tr(auxAt8,9 )
Después se hace una copia de U en V (paso 2 del esquema anterior) para
128
escalar V con Sgn y U con S ∗ (pasos 3 y 4 del esquema anterior). El siguiente
paso (paso 5) es hacer una réplica de U (QP S ∗ ) y V (QP Sgn) para proseguir
con el cálculo replicado de RQP S ∗ que se consigue con el reverso de U (paso
6) y con el cálculo distribuido de (RQP S ∗ )(QP Sgn)t = U V t en el paso 7 del
mismo esquema (con lo que se ha conseguido realizar la operación U S ∗ V t , donde
U y V denotan los vectores izquierdos y derechos de A, respectivamente). En el
paso 8 se replica U para calcular replicadamente la ecuación 5.9 (paso 9). Por
último, cada procesador calcula un subconjunto de elementos de btr , como en
el paso 10 del esquema anterior, los elementos de btr quedan distribuidos en los
procesadores. Este procedimiento es el de los Algoritmos 45 y 46.
Algoritmo 45 ParaleloCalculabtrEstructurado (parte 1/2)

1. /* U:,low:up ← QP:,low:up */
U:,low:up ← dgemm(m, longi, m, Q, P:,low:up)
2. V:,low:up ← U:,low:up
3. /* U:,low:up ← G(QP ):,low:up */
Para i = low, up
U:,i ← dscal(n, Gii , U:,i )
4. /* U:,low:up ← (QP G):,low:up diag(S ∗ ) */
Para i = low, up
U:,i ← dscal(n, Si∗ , U:,i )
5. /* Replica U y V (dispersión todos a todos, mensajes de longitud n2 /Prc ) */
Para i = 0, Prc − 1
Si procesador i {enviar}
dgebs2d(0 All0 , m, longi, U:,low:up)
dgebs2d(0 All0 , m, longi, V:,low:up)
sino {recibir}
U:,low:up ← dgebr2d(0 All0 , m, longi, U:,low:up)
V:,low:up ← dgebr2d(0 All0 , m, longi, V:,low:up)
6. /* V ← RQP */
V ←permutaRenglones(V )
7. /* Ulow:up,: ← (QP Gdiag(S ∗ ))low:up,: (RQP )t */
Ulow:up,: ← dgemm(longi, m, m, Ulow:up,:, V t )
8. /* Replica U (dispersión todos a todos, mensaje de longitud n2 /Prc ) */
Si procesador i /*enviar*/
dgebs2d(0 All0 , longi, n, Ulow:up,:)
sino /*recibir*/
Ulow:up,: ← dgebr2d(0 All0 , longi, n, Ulow:up,:)
129
Algoritmo 46 ParaleloCalculabtrEstructurado (parte 2/2)
9. /* aux ← U diag(S ∗ )V t − A0 */
9.1. Para i = n, n − 1, n − 2, ..., 1
Si (A0 (i) 6= 0)
ren ← i; col ← 1
Mientras (ren ≤ n) & (col ≤ n)
auxren,col ← Uren,col − A0i
ren ← ren + 1; col ← col + 1
9.2. ii ← 2
9.3. Para i = 0, −1, −2, ..., 2 − n
Si (A0i 6= 0)
col ← ii; ren ← 1
Mientras(col ≤ n) & (ren ≤ n)
auxren,col ← Uren,col − A0i
ii ← ii + 1
10. /* bT ri ← tr((U diag(S ∗ )V t − A0 )Ati ) */
10.1. i ← 1
10.2. Para ii = low, up
Si (REN Sii 6= 0)
ren ← REN Sii ; col ← 1
Mientras (col ≤ n) & (ren ≤ n)
bT ri = bT ri + auxren,col
i←i+1
10.3.i ← 1
10.4. Para ii = low, up
Si (COLSii 6= 0)
col ← COLSii ; ren ← 1
Mientras (col ≤ n) & (ren ≤ n)
bT ri ← bT ri + auxren,col
i←i+1
El cálculo paralelo de Atr se da en el Algoritmo 47, que al igual que btr ,

deja a Atr distribuida entre todos los procesadores. Por ser Atr diagonal, la
resolución del sistema Atr c = btr se reduce a dividir cada elemento de btr por el
correspondiente elemento de la diagonald de Atr .
130
Algoritmo 47 ParaleloCalculaAtrEstructurado
1. j ← 1
2. Para i = 1,n/Prc
2.1. Si (REN Si 6= 0) Atrj = n − REN Si + 1
2.2. Si (COLS − i 6= 0) Atrj = Atrj + n − COLSi + 1
2.3. j ←j+1
Ası́, MIE paralelo y EPE paralelo están en los Algoritmos 48 y 49, respecti-
vamente.
Algoritmo 48 MIEParalelo
1. A ← CalculaAestructurado(A0 , ..., An , c) /* operación replicada */
2. [P, Q, diag(S), G] ← ParaleloCalculaSVD(AR)
3. error ← ParaleloCalculaError(S, S ∗)
4. Para k=1,2,...Mientras error > tol
4.1. [J, b] ← ParaleloCalculaJbEstructurado(P, Q, S ∗, G, A1 , ...An )
4.2. c ← pdgesv(J, b)
4.3. c ← pdgemr2d( Pnr , c) /* redistribuye c */
4.4. Si procesador 0 entonces /* envı́a para replicar c */
dgebs2d(0 All0 , n, c)
Sino /* recibe para replicar c */
c ← dgebr2d(0 All0 , n, c)
4.5. A ← CalculaAestructurado(A0, ..., An , c) /* operación replicada */
4.6. [P, Q, diag(S), G] ← ParaleloCalculaSVD(AR)
4.7. error ← ParaleloCalculaError(S, S ∗)
131
Algoritmo 49 EPEParalelo
1. Atr ← ParaleloCalculaAtrEstructurado(A1, A2 , ..., An )
2. Para k=1,2,...
2.1. A ← CalculaAestructurado(A0, ..., An , c) /* operación replicada */
2.2. [P, Q, diag(S), G] ← ParaleloCalculaSVD(AR)
2.3. btr ← ParaleloCalculabtrEstructurado(A0, ..., An , P, Q, S ∗ , G)
2.4. cvieja ← c
2.5. Para i = low, up
ci ← btri /Atri
2.6. Para i = 0, Prc − 1 /* replica c */
Si procesador i entonces /* envı́a */
dgebs2d(0 All0 , longi, clow:up)
Sino /* recibe */
c ← dgebr2d(0 All0 , longi, clow:up )
2.7 error ← ParaleloCalculaError(c, cvieja)
Hasta error < tol
5.4. Prestaciones de Resoluciones Paralelas del

PIEVS
Es de esperar, al igual que en el caso secuencial, que la paralelización del MIE
y EPE tengan una complejidad de tiempo de menor orden que los algoritmos
paralelos del PIAVS (MI y EP), como se observa en los tiempos aritméticos:
MI paralelo:
4 3
44n3 n 2n n
+O +k +O
3Prc Prc Prc Prc
MIE paralelo:
2 3 2
n 8n 2n3 n2 log2 n n
n2 log2 n + O +k + + n2 log2 n + +O
Prc 3Prc Pr Pr Pr
EP paralelo:

n4 n3 56n3 n2
+O +k +O
Prc Prc 3Prc Prc
EPE paralelo:

4n3 n2
k + n2 log2 n + n2 + O
Prc Prc
en los tiempos de establecimiento de comunicación:
MI paralelo:
n p p o
17n + k 2log2 Prc n2 + O Prc n
132
MIE paralelo:

3 3
(Pr + Pc ) + k nlog2 Prc + (Pr + Pc ) + O(n)
2 2
EP paralelo: √ √
Prc n2 p Prc n
+O Prc n + k
2 2
EPE paralelo: p
kO Prc
y en los tiempos de transferencia:
MI paralelo:
√
14log2 Prc n2 2log2 Prc n3 p
2
√ +k √ +O Prc n
Prc Prc
MIE paralelo:

n n log2 Prc n2 n n
+ +k √ + +
Pc Pr 4 Prc Pc Pr
EP paralelo:
√
Prc n2 p 14log2 Prc n2 p
+O Prc n + k √ +O Prc n
4 Prc
EPE paralelo:
6n2 n
k √ +O √
Prc Prc
Con estos tiempos de ejecución se puede estimar la tendencia asintótica del
Speedup de los algoritmos, obteniéndose los siguientes resultados:
−1
T (n, 1) 3Prc 3Prc 7Pr
lim SM IE (n, Prc ) = lim ≈ = O(Pr )
n→∞ n→∞ T (n, Prc ) 14n3 tf 14n3 tf 3
−1
T (n, 1) Prc Prc
lim SEP E (n, Prc ) = lim = Prc ;
n→∞ n→∞ T (n, Prc ) 4n3 tf 4n3 tf
los Speedup de MIE y EPE indican que se tienen prestaciones óptimas para
valores grandes de n, pero en el caso de MIE el óptimo se alcanza cuando se
utilizan vectores columnas de procesadores, es decir mallas de la forma Prc =
Pr × 1, lo que no es de sorprender si se remite a la distribución adecuada de
los vectores propios de la matriz Hankel RA para calcular J y b (los pasos más
costosos de MIE) que consiste en una distribución cı́clica por renglones. Para
corroborar esta observación se han realizado algunas pruebas numéricas en el
cluster Kefren para n = 1500; los resultados que se han obtenido son:
133
Prc MIE (seg) EPE (seg)
1×4 27 14.69
4×1 15 14.69
2×2 19 14.68
1×8 23 10.61
8×1 10 10.61
2×4 15 10.60
4×2 12 10.61
en éstos se constata que con la malla Prc = 4 × 1 y Prc = 8 × 1 MIE obtiene

mejores tiempos de ejecución, mientras que EPE los obtiene prácticamente con
cualquier malla.
A continuación, se presentan algunos resultados experimentales para diferen-
tes tamaños de n considerando la ejecución de una sóla iteración de los métodos.
En las Tabla 5.4 están los tiempos de ejecución medidos y los correspondientes
Speedups de MIE.
Tabla 5.4: Tiempos de ejecución y Speedup experimentales de MIE paralelo

MIE n n
Prc 1000 1500 2000 2500 3000 1000 1500 2000 2500 3000
1 14.8 44 101 200 342 1 1 1 1 1
2 8.3 26 53 114 194 1.8 1.7 1.8 1.7 1.8
4 5.3 15 35 65 109 2.8 2.8 2.8 3.1 3.1
6 4.5 12 28 51 84 3.3 3.6 3.6 3.9 4.1
8 3.8 10 23 44 74 3.9 4.2 4.3 4.5 4.6
10 4.1 9.7 21 40 67 3.6 4.5 4.7 5.0 5.1
14 3.9 9.5 19 35 57 3.7 4.6 5.3 5.7 6.0
16 3.7 8.6 18 33 54 3.9 5.1 5.6 6.1 6.3
Tiempo (seg) SpeedUp
Se observan decrementos significativos de tiempos de ejecución para los casos

grandes de n; sin embargo, con respecto al Speedup, aunque éste va mejorando
conforme n crece, las prestaciones son buenas con 2 procesadores y aceptables
con 4, y a partir de 6 procesadores el Speedup empieza a degradarse. El mismo
fenómeno se observa para EPE en la Tabla 5.5.
134
Tabla 5.5: Tiempos de ejecución y Speedup experimentales de EPE paralelo
EPE n n
Prc 1000 1500 2000 2500 3000 1000 1500 2000 2500 3000
1 12 39 89 174 293 1 1 1 1 1
2 7.3 23 51 100 166 1.7 1.7 1.7 1.7 1.8
4 4.8 14 32 62 103 2.5 2.8 2.8 2.8 2.8
6 4.1 11 26 50 81 3.0 3.3 3.4 3.5 3.6
8 3.6 10 23 44 71 3.4 3.7 3.9 3.9 4.1
10 3.5 9.9 21 40 65 3.5 3.9 4.1 4.3 4.3
14 3.2 9.1 19 36 58 3.8 4.2 4.5 4.6 4.8
16 3.1 8.9 18 35 56 3.9 4.4 4.8 4.9 5.2
Tiempo (seg) SpeedUp
El comportamiendo del Speedup de estos algoritmos se debe, en primer lu-

gar, a que la versión secuencial de los mismos ha resultado ser un algoritmo
altamente eficiente, por lo que se necesitarı́an versiones paralelas en las que
la mayorı́a de sus operaciones deberı́an ejecutarse en paralelo con el mı́nimo
número de comunicaciones. Sin embargo, en los algoritmos paralelos que se han
diseñado no todas las operaciones se han paralelizado, algunas por ser altamente
eficientes secuencialmente (como la FFT involucrada en la tridiagonalización de
una matriz tipo Hankel, lo que implica que la svd de una matriz tipo Hankel
esté parcialmente paralelizada) y otras, por evitar comunicaciones entre proce-
sadores, se ejecutan replicadamente en cada procesador. Estos factores se ven
reflejados en el orden de complejidad de tiempo del algoritmo secuencial:

Tsvd secuencial = n2 log2 n + O(n2 ) tf
contrastado con el orden de complejidad de tiempo del algoritmo paralelo:

2 p
2 n m
Tsvd paralelo = n log2 n + O √ tf + O Prc tm + O √ tv
Prc Prc
en el caso de MIE y
2 p
2 n m
Tsvd paralelo = n log2 n + O tf + O Prc tm + O √ tv
Prc Prc
en el caso de EPE. Gráficamente el Speedup de MIE y EPE están en la Figu-
ra 5.2.
135
7 5.5
n=500 n=500
n=1000 n=1000
5
n=1500 n=1500
6 n=2000 n=2000
n=3000 n=3000
4.5
5 4
Speedup de EPE
Speedup de MIE
3.5
4
3
3 2.5
2
2
1.5
1 1
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 5.2: Speedup experimentales de MIE y EPE en el cluster Kefren
La eficiencia de MIE y EPE se han calculado en las Tablas 5.6 y 5.7, respec-
tivamente.
Tabla 5.6: Eficiencia Experimental de MIE

Prc Aprovechamiento
1 100 % 100 % 100 % 100 % 100 %
2 90 % 85 % 90 % 85 % 90 %
4 70 % 70 % 70 % 77 % 77 %
6 55 % 60 % 60 % 65 % 68 %
8 48 % 52 % 53 % 56 % 57 %
10 36 % 45 % 47 % 50 % 51 %
14 26 % 32 % 37 % 40 % 42 %
16 24 % 31 % 35 % 38 % 39 %
n 1000 1500 2000 2500 3000
Tabla 5.7: Eficiencia Experimental de EPE

Prc Aprovechamiento
1 100 % 100 % 100 % 100 % 100 %
2 85 % 85 % 85 % 85 % 85 %
4 62 % 70 % 70 % 70 % 70 %
6 50 % 55 % 56 % 58 % 58 %
8 42 % 46 % 48 % 48 % 48 %
10 35 % 39 % 41 % 43 % 43 %
14 27 % 30 % 32 % 32 % 32 %
16 24 % 27 % 30 % 30 % 30 %
n 1000 1500 2000 2500 3000
Para el PIEVS MIE es el algoritmo paralelo que mejor aprovecha los proce-
sadores que intervienen en su resolución, pues alcanza eficiencas aceptables (de
al menos 70 %) para 4 procesadores en todos los experimentos, mientras que
136
EPE lo hace también con 4 procesadores, pero a partir de n = 1500. A partir de
6 procesadores las mejores eficiencias empiezan a decrecer en ambos algoritmos.
La escalabilidad de los algoritmos se ha medido haciendo crecer en la misma
proporción el tamaño del problema y el número de procesadores. Consideran-
do que, en términos de orden superior, la complejidad de tiempo de MIE y
EPE es O(n3 ), se han realizado experimentos para n ={1000, 1259, 1582, 1817,
2000, 2154, 2410, 1519}, correspondientemente con Prc ={1, 2, 4, 6, 8, 10, 14,
16}. Gráficamente se oberva el Speedup escalado obtenido en la Figura 5.3. En
general, los algoritmos presentan baja escalabilidad.
7 5.5
EPE
MIE
5
6
4.5
5 4
Speedup Escalado
Speedup Escalado
3.5
4
3
3 2.5
2
2
1.5
1 1
0 2 4 6 8 10 12 14 16 0 2 4 6 8 10 12 14 16
Figura 5.3: Speedup Escalado de los algoritmos paralelos del PIEVS
5.5. Conclusiones
Se ha diseñado e implementado un algoritmo eficiente para el cálculo de la
descomposición en valores singulares (svd) de una matriz tipo Hankel, basado
en la multiplicación rápida de Fourier de una matriz Hankel por un vector. Este
algoritmo reduce considerablemente los costos computacionales de las rutinas
LAPACK y ScaLAPACK que calculan la svd de una matriz general, lo que
representa un aporte de este trabajo.
Con base en el algoritmo eficiente construido para la svd y en las caracterı́sti-
cas estructurales de las matrices que intervienen en el PIEVS se han construido
MIE y EPE, dos algoritmos que resuelven el PIEVS eficientemente, siendo éste
uno de los objetivos de este capı́tulo que se han alcanzado satisfactoriamente.
Se ha constatado que los algoritmos MI y EPE del PIAVS mejoran sustancial-
mente sus costos computacionales cuando se diseñan e implementan tomando
ventaja de la estructura de las matrices tipo Toeplitz del PIEVS, como se ha
mostrado en la complejidad de tiempo y experimentos numéricos de MIE y EPE,
constrastados con los obtenidos con MI y EP.
EL MIE y PIE también se han paralelizado. Los costos computacionales de
137
estos algoritmos paralelos se han reducido respecto de los correspondientes MI y
EP para el PIAVS. Con MIE y EPE paralelos se ha podido disminuir el tiempo
de ejecución secuencial para resolver el PIEVS.
Las prestaciones de los algoritmos paralelos MIE y EPE se han visto afec-
tadas escencialmente por dos causas: por una parte, el algoritmo secuencial
tomado como referencia para medir las prestaciones es altamente eficiente, por
lo que sus tiempos de ejecución son difı́ciles de mejorar sustancialmente cuando
se utiliza más de un procesador; por otra parte, aunque hay rutinas altamente
paralelizables, como es el caso del cálculo de J, b y btr, las prestaciones se ven
mermadas por las secciones de código que deben ejecutarse secuencialmente, ya
porque los tiempos secuenciales son altamente eficientes, ya por evitar comuni-
caciones entre procesadores. Sin embargo, al menos con 2 y 4 procesadores MIE
y EPE presentan prestaciones aceptables para problemas de tamaños grandes.
138
Capı́tulo 6
Algoritmos para la
Resolución del PIVSVP
En este capı́tulo se aborda el Problema Inverso de Valores Singulares y

Valores Propios (PIVSVP) que consiste en construir una matriz A ∈ <n×n
cuyos valores singulares sean S ∗ = {S1∗ , S2∗ , ..., Sn∗ } y cuyos valores propios sean
L∗ = {L∗1 , L∗2 , ..., L∗n }, con S1∗ ≥ S2∗ ≥ ... ≥ Sn∗ y L∗1 ≥ L∗2 ≥ ... ≥ L∗n , dos
conjuntos de valores reales dados bajo ciertas restricciones, como se definirán
en las secciones de este capı́tulo.
En la Sección 6.1 se resuelve lo que se puede considerar un caso particular
del PIVSVP, al asumir que L∗1 = L∗2 = ... = L∗n = 1, y que los elementos de S ∗
satisfacen las condiciones de Weyl; para esto se aplica un algoritmo dado por
Kosowsky y Smoktunowicz en [KA00], que en este capı́tulo se denominará MTri-
IU, que construye una matriz triangular inferior unidad. Se presentan dos im-
plementaciones paralelas de este algoritmo, una bajo el modelo de memoria
distribuida y otro bajo el modelo de memoria compartida, siendo esta última la
más adecuada para el tipo de algoritmo que se maneja. Los experimentos se han
realizado con los casos de prueba del tipo TriIU. La implementación del algorit-
mo bajo el modelo de memoria distribuida se ha realizado en el cluster Kefren
y la implementación bajo el modelo de memoria compartida se ha realizado en
el cluster Aldebarán, que es el más adecuado para este tipo de algoritmos.
En la Sección 6.2 se presenta un método, aporte de este trabajo de tesis, que
resuelve una generalización del PIVSVP, al considerar que los valores singulares
dados S ∗ y los valores propios dados L∗ satisfacen las condiciones Weyl-Horn,
que establecen un vı́nculo entre los valores singulares y los valores propios de una
matriz. El método, al que se denomina MBidiag, construye una matriz bidiago-
nal a través de la resolución de un PIVP. Se presentan resultados experimentales
de MBidiag y se realiza una comparación con respecto a resultados experimen-
tales arrojados por un método dado por Chu en [Chu00] y por otro dado por Li
139
y Mathias en [LM01], que también se ocupan de la construcción de una matriz
(Chu de una cuasitriangula superior, y Li y Mathias de una triangular inferior)
con valores singulares y valores propios prestablecidos y que cumplen las condi-
ciones de Weyl-Horn. Para los experimentos se han tomado casos de prueba del
tipo Bidiag sobre el cluster Kubrick.
6.1. Método MTriIU

El problema de construir una matriz triangular inferior unidad A ∈ R n×n ,
tal que los valores singulares de A sean S1∗ ≥ S2∗ ≥ ... ≥ Sn∗ , fue propuesto por
Kosowski y Smoktunowicz en [KA00]. Este problema puede verse como un caso
particular del PIVPVS:
Encontrar una matriz triangular inferior unidad A ∈ R n×n , tal que

los valores singulares de A sean S1∗ ≥ S2∗ ≥ ... ≥ Sn∗ , y los valores
propios de A sean L∗i = 1, para i = 1, n.
La resolución de este problema está garantizada por Horn [Hor54] que ha

demostrado que dicha matriz A existe si y sólo si se satisfacen las condiciones
de Weyl:
S1∗ S2∗ S3∗ ...Si∗ ≥ 1, (i = 2, n) (6.1)

S1∗ S2∗ S3∗ ...Sn∗ = 1. (6.2)
Para resolver este problema Kosowski y Smoktunowicz se basan en la idea de
construir una secuencia de matrices triangulares inferiores unidad A(i) (i = 1, n)
equivalentes a la matriz diagonal diag(S1∗ , S2∗ , ..., Sn∗ ). Se sabe que dos matrices
M y N son unitariamente equivalentes si existen matrices unidad U , V tales que
M = U N V t ; bajo estas condiciones M y N tienen los mismos valores singulares.
La primera matriz de la sucesión A(1) = diag(S1∗ , S2∗ , ..., Sn∗ ) posee los valores
singulares deseados, pero no los valores propios deseados Li = 1 (i = 1, n); para
esto se construye una matriz unitariamente equivalente a A(1) haciendo uso del
siguiente Lema:
Lema 1 Dos números reales Si∗ , Sj∗ > 0 tales que Si∗ ≥ 1 ≥ Sj∗ o Sj∗ ≥ 1 ≥ Si∗ ,
son los valores singulares de la matriz
" #
1 0
q .
(Si∗2 − 1)(1 − Sj∗2 ) Si∗ Sj∗
Este lema lleva a tomar submatrices 2 × 2 de A(i) (i = 1, n) de la forma

diag(di , dj ) tales que di , dj cumplan
di ≥ 1 ≥ d j o bien dj ≥ 1 ≥ d i . (6.3)
140
Para garantizar que 6.3 se cumpla, Kosowski et.al. hacen uso del siguiente
lema:
Lema 2 Si los números reales S1∗ ≥ S2∗ ≥ ... ≥ Sn∗ > 0 satisfacen las condi-
ciones de Weyl, existe una permutación {d1 , d2 , ..., dn } de {S1∗ , S2∗ , ..., Sn∗ } tal
que
d1 d2 ...di−1 ≥ 1 ≥ di o di ≥ 1 ≥ d1 d2 ...di−1 (i = 2, n). (6.4)
Partiendo entonces, no de la matriz diag(S1∗ , S2∗ , ..., Sn∗ ) sino de la matriz

(1)
A = diag(d1 , d2 , ..., dn ) y como d1 y d2 cumplen (6.3), entonces la siguiente
matriz existe: " #
(2) 1 0
L2×2 = p
(d21 − 1)(1 − d22 ) d 1 d2
con valores singulares d1 , d2 . Entonces, se puede construir A(2) como

 
1 0 " (2) #
p L 2×2
A(2) = 
 
(d21 − 1)(1 − d22 ) d1 d2 = (1) .
Dn−2×n−2
diag(d3 , d4 , ..., dn )
(2) (2)
A(2) es equivalente a A(1) porque existen matrices unitarias U2×2 y V2×2
tales que
(2) (2) (2)t
L2×2 = U2×2 diag(d1 , d2 ) V2×2 .
Una vez que A(2) ha sido construida, empieza un proceso iterativo para
construir A(3) , A(4) , ..., A(n) . Por ejemplo, la construcción de A(3) se basa en la
(3)
descomposición en valores singulares (SVD) de la matriz L2×2 :
" #
(3) 1 0 (3)
L2×2 = p = U2×2 diag(d1 d2 , d3 ) V 2 × 2(3)t ;
2 2
(d1 d2 − 1)(1 − d23 ) d 1 d2 d3
(6.5)
(3) (3) (3) (2) (3)t
entonces A se puede expresar como A = Q A Z , donde
 
1 0 0 0 ... 0
 (3) (3)  
 0 u11 u12 0 ... 0  
 0
(3)
u21
(3)
u22 0 ... 0  I1×1
Q(3)
   (3)
= 0 0 0 1 ... 0 = U2×2 ,
 
 . . . . .. .  In−3×n−3
 .. .. .. .. . .. 
0 0 0 0 ... 1
141
 
1 0 0 0 ... 0
q

 (d2i − 1)(1 − d2j ) d 1 d2 0 0 ... 0 

 0 0 d3 0 ... 0 
A(2)
 
= 0 0 0 d4 ... 0 =
 
 .. .. .. .. .. .. 
 . . . . . . 
0 0 0 0 ... dn
 (2) 
B1×1
 (2) 
=  C2×1 diag(d1 d2 , d3 ) ,
(2)
Dn−3×n−3
 
1 0 0 0 ... 0
 (3) (3)  
 0 v11 v21 0 ... 0  
 0
(3)
v12 v22
(3)
0 ... 0  I1×1
Z (3)t
   (3)t
= 0 0 0 1 ... 0 = V2×2 ;
 
 . . . . .. .  In−3×n−3
 .. .. .. .. . .. 
0 0 0 0 ... 1
entonces A(3) se expresa como
2 32
(2) 3
B I1×1
6 1×1
(3) (2) (3) (3)t
A(3)
76
=6
4 2×2 C2×1
U U2×2 diag(d1 d2 , d3 ) V2×2 5=
74 7
5
(2)
Dn−3×n−3 In−3×n−3
2 3
(2)
B1×1
(3) (3) (3)t
6 7
=6
4 U2×2 C22×1 U2×2 diag(d1 d2 , d3 )V2×2 7=
5
(2)
Dn−3×n−3
2 3
(2)
B1×1
(3) (2) (3)
6 7
=6
4 U2×2 C2×1 L2×2 7
5
(2)
Dn−3×n−3
El mismo procedimiento se sigue para calcular A(4) , A(5) , ..., A(n) . El resul-
tado final será la matriz triangular inferior unidad A(n) , cuyos valores singulares
son S ∗ y cuyos valores propios son L∗i = 1 (i = 1, n).
Si se definen los números pi y zi como:
pi = d1 d2 ...di , (i = 1, n); (6.6)

q
zi = (p2i−1 − 1)(1 − d2i ), (i = 2, n); (6.7)
A(n) tiene la forma:
(n−1)
(n) Bn−2×n−2
A = (n) (n−1) (n)
U2×2 C2×n−2 L2×2
(n−1) (n) (n−1) (n)
donde Bn−2×n−2 , U2×2 C2×n−2 y L2×2 son:
1 0 ... 0
(3)
u11 z2 1 ... 0
(n−1) (4) (3) (4)
Bn−2×n−2 = u11 u21 z2 u11 z3 ... 0 , (6.8)
.. .. .. ..
. . . .
(n−1) (n−2) (3) (n−1) (n−2)
u11 u21 ...u21 z2 u11 u21 ...u(4) z3 ... 1
142
(n) (n−1) (3) (n) (n−1) (4) (n)
(n) (n−1) u11 u21 ...u21 z2 u11 u21 ...u21 z3 ... u11 zn−1
U2×2 C2×n−2 = (n) (n−1) (3) (n) (n−1) (4) (n) ,
u21 u21 ...u21 z2 u21 u21 ...u21 z3 ... u21 zn−1
(6.9)
(n) 1 0 1 0
L2×2 = = . (6.10)
zn pn zn 1
Para automatizar este proceso, denominado en este trabajo como método
MTriIU, en la siguiente sección se discute el Algoritmo secuencial correspondi-
ente y se proporcionan pruebas numéricas.
6.1.1. Algoritmo Secuencial del Método MTriIU

Antes de entrar de lleno a la construcción de las matrices A(i) (i = 1, n), hay
que garantizar que los valores singulares deseados S ∗ , que cumplen las condi-
ciones de Weyl (6.1) y (6.2), también cumplan la condición (6.3). Basándose en
el Lema 2, es posible encontrar una permutación de S ∗ con la que se cumpla esa
condición (6.3). El algoritmo correspondiente a este proceso es el Algoritmo 50.
Algoritmo 50 Construyed
1. S ← ordenaMenorMayor(S ∗)
2. /* Localiza el ı́ndice k del mayor valor de S menor que 1 */
Para i = 1, n
Si (Si < 1)
k←i
3. /* Construye vector d que cumpla Lema 2 */
d1 ← Sk ; d2 ← Sk+1
aa ← Sk ; bb ← Sk+1
izq ← k − 1; der ← k + 2
k←3
Mientras (k ≤ n)
tempo ← aa ∗ bb
Si (tempo < 1)
dk ← Sder
der ← der + 1
Sino
dk ← Sizq
izq ← izq − 1
aa ← tempo
bb ← dk
k ←k+1
Ahora, de las ecuaciones (6.8), (6.9) y (6.10) es claro que A(n) puede constru-
irse con los componentes de la primera columna de las matrices U (i) (i = 3, n) y
143
con los valores de los vectores pi (i = 1, n) (ecuación 6.6), zi (i = 2, n) (ecuación
6.7) y di (i = 1, n) (algoritmo 50), donde U (i) es la matriz de vectores singulares
izquierdos de " #
(i) 1 0
L = , (6.11)
zi pi
por lo que A(n) puede construise directamente, sin necesidad de construir ex-
plı́citamente A(2) , A(3) ,...,A(n−1) . Entonces, una vez calculadas di (i = 1, n), el
siguiente paso para construir A(n) es calcular zi (i = 2, n) y U (i) (i = 3, n) con
el Algoritmo 51.
Algoritmo 51 CalculazU
1. p1 ← d1
2. Para i = 2, n
2.1. pi ← pi−1 di
3. z1 ← sqrt((p1 − 1)(1 − d2 )(p1 + 1)(1 + d2 ))
4. Para i = 3, n
4.1. zi−1 ←" sqrt((pi−1#− 1)(1 − di )(pi−1 + 1)(1 + di ))
1 0
4.2. L ←
zi−1 pi
4.3. [Q, S, V ] ← dgesvd(2, L)
4.4. Si (pi−1 < di )
dswap(Q:,1 , Q:,2 )
4.5. U:,i−2 ← Q:,1
El resultado del Algoritmo 51 es el vector z y la matriz U siguientes:
1 2 ... n − 1
z = z2 z3 ... zn
1 2 ... n − 2
(3) (4) (n)
U= u11 u11 ... u11 1 ;
(3) (4) (n)
u21 u21 ... u21 2
con estos datos en el Algoritmo 52 se construye A ≡ A(n) , que es la matriz
triangular inferior unidad con valores singulares S ∗ .
Algoritmo 52 CalculaMatTriU
1. A ← In
2. Para i = 2, n − 1 /* Ai:i+1,1:i−1 ← U:,i−1 Ai,1:i−1 */
Ai:i+1,1:i−1 ← dgemm(2, i − 1, 1, U:,i−1 , Ai,1:i−1 )
3. Para i = 1, n − 1 /* Ai+1:n,i ← zi Ai+1:n,i */
Ai+1:n,i ← dscal(n − i, zi , Ai+1,i )
144
Por lo tanto, el proceso completo para calcular A está en el Algoritmo 53.
Algoritmo 53 MTriIU
1. d ← Construyed(S ∗ )
2. [z, U ] ← CalculazU(d)
3. A ←CalculaMatTriU(z, U )
Este Algoritmo tiene una complejidad de tiempo de:

2 328n
T (n) = n + tf
3
Algunos resultados de experimentos numéricos del Algoritmo MTriIU están
en la Tabla 6.1, donde S denota los valores singulares de la matriz A calculada.
En todos los casos se observan buenos resultados.
Tabla 6.1: Resultados del caso Triu con MTriIU

n 4 5 8 30 50 100 150 300 500
kS ∗ − Sk2 4e-16 4e-16 5e-16 1e-15 1e-15 2e-14 4e-14 8e-15 1e-14
En la siguiente sección se analiza la forma en que puede paralelizarse este

algoritmo, aprovechando que no es necesario el cálculo de matrices triangulares
inferiores unidad previas a A(n) .
6.1.2. Paralelización del Algoritmo MTriIU

Recordar que para calcular A ≡ A(n) se requiere de U (i) (i = 3, n) que de-
pende de la SVD de L(i) , y que L(i) (ver (6.11)) depende de pi y zi (definidas
en (6.6) y (6.7), respectivamente). Cada elemento de p puede calcularse inde-
pendientemente de los otros; como zi depende de pi−1 y di , zi también puede
calcularse en paralelo con zj (j = 2, n; j 6= i). Entonces, la SVD de las matrices
L(i) pueden calcularse en paralelo y los componentes de U (i) también.
Por otra parte, en la sección anterior se vió que A puede construirse sin
calcular explı́citamente la sucesión A(i) (i = 1, n − 1). Para eliminar operaciones
en punto flotante innecesarias, se pueden ordenar los productos involucrados en
cada renglón de A como en el siguiente esquema (para el caso n = 6 y el renglón
5):
(6)
con U (6) : ⇒ A6,1:6 = u11 1
(5) (6) (5) (6)

con U (5) : A6,4 u21 ⇒ A6,1:6 = u11 u21 u11 1
(4) (6) (5) (4) (6) (5) (6)

con U (4) : A6,3 u21 ⇒ A6,1:6 = u11 u21 u21 u11 u21 u11 1
(3)
con U (3) : A6,2 u21 ⇒ A6,1:6 = u(6) (5) (4) (3)
11 u21 u21 u21
(6) (5) (4)
u11 u21 u21
(6) (5)
u11 u21
(6)
u11 1
145
Las expresiones generales de este procedimiento son:
(i−2) (j)
Ai,i−2 = u21 ; Ai,j = Ai,j+1 u21 ; (i = n; j = i − 3, i − 2, ..., 1); (6.12)
(i−1) (j)
Ai,i−1 = u11 ; Ai,j = Ai,j+1 u21 ; (i = 2, n − 1; j = i − 2, i − 3, ..., 1). (6.13)
Para finalizar la construcción de A, las columnas de su triangular inferior

(excepto la diagonal) se multiplican con los valores de z, esta operación se puede
expresar como:
Aij = zj Aij ; (i = 2, n; j = 1, i − 1). (6.14)
Entonces, los renglones de A se pueden calcular simultáneamente si los valores

de la matriz U y el vector z se han calculado ya.
Por lo tanto, hay tres secciones del algoritmo MTriIU (Algoritmo 53) que
pueden paralelizarse: el cálculo de las columnas de la matriz U , de los compo-
nentes del vector z y de los renglones de A. La paralelización, entonces, consiste
en la distribución de los n − 1 componentes de z, los n − 2 componentes de U y
los n−1 renglones de A (A2,1:1 , A3,1:2 , A4,1:3 , ..., An,n−1 ) entre Prc procesadores.
Para controlar la distribución de carga entre los procesadores, se utilizan dos
estructuras de ı́ndices: low y up, las que indican los lı́mintes del subintervalo
de componentes de U y z que cada procesador debe calcular. Por ejemplo, si
n = 19 y Prc = 4, la distribución del cálculo de z y U queda como:
P roc low up Calcula

0 3 7 U (3) , U (4) , U (5) , U (6) , U (7) y z3 , z4 , z5 , z6 , z7
1 8 11 U (8) , U (9) , U (10) , U (11) y z8 , z9 , z10 , z11
2 12 15 U (12) , U (13) , U (14) , U (15) y z12 , z13 , z14 , z15
3 16 19 U (16) , U (17) , U (18) , U (19) y z16 , z17 , z18 , z19 , z2
La distribución del trabajo necesario para calcular A se controla mediante las

estructuras de ı́ndices ren y contaRen; contaRen indica cuántos y ren qué ren-
glones de A debe calcular cada procesador, distribuyendo los renglones por pare-
jas entre los procesadores para equilibrar la carga computacional. Por ejemplo,
si n = 20 y Prc = 7, se forman las siguientes parejas de renglones:
parejas (2,20) (3,19) (4,18) (5,17) (6,16) (7,15) (8,14) (9,13) (10,12) (11)
flops 36 38 38 38 38 38 38 38 38 19
donde las parejas se eligen tomando renglones extremos de modo que la cantidad
de flops a calcular sea aproximadamente igual para cada procesador. Formadas
las parejas, en este ejemplo a cada procesador le corresponde una pareja; el
resto de las parejas ((9,13), (10,12) y (11)) se distribuyen entre los procesadores,
quedando ren y contaRen con los siguientes valores:
146
P roc ren contaRen
0 2 20 9 3
1 3 19 13 3
2 4 18 10 3
3 5 17 12 3
4 6 16 11 3
5 7 15 2
6 8 14 2
Para implementar esta idea en una computadora paralela de Memoria Dis-

tribuida, las estructuras: ren, contaRen, U y z deben estar disponibles en todos
los procesadores, por lo que en el proceso paralelo para calcular A hay dos etapas
de comunicación, como se ilustra a continuación para el caso n = 19, Prc = 4:
P roc0 P roc1 P roc2 P roc3

Construye d1:n d1:n d1:n d1:n
Calcula z3:7 z8:11 z12:15 z16:19,2
Calcula U (3) ...U (7) U (8) ...U (11) U (12) ...U (15) U (16) ...U (19)
⇐ − − − − − − − − − − − − − − − − − − − − − − − − −− ⇒
Dispersión Todos a Todos para replicar U y z
⇐ − − − − − − − − − − − − − − − − − − − − − − − − −− ⇒
A2,1 , A19,1:18 A3,1:2 , A18,1:17 A4,1:3 , A17,1:16 A5,1:4 , A16,1:15
Calcula A16,1:15 , A15,1:14 A7,1:6 , A14,1:13 A8,1:7 , A13,1:12 A9,1:8 , A12,1:11
A11,1:10 A10,1:9
⇐−−−−−−−−−−−−−−−−−−−−−−−−−−−
Reducción Todos a Uno para construir A en P roc0
⇐−−−−−−−−−−−−−−−−−−−−−−−−−−−
Los algoritmos del cálculo paralelo de z, U y A se describen en los Algoritmos

54, 55 y 56.
Algoritmo 54 ParaleloCalculazU
1. p1 ← d1
2. Para i = 2, n
2.1. pi ← pi−1 di
3. Si procesador Prc
z1 ← sqrt((p1 − 1)(1 − d2 )(p1 + 1)(1 + d2 ))
4. Para i = low, up
4.1. zi−1 ←
" sqrt((pi−1#− 1)(1 − di )(pi−1 + 1)(1 + di ))
1 0
4.2. L ←
zi−1 pi
4.3. [Q, diag(S), V ] ← dgesvd(2, L)
4.4. Si (pi−1 < di )
dswap(Q:,1 , Q:,2 )
4.5. U:,i ← Q:,1
147
Algoritmo 55 ParaleloCalculaMatTriU
1. A ← In
2. Para k = 1, contaRenproc
2.1. i ← renproc,k
2.2. Si (i = n)
Ai,i−2 ← U2,i−2
Para j = i − 3, i − 4, i − 5, ..., 1
Ai,j ← Ai,j+1 U2,j
Ai,j+1 ← Ai,j+1 zj+1
Sino
Ai,i−1 ← U1,i−1
Para j = i − 2, i − 3, i − 4, ..., 1
Ai,j ← Ai,j+1 U2,j
Ai,j+1 ← Ai,j+1 zj+1
2.3. Ai,1 ← Ai,1 z1
148
Algoritmo 56 MTriIUParalelo
1. d ← Construyed(S ∗ ) /* operación replicada */
2. [z, U ] ← ParaleloCalculazU(d)
3. /* Dispersión Todos a Todos de un mensaje de longitud n−2 Prc + 1 para
n−2
replicar ll y de un mensaje de longitud 2 × Prc para replicar U */
Si procesador i /*enviar*/
dgebs2d(0 All0 , 2, n−2
Prc + 1, U )
dgebs2d(0 All0 , n−2
Prc , 1, ll)
Sino /*recibir*/
U ← dgebr2d(0 All0 , 2, n−2 Prc + 1, U )
0 0 n−2
ll ← dgebr2d( All , Prc , 1, ll)
4. A ← ParaleloCalculaMatTriU(ll, U )
5. /* Reducción TODOS a UNO de un mensaje de longitud
contaRen × max(renproc,: ) para construir A en el procesador P0 */
Si procesador NO 0
Para i = 1, contarenproc
N bytes ← max(N bytes, renproc,i − 1)
paquete ← M P I P ack(Aren(proc,i),1:ren(proc,i)−1 , renproc,i − 1)
M P I Send(paquete, N bytes, M P I P ACKED)
Sino
Para p = 1, Prc − 1
paquete ← M P I Recv(paquete, N bytes)
Para i = 1, contarenp
Aren(p,i),1:ren(p,i)−1 ← M P I U npack(paquete, renp,i − 1)
6.1.3. Análisis de Prestaciones e Implementaciones del Al-

goritmo Paralelo MTriIU
Analizando teóricamente las prestaciones del Algoritmo paralelo MTriIU, el
Speedup se ve afectado por la construcción de A enel procesador P roc0 , pues
2
comunica una cantidad de datos del orden O √nP , como se ve en su tiempo
rc
de ejecución teórico:

n2 322n 656 p n2 + 4n
TM T riIU (n, Prc ) = + + 2n − tf + 5 Prc tm + √ tv ,
Prc 3Prc 3Prc Prc
por lo que su Speedup no alcanza el óptimo asintóticamente, de acuerdo a la
siguiente expresión:
−1
T (n, 1) Prc Prc Prc
lim SM T riIU (n, Prc ) = lim = √ .
n→∞ n→∞ T (n, Prc ) n2 t f n2 t f 1+ Prc ttfv
149
Algunas muestras experimentales tomadas en el cluster Kefren ilustran este
comportamiento en la Tabla 6.2, donde es evidente que los tiempos de ejecución
no disminuyen al aumentar el número de procesadores.
Tabla 6.2: Tiempos de Ejecución Experimentales de MTriIU en Kefren, construyendo A en

P roc0
P Segundos
1 1.3 4.2 8.5 14 47 78 226 344
2 2.4 8.9 19 37 210 316 600 964
4 2.9 10.1 23 43 141 209 422 678
6 3.0 11.1 25 45 124 179 361 580
8 3.3 12.2 27 49 113 167 332 533
10 3.5 12.4 28 51 110 163 314 504
12 3.5 12.9 29 52 106 154 299 493
14 3.8 13.1 30 53 105 152 290 479
16 4.0 13.6 31 55 104 152 288 466
n 500 1000 1500 2000 2500 3000 4000 5000
El costo teórico del mismo algoritmo sin la construcción final de A en el

procesador P roc0 es:

n2 322n 656 p 6n
TM T riIU (n, Prc ) = + + 2n − tf + 4 Prc tm + √ tv ,
Prc 3Prc 3Prc Prc
que muestra que el grado de paralelismo logrado en el cálculo de U , z y A es
teóricamente bueno, ya que el Speedup alcanza el óptimo asintóticamente:
−1
T (n, 1) Prc Prc
lim SM T riIU (n, Prc ) = lim = Prc .
n→∞ n→∞ T (n, Prc ) n2 t f n2 t f
Los tiempos de ejecución experimentales con el algoritmo paralelo MTriIU que

no construye A pueden verse en la Tabla 6.3. En estos experimentos se reducen
los tiempos de ejecución cuando se utiliza más de un procesador, excepto en
algunos casos donde es necesario utilizar muchos procesadores para reducir el
tiempo secuencial (n = {2500, 3000}), pero este fenómeno tiende a desaparecer
cuando el tamaño del problema se incrementa. Los Speedup de estos experi-
mentos están en la Figura 6.1. Además se espera que multiplicando el número
de procesadores por algún entero k, el Speedup obtenido sea k, como en los
resultados de la Tabla 6.4 (tomando datos de la Tabla 6.3) que muestran apro-
ximadamente este comportamiento cuando n crece.
150
Tabla 6.3: Tiempos de Ejecución Experimentales de MTriIU en Kefren, SIN construı́r A en
P roc0
P Segundos
1 1.3 4.2 8.5 14 47 78 226 344
2 0.91 3.2 6.8 11 164 235 420 646
4 0.76 2.5 5.6 9.6 86 125 222 337
6 0.80 2.4 5.2 9.0 61 88 157 234
8 0.75 2.4 5.1 8.7 48 69 123 184
10 0.67 2.3 4.9 8.5 40 58 103 153
12 0.74 2.3 4.8 8.3 36 51 91 131
14 0.67 2.3 4.7 8.4 32 46 81 117
16 0.65 2.3 4.7 7.7 29 42 74 105
n 500 1000 1500 2000 2500 3000 4000 5000
Tabla 6.4: Speedup experimental de MTriIU en Kefren, sin construir A en P roc 0 , multiplicando
el número de procesadores por 2 y por 4
k P Speedup
2 2 1.19 1.27 1.20 1.19 1.89 1.88 1.89 1.91
4 1.01 1.07 1.1 1.1 1.79 1.81 1.8 1.83
8 1.15 1.04 1.08 1.13 1.66 1.64 1.66 1.75
4 2 1.21 1.37 1.32 1.30 3.38 3.40 3.41 3.51
4 1.16 1.12 1.19 1.24 2.98 2.97 3 3.2
n 500 1000 1500 2000 2500 3000 4000 5000
1.8 3.2 P=10

P=12
3 P=14
1.6 P=16
Speedup de WE, Memoria Distribuida
Speedup de WE, Memoria Distribuida
2.8
1.4
2.6
1.2 2.4
2.2
1
2
0.8
1.8
P=2
0.6 P=4 1.6
P=6
P=8 1.4
0.4
1.2
500 1000 1500 2000 2500 3000 3500 4000 4500 5000 500 1000 1500 2000 2500 3000 3500 4000 4500 5000
Tamaño del Problema (n) Tamaño del Problema (n)
Figura 6.1: Speedup experimental de MTriIU en Kefren, SIN construir A en P roc 0
El análisis anterior muestra que, dejando de lado las comunicaciones nece-

sarias para contener la matriz A en un sólo procesador, la resolución del PIVSVP
ha sido razonablemente paralelizada. El escollo de las comunicaciones es tratado
en la siguiente subsección.
151
Implementación en el Modelo de Memoria Compartida
El análisis de costos de la implementación bajo el modelo de Memoria Distri-

buida del algoritmo paralelo MTriIU muestra que las comunicaciones necesarias
para construir la matriz triangular inferior unidad A en un sólo procesador,
dañan seriamente las prestaciones de la implementación.
En una implementación bajo el modelo de Memoria Compartida, no es nece-
sario realizar este último paso, con lo que, de manera natural, se mejoran las
prestaciones de este algoritmo. Esta implementación se ha realizado emplean-
do directivas de compilador de OpenMP [CDK+ 01], tales como omp parallel
do para paralelizar ciclos, omp parallel para paralelizar una sección de código,
omp barrier para sincronizar hilos de ejecución y omp do para definir trabajo
compartido en un ciclo.
Utilizando H hilos de procesamiento y asumiento que cada hilo se ejecuta en
un procesador (Prc = H), cada hilo se puede encarga de calcular un subconjunto
de componentes de z, U y A, pues ya se ha visto en la sección anterior que no
hay problemas de dependencias de datos.
La distribución de z, U y A podrı́a efectuarse por el programador, como en
el caso de la implementación en Memoria Distribuida (mediante los ı́ndices low,
up, Ren y ContaRen). Sin embargo, en este caso es más eficiente dejar este
trabajo al compilador utilizando las directivas adecuadas, como: omp parallel
do y omp do, que dividen el trabajo entre hilos de procesamiento de manera
automática. En el siguiente diagrama se muestra esquemáticamente cómo se
proceden los cálculos:
Hilos hilo0 hilo1 hilo2 hilo3

Construir d1:n −−−−− −−−−− −−−−−
Calcular z3:7 z8:11 z12:15 z16:19,2
Calcular U (3) ...U (7) U (8) ...U (11) U (12) ...U (15) U (16) ...U (19)
⇐ − − − Barrera de Sincronización − − − ⇒
A2,1 , A3,1:2 A6,1:5 , A7,1:8 A10,1:9 , A11,1:10 A14,1:13 , A15,1:14
Calcular A4,1:3 , A5,1:4 A8,1:7 , A9,1:8 A12,1:11 , A13,1:12 A16,1:15 , A17,1:16
A18,1:17 A19,1:18
Comparando este diagrama con el de Memoria Distribuida, es claro que

las etapas de comunicaciones desaparecen, ası́ que se espera que la eficiencia del
algoritmo paralelo MTriIU se incremente. Este proceso está escrito en detalle en
el algoritmo 57, donde se utiliza omp parallel para crear hilos de procesamiento
(hilo1 , hilo2 , ..., hiloH−1 ) y ejecutar en paralelo un segmento de código; y en
los algoritmos 58 y 59, donde se utiliza la directiva omp do para distribuir las
iteraciones (del ciclo ”Para”) entre los hilos de procesamiento creados con omp
parallel.
152
Algoritmo 57 ParaleloShMTriIU
d ← Construyed(S ∗ ) /* ejecutado por hilo0 (hilo maestro) */
!$omp parallel private(hilo) /* hilo0 crea hilos esclavos hilo1 , ..., hiloH−1 */
[z, U ] ← ParaleloShzU(d)
!$omp barrier
A ← ParaleloShA(z, U )
!$omp end parallel /* esclavos finalizados por hilo hilo0 */
Algoritmo 58 ParaleloShzU
!$omp do /* Se distribuyen las iteraciones entre los hilos */
Para i = 3, n
zi−1 ← calcular z(p, d) /* de acuerdo con (6.7) */
L ← calcular L(zi−1 , pi ) /* de acuerdo con (6.11) */
[Q, diag(S), V ] ← dgesvd(2,L)
U1:2,i−2 ← Q:,1
!$omp enddo
Si hilo = hiloH−1 z1 ← calcular z(p, d)
Algoritmo 59 Algorithm ParaleloShA

!$omp do /* Se distribuyen las iteraciones entre los hilos */
Para i = 2, n
Ai,1:i−1 ← calcula A(z, U ) /* de acuerdo a (6.12-6.14) */
!$omp enddo
Pruebas experimentales del Algoritmo 57 se han realizado en el cluster Alde-

barán, que por ser un multiprocesador de memoria lógicamente compartida,
aunque fı́sicamente distribuida (memoria compartida distribuida), es el adecua-
do para ejecutar este tipo de implementaciones. En la Tabla 6.5 se tienen algunos
tiempos de ejecución obtenidos.
153
Tabla 6.5: Tiempos de Ejecución Experimentales de MTriIU en Aldebarán, bajo el modelo de
Memoria Compartida
Hilos Segundos
1 1.3 4.9 10.1 22 26 37 68 95
2 1.0 3.1 6.1 12 14 20 35 48
3 0.64 2.1 4.3 9.0 10 14 23 31
4 0.55 1.6 3.4 7.4 7.1 10 18 23
6 0.45 1.1 2.7 5.0 3.2 9 16 18
8 0.44 1.1 2.6 4.3 5.5 8 13 17
10 0.33 1.2 2.3 3.7 4.8 7 10.3 16
12 0.35 1.0 2.6 3.7 4.6 6.1 10.2 13
14 0.32 0.9 2.2 3.3 4.2 6.0 9.8 11
16 0.25 0.8 2.1 3.2 4.1 5.4 9.6 10
n 500 1000 1500 2000 2500 3000 4000 5000
Los Speedup correspondientes a los tiempos anteriores están en la Figura 6.2.

Con 2 hilos de procesamiento el Speedup ya es aceptable para n = 1000 y a partir
de n = 2000 es bueno para 2 procesadores mientras que para 3 y 4 empieza a
ser aceptable. Buenos Speedup para 3 y 4 procesadores se obtienen a partir de
n = 3000. En el caso de 6 procesadores, el Speedup es aceptable en el tamaño
de problema más grande que se ha probado (n = 5000).
7 10
9
6
Speedup de WE, Memoria Compartida
Speedup de WE, Memoria Compartida
5 7
6
4
5
3 4
n=500
n=1000 n=2500
3
n=1500 n=3000
2 n=4000
n=2000 2 n=5000
1 1
2 4 6 8 10 12 14 16 2 4 6 8 10 12 14 16
Numero de Hilos (H) Numero de Hilos (H)
Figura 6.2: Speedup experimentales de MTriIU en Aldebarán. Modelo de Memoria Compartida
La eficiencia correspondiente a estos experimentos (Tabla 6.6) son buenos

con tamaños de problema relativamente pequeños. Con n = 1000 y dos hilos la
eficiencia es de 81 %; para n = 2000 la eficiencia es muy buena hasta con 4 hilos
y aceptable con 6. Para el caso experimental más grande que se ha probado
(n = 5000) la eficiencia con 6 procesadores también es buena.
154
Tabla 6.6: Eficiencia Experimental de MTriIU en Aldebarán. Modelo de Memoria Compartida
Hilos Aprovechamiento
2 66 % 81 % 83 % 91 % 92 % 92 % 97 % 98 %
3 70 % 78 % 78 % 81 % 87 % 88 % 98 % 98 %
4 61 % 76 % 74 % 92 % 91 % 92 % 94 % 95 %
6 50 % 74 % 62 % 73 % 69 % 68 % 71 % 88 %
8 38 % 56 % 49 % 64 % 59 % 58 % 65 % 69 %
10 41 % 41 % 44 % 59 % 54 % 53 % 66 % 59 %
12 32 % 41 % 34 % 49 % 47 % 50 % 55 % 61 %
14 30 % 36 % 36 % 47 % 44 % 44 % 49 % 63 %
16 34 % 35 % 30 % 43 % 39 % 43 % 44 % 59 %
n 500 1000 1500 2000 2500 3000 4000 5000
Para analizar la escalabilidad de este algoritmo se ha hecho crecer en la

misma proporción el tamaño del problema y el número de hilos (el número de
procesadores); como el algoritmo MTriIU es O(n2 ), se han tomando tiempos
de ejecución para n = {1000, 1400, 2000, 2800, 3400, 4000} con un hilo de proce-
samiento y respectivamente con H = {1, 2, 4, 8, 12, 16} hilos (procesadores). Los
resultados están en la Figura 6.3 y muestran una buena escalalibidad.
8
n=4000
7
n=3400
6
Speedup Escalado de WE,
Memoria Compartida
5
n=2800
3
n=2000
2
n=1400
1
n=1000
0
0 2 4 6 8 10 12 14 16
Numero de Hilos (H)
Figura 6.3: Speedup Escalado de MTriIU en Aldebarán. Memoria Compartida
6.2. Método MBidiag

Se pueden encontrar en [Chu00] y [LM01] métodos para la resolución del
PIVSVP propuestos por Chu y por Li y Mathias, respectivamente. Chu se basa
en la construcción de una matriz cuasitriangular inferior y Li y Mathias en una
matriz triangular superior con valores propios y valores singulares prestableci-
dos.
En esta sección se propone un método alternativo a los ya mencionados para
155
resolver el PIVSVP, mediante la construcción de una matriz bidiagonal con
con valores propios y valores singulares prestablecidos, los cuales satisfacen las
restricciones que establece el siguiente teorema.
Teorema 1 Dada una matriz An×n , con valores propios L1 , L2 , ..., Ln y valores
singulares S1 , S2 , ..., Sn , tales que
|L1 | ≥ |L2 | ≥ ... ≥ |Ln | y S1 ≥ S2 ≥ ... ≥ Sn ,
entonces
|L1 ||L2 |...|Li | ≤ S1 S2 ...Si (i = 1, n − 1) (6.15)
|L1 ||L2 |...|Ln | = S1 S2 ...Sn (6.16)
Entonces, el PIVSVP se puede enunciar como: dados los conjuntos de valores

reales S ∗ = {S1∗ , S2∗ , ..., Sn∗ } y L∗ = {L∗1 , L∗2 , ..., L∗n }, tales que S1∗ ≥ S2∗ ≥ ... ≥
Sn∗ y L∗1 ≥ L∗2 ≥ ... ≥ L∗n , y que cumplen las condiciones (6.15) y (6.16), construir
una matriz bidiagonal A ∈ <n×n cuyos valores propios sean L∗ y cuyos valores
singulares sean S ∗ . Como A es bidiagonal, se puede conseguir fácilmente que
posea los valores propios L∗ si toma la forma
L∗1
c1 L∗2
A(c) = c2 L∗3 , (6.17)
.. ..
. .
cn−1 L∗n
quedando por calcular los parámetros c1 , c2 , ..., cn−1 tales que los valores sin-
gulares de A(c) sean S ∗ . Para ello, se define la matriz simétrica
L∗21 L∗1 c1
L∗1 c1 c21 + L∗2 2 L∗2 c2
T (c) = A(c)A(c)t = L∗2 c2 c + L∗2
2
3
.. ..
. .
L∗n−1 cn−1 c∗n−1 + L∗2
n
(6.18)
que se puede expresar como

T (c) = diag L∗2 ∗2 ∗2
1 , L2 , ..., Ln +
+ c21 e2 et2 + c22 e3 et3 + ... + c2n−1 en etn +

+ c1 L∗1 (e2 et1 + e1 et2 ) + c2 L∗2 (e3 et2 + e2 et3 ) + ...+
+ cn−1 L∗n−1 (en etn−1 + en−1 etn ) (6.19)
156
donde ei es el i−ésimo vector canónico (i = 1, n). Como T (c) se ha construido
de acuerdo a (6.18), los valores propios de T (c) son el cuadrado de los valores
singulares de A(c). Como se desea que A(c) tenga los valores singulares S ∗ ,
entonces se tiene el problema de calcular el vector c ∈ <n−1 tal que los valores
propios de T (c), denotados con Li (c) (i = 1, n), sean Si∗2 (i = 1, n). Para
resolver este problema se define el sistema de n − 1 ecuaciones no lineales con
n − 1 incógnitas F (c) = 0 de la forma

F (c) = [Fi (c)]i=1,n−1 = Li (c) − Si∗2 i=1,n−1 = 0. (6.20)
Resolver (6.20) implica que se ha encontrado la matriz T (c) (de la ecuación

(6.18) o (6.19)) que tiene los n − 1 valores propios deseados Si∗2 (i = 1, n − 1),
es decir, que se ha encontrado la matriz A(c) (de la ecuación (6.17)) que tiene
los n − 1 valores singulares deseados Si∗ (i = 1, n − 1). Como se ha partido del
supuesto de que S ∗ y L∗ satisfacen (6.16):
|L∗1 ||L∗2 |...|L∗n |

|L∗1 ||L∗2 |...|L∗n | = S1∗ S2∗ ...Sn∗ ⇒ Sn∗ = ,
S1∗ S2∗ ...Sn−1
∗
por lo que, resolver (6.20) es construir A(c) con los n valores singulares deseados
S∗.
Para resolver el sistema de ecuaciones no lineales (6.20) se utiliza el algoritmo
de Newton. Para ello, es necesario calcular la matriz Jacobiana de F (c), la que
está definida como

∂Fi (c) ∂Li (c)
J(c) = = . (6.21)
∂cj i,j=1,n−1 ∂cj i,j=1,n−1
A partir de la descomposición en valores propios de T (c),
T (c) = Q(c)diag (L1 (c), L2 (c), ..., Ln (c)) Q(c)t ,
donde Q(c) es ortogonal, es decir, a partir de
diag (L1 (c), L2 (c), ..., Ln (c)) = Q(c)t T (c)Q(c),
si se definen L ≡ L(c), Q ≡ Q(c) y T ≡ T (c), se tiene que
Li = qit T qi (i = 1, n)
∂Li ∂ (qit T qi ) ∂q t ∂T ∂qi
⇒ = = i T qi + qit qi + qit T
∂cj ∂cj ∂cj ∂cj ∂cj
(i = 1, n; j = 1, n − 1). (6.22)
Definiendo J ≡ J(c) y sustituyendo (6.22) en (6.21), se tiene que
∂T (c)
Jij = qit qi (i, j = 1, n − 1), (6.23)
∂cj
157
lo que se justifica porque, al ser Q ortogonal, qit qi = 1 (i = 1, n), es decir
2 2 2
(qi )1 + (qi )2 + ... + (qi )n = 1
∂ (qi )1 ∂ (qi )2 ∂ (qi )n
⇒ 2 (qi )21 + 2 (qi )22 + ... + 2 (qi )2n =0
∂cj ∂cj ∂cj

∂ (qi )1 ∂ (qi )2 ∂ (qi )n t
⇒ ... [(qi )1 (qi )2 ... (qi )n ] = 0.
∂cj ∂cj ∂cj
t
∂qi
⇒ =0
∂cj ij=1,n−1
Por otra parte, la derivada parcial de T , definida en (6.19), con respecto a

cj es
∂T
= 2cj ej+1 etj+1 + L∗j ej+1 etj + ej etj+1 (j = 1, n − 1),
∂cj
que al sustituirla en (6.23), da como resultado

Jij = qit 2cj ej+1 etj+1 + L∗j ej+1 etj + ej etj+1 qi =

= 2cj qit ej+1 etj+1 qi + L∗j qit ej+1 etj + ej etj+1 qi =
= 2cj qj+1,i etj+1 qi + L∗j qj+1,i etj qi + L∗j qj,i etj+1 qi =
= 2cj qj+1,i qj+1,i + L∗j qj+1,i qj,i + L∗j qj,i qj+1,i =
2
= 2cj qj+1,i + 2L∗j qj,i qj+1,i = 2cj qj+1,i
2
+ 2L∗j qj,i qj+1,i (i = 1, n − 1). (6.24)
Definida la matriz jacobiana de F (c), se puede aplicar la iteración de Newton:
c(k) = c(k−1) − J (k−1)−1 F (k−1) , k = 1, 2, ...
que convergerá cuadráticamente si se parte de un vector c(0) suficientemente

cercano a la solución del sistema (6.20). Cuando el algoritmo de Newton haya
calculado dicha aproximación, se podrá construir la matriz A(c) con valores
propios L∗ y valores singulares S ∗ . El algoritmo correspondiente a este procedi-
miento y experimentos numéricos se dan en la siguiente sección.
6.2.1. Algoritmo MBidiag y Experimentos Numéricos

El algoritmo mediante el cual se construye una matriz bidiagonal A(c) con
valores propios L∗ y valores singulares S ∗ dados, está en el Algoritmo 60.
Algunos experimentos numéricos se han realizado utilizando casos del tipo
Bidiag, ejecutando el Algoritmo MBidiag en el cluster Kipling. Dado que MBidi-
ag es un algoritmo tipo Newton, se han utilizado diferentes vectores iniciales c (0) ,
algunos más cercanos y otros más alejados del vector solución (controlada esta
distancia con δ), mostrando los resultados que este es un método robusto dado
que ha convergido en la mayorı́a de los casos.
158
Algoritmo 60 MBidiag
1. Calcular T (c(0) ) y A(c(0) ) de acuerdo a (6.19) y (6.17)
2. Calcular la descomposición en valores propios de T (c(0) )
(0)
Q , diag(L(0) ) ← dsyev(T (c(0) ))
3. Calcular los valores singulares de A(c(0) )
diag(S (0) ) ← dgesvd(A(c(0) ))
4. Para k = 0,1,2,..., Mientras kS (k) − S ∗ k2 > tol
4.2. Calcular F (k) de acuerdo a (6.20)
4.3. Resolver el sistema J (k) x(k) = −F (k)
x(k) ← dgesv(J (k) , −F (k) )
4.4. c(k+1) ← c(k) + x(k)
4.5. Calcular T (c(k+1) ) y A(c(k+1) ) de acuerdo a (6.19) y (6.17)
4.6. Calcular la descomposición en valores propios de T (c(k+1) )
(k+1)
Q , diag(L(k+1) ) ← dsyev(T (c(k+1) )
4.7. Calcular los valores singulares de A(c(k+1) )
diag(S (k+1) ) ← dgesvd(A(c(k+1) ))
Los resultados de experimentos para tamaños pequeños pueden verse en la

Tabla 6.7, donde k denota el número de iteraciones que MBidiag ha requerido
para converger. Para los tamaños n = {25, 50, 100} se tienen algunos problemas
de convergencia para los casos donde c(0) está más alejado de la solución.
159
(0)
Tabla 6.7: Resultados del caso Bidiag con MBidiag, para n = {4, 10, 25, 50, 100}, con c i =
c∗i + δ (i = 1, n)
n δ kS (0) − S ∗ k2 kL(0) − L∗ k2 k kS (k) − S ∗ k2 kL(k) − L∗ k2
4 1e-3 9e-4 0 3 3e-16 0
1e-2 9e-3 0 3 1e-14 0
1e-1 9e-2 0 5 8e-17 0
1e+0 1e+0 0 11 4e-14 0
1e+1 1e+1 0 13 5e-16 0
1e+2 1e+2 0 13 4e-16 0
10 1e-3 1e-3 0 3 4e-15 0
1e-2 1e-2 0 3 6e-15 0
1e-1 1e-1 0 4 4e-15 0
1e+0 2e+0 0 241 7e-15 0
1e+1 2e+1 0 713 2e-15 0
1e+2 2e+2 0 188 1e-14 0
25 1e-3 3e-3 0 3 1e-14 0
1e-2 3e-2 0 4 1e-14 0
1e-1 3e-1 0 13 1e-14 0
1e+0 3e+0 0 — — —
1e+1 3e+1 0 56 4e-13 0
1e+2 4e2 0 — — —
50 1e-3 4e-3 0 1106 4e-14 0
1e-2 4e-2 0 67 4e-14 0
1e-1 4e-1 0 — — —
1e+0 4e+0 0 — — —
1e+1 4e+1 0 6 3e-12 0
100 1e-3 6e-3 0 3 2e-13 0
1e-2 6e-2 0 3 1e-12 0
1e-1 6e-1 0 9 3e-13 0
1e+0 6e+0 0 — — —
1e+1 6e+1 0 3 1e-9 0
En la Tabla 6.8 se tienen otros resultados para casos de mayor tamaño. En

todos los experimentos realizados se ha logrado converger a una solución. Por
la forma en que se construye la matriz bidiagonal A(c), mientras que los valores
singulares deseados S ∗ se aproximan mediante el método de Newton, los valores
propios deseados L∗ siempre son exactos, como lo muestra el error absoluto
kL(k) − L∗ k2 .
160
Tabla 6.8: Resultados del caso Bidiag con MBidiag, para n = {150, 200, 400, 500, 1000}, con
(0)
ci = c∗i + δ (i = 1, n)
n δ kS (0) − S ∗ k2 kL(0) − L∗ k2 k kS (k) − S ∗ k2 kL(k) − L∗ k2
150 1e-1 8e-1 0 7 7e-13 0
1e+0 8e+0 0 5 4e-11 0
1e+1 6e+1 0 3 1e-9 0
1e+2 8e+2 0 72 4e-9 0
200 1e-3 9e-3 0 1 1e-8 0
1e-2 9e-2 0 1 1e-8 0
1e-1 9e-1 0 2 1e-8 0
1e+0 9e+0 0 2 3e-8 0
1e+1 9e+1 0 4 5e-9 0
1e+2 9e+2 0 5 1e-8 0
400 1e-3 1e-2 0 1 4e-8 0
1e-2 1e-1 0 1 4e-8 0
1e-1 1e+0 0 2 4e-8 0
1e+0 1e+1 0 5 4e-8 0
1e+1 1e+2 0 3 4e-8 0
500 1e-3 1e-2 0 6 4e-8 0
1e-2 1e-1 0 3 4e-8 0
1e-1 1e+0 0 27 4e-8 0
1e+0 1e+1 0 18 4e-8 0
1e+1 1e+2 0 25 4e-8 0
1e+2 1e+3 0 4 2e-8 0
1000 1e-3 2e-2 0 1 3e-7 0
1e-2 2e-1 0 1 1e-7 0
1e-1 2e+0 0 2 1e-7 0
1e+0 2e+1 0 2 2e-7 0
1e+1 2e+2 0 3 1e-7 0
1e+2 2e+3 0 5 1e-7 0
Se han implementado los métodos propuestos por Chu [Chu00] y Li y Ma-

thias [LM01] con el fin de compararlos con el método MBidiag, para lo que se
han tomado casos de prueba del tipo Bidiag y se han probado numéricamente
con los tres métodos. Los resultados están en la Tabla 6.9, donde
kS − S ∗ k2
eaS = kS − S ∗ k2 , erS = ,
kS ∗ k2
kL − L∗ k2
eaL = kL − L∗ k2 , erL = ,
kL∗ k2
son los errores finales alcanzados por los algoritmos; S denota los valores sin-
gulares de las matrices construidas por los algoritmos y L denota los valores
propios de las mismas.
161
Tabla 6.9: Métodos de Chu v.s. Li-Mathias v.s. MBidiag
MBidiag Método Chu Método Li-Mathias

n eaS erS eaL erL eaS erS eaL erL eaS erS eaL erL
5 3e-16 1e-16 0 0 6e-16 1e-16 2e-16 6e-17 1e-15 2e-16 4e-16 1e-16
10 1e-14 1e-15 0 0 2e-15 1e-16 1e-15 1e-16 1e-15 1e-16 2e-15 2e-16
25 1e-14 2e-16 0 0 1e-14 2e-16 4e-15 1e-16 1e-14 2e-16 4e-15 1e-16
50 3e-12 2e-16 0 0 3e-12 2e-16 1e-12 1e-16 1e-12 2e-16 1e-12 1e-16
100 1e-9 3e-16 0 0 1e-9 3e-16 4e-10 1e-16 1e-9 3e-16 1e-9 3e-16
150 3e-9 4e-16 0 0 3e-9 4e-16 8e-10 1e-16 2e-9 3e-16 1e-9 2e-16
200 5e-9 1e-16 0 0 6e-9 5e-16 1e-9 1e-16 4e-9 4e-16 2e-8 2e-15
400 4e-8 1e-15 0 0 3e-8 9e-16 3e-9 1e-16 1e-8 5e-16 1e-7 4e-15
500 2e-8 5e-16 0 0 3e-8 7e-16 4e-9 1e-16 3e-8 6e-16 1e-8 4e-16
750 8e-8 9e-16 0 0 8e-8 1e-15 8e-9 1e-16 5e-8 6e-16 3e-7 4e-15
1000 1e-7 1e-15 0 0 1e-7 1e-15 1e-8 1e-16 5e-8 4e-16 3e-7 5e-15
1250 4e-7 2e-15 0 0 3e-7 1e-15 1e-8 1e-16 8e-8 4e-16 1e-6 1e-14
1500 2e-7 9e-16 0 0 3e-7 1e-15 2e-8 1e-16 1e-7 4e-16 7e-7 3e-15
2000 3e-7 1e-15 0 0 6e-7 1e-15 3e-8 1e-16 2e-7 6e-16 2e-6 1e-15
Los resultados de la Tabla 6.9 muestran que los tres métodos tienen el mis-
mo comportamiento con respecto a los valores singulares de las matrices que
construyen, sin embargo, la matriz construida por el método MBidiag siempre
tiene los valores propios deseados exactos, mientras que los otros métodos los
aproximan.
6.3. Conclusiones
El problema de la construcción de una matriz triangular inferior unidad con
valores singulares prestablecidos, visto en la Sección 6.1, es una muestra de
un problema cuya resolución se aborda más natural y convenientemente bajo
un esquema de memoria compartida. Esta conclusión se da a partir del estu-
dio y análisis de diversas implementaciones de sus correspondientes algoritmos
secuenciales y paralelos.
El código paralelo diseñado para el modelo de Memoria Distribuida alcanza
buenos niveles de paralelismo en cuanto a la fase de cómputo se refiere. Sin
embargo, una vez que la matriz A se ha calculado, ésta queda distribuida de
forma que es necesario reunir todos sus componentes en un sólo procesador;
las comunicaciones para realizar este paso merman las ganancias obtenidas del
código paralelo. Este problema puede tratarse si el mismo algoritmo se adapta
a un esquema de Memoria Compartida, donde las comunicaciones finales para
reunir A en un procesador no son necesarias. Más aún, las comunicacinoes nece-
sarias para replicar z y U en el modelo de Memoria Distribuida tampoco son
necesarias en el esquema de Memoria Compartida.
162
Una comparativa de los modelos de Memoria Distribuida y Memoria Com-
partida del algoritmo MTriIU para el PIVSVP se resumen en la siguiente tabla:
Memoria Compartida Memoria Distribuida

* Facilidad de implementación * Implementation Compleja
* * No requere estructuras de * Require estructuras de datos

datos adicionales de control
* * Distribución de carga * Distribución manual (por parte

mediante el uso de directivas del programador) de carga de trabajo
de compilador adecuadas
* * Eficiencia aceptable mayor * No alcanza prestaciones aceptables

que 90 % hasta con 4 hilos por las etapas de comunicaciones
Por lo tanto, bajo el esquema de Memoria Compartida se han logrado dis-

minuir los tiempos de ejecución secuenciales del algoritmo MTriIU y se han
obtenido muy buenas prestaciones hasta con 4 hilos de ejecución: logrando un
Speedup de, al menos, 1.8, 2.6 y 3.6 con 2, 3 y 4 hilos de procesamiento co-
rrespondientemente, para los casos n ≥ 2000 (Figura 6.2), lo que corresponde a
una eficiencia > 90 % (Tabla 6.6), obteniendo también una buena escalalibidad
hasta con 4 hilos. Las prestaciones se ven mermadas con más de 4 hilos de eje-
cución por ser Aldebarán, aunque un multiprocesador lógicamente, fı́sicamente
una multicomputadora, por lo que, finalemente, se realizan pasos de mensajes
entre unidades de procesamiento, aunque esto sea transparente al programador.
En muchos problemas la programación paralela bajo el esquema de memoria
compartida es más adecuada que la de memoria distribuida, por la naturaleza
de la resolución del problema que se está tratando, como el presentado en este
trabajo, pues la distribución de los cálculos ha resultado ser muy sencilla y
adaptada naturalmente al esquema de memoria compartida.
Por otra parte, el método MBidiag para la construcción de una matriz bi-
diagonal con valores propios y valores singulares prestablecidos, propuesto en la
Sección 6.2, ha resultado ser de alta robustez experimental, ya que en la mayorı́a
de los casos probados, se ha obtenido una matriz cuyos valores singulares son
aproximados con alta exactitud para los casos de tamaño pequeño y con una
exactitud aceptable para los casos de mayor tamaño; mientras que los valores
propios de tal matriz están dados directamente en su diagonal.
Ante algoritmos que resuelven el mismo problema, como el de Chu [Chu00]
y el de Li-Mathias [LM01], construyendo matrices cuasitriangular superior y
triangular inferior, respectivamente, el método MBidiag ha resultado ser tan
bueno como éstos, alcanzando aproximaciones a los valores singulares con el
163
mismo orden de exactitud. Mientras que estos autores construyen matrices trian-
gulares, MBidiag construye una matriz que es aún más simple en estructura, ya
que construye una matriz bidiagonal, que tanto en el almacenamiento como en
los cálculos para manipularla es menos costosa que las triangulares.
Con los algoritmos MTriIU y MBidiag se dan los precedentes para la inves-
tigación de métodos que resuelven el PIVS y el PIVP simultáneamente.
164
Capı́tulo 7
Conclusiones y Perspectivas
Esta tesis constituye una de las etapas de diseño, desarrollo e implementación

de una biblioteca numérica secuencial y paralela que agrupa rutinas eficientes
y portables que resuelven el Problema Inverso de Valores Propios (PIVP) y el
Problema Inverso de Valores Singulares (PIVS). Especı́ficamente, en esta tesis
se ha estudiado un conjunto de métodos y se han diseñado e implementado algo-
ritmos secuenciales y paralelos correspondientes para la resolución del Problema
Inverso de Valores Singulares (PIVS), el que se ha clasificado en este trabajo co-
mo: Problema Inverso Aditivo de Valores Singulares (PIAVS), Problema Inverso
Estructurado de Valores Singulares (PIEVS) y Problema Inverso de Valores Sin-
gulares y Valores Propios (PIVSVP).
Para la resolución del PIAVS, se ha tomado como base un conjunto de cua-
tro métodos tipo Newton que Friedland, Nocedal y Overton han propuesto
en [FNO87] para la resolución de PIVP, denominados Method I, Method II,
Method III y Method IV. Lift&Project es otro método que constituye la base
sobre la que se ha resuelto el PIAVS. Lift&Project es un método que resuelve
el PIVP y que ha sido propuesto por Chen y Chu en [CC96].
Ası́, en el Capı́tulo 2 se han introducido los métodos FB, MI, EP y MIII para
resolver el PIAVS. FB es un método tipo Newton de concepción muy sencilla que
ha sido desarrollado en esta tesis como una primera alternativa para resolver el
PIAVS cuando éste constituye directamente un sistema de ecuaciones no lineales.
MI y MIII son adaptaciones de Method I y Method III, respectivamente, la
primera ha sido realizada en este trabajo y la segunda ha sido desarrollada por
Chu en [Chu92a]. EP es una adaptación de Lift&Project y ha sido desarrollada
también en esta tesis.
Los algoritmos de FB, MI, EP y MIII son todos de un alto costo com-
putacional, tanto espacial como temporal. FB es el más costoso de todos con
un orden de complejidad de tiempo de O(n6 ) y de complejidad de espacio de
O(n4 ), mientras que el resto de los algoritmos están en el orden de O(n4 ) en el
165
tiempo y O(n3 ) en el espacio. Se han identificado dos tipos de algoritmos: los de
convergencia local y los de convergencia global. FB, MI y MIII se consideran de
convergencia local (a los que les lleva pocas iteraciones converger a una solución,
siempre que partan de una aproximación inicial cercana a la ésta), mientras que
EP se considera de convergencia global (al que le le lleva muchas iteraciones
converger a una solución, independientemente de la aproximación inicial dada).
De acuerdo a sus caracterı́sticas, MI ha sido el algoritmo más eficiente y FB el
menos. EP ha sido el algoritmo que ha demandado menos almacenaje que MI,
MIII y FB (el que es altamente costoso). Los resultados más importantes que se
han expuesto en este párrafo corresponden a los obtenidos del estudio teórico y
numérico de los algoritmos que se ha realizado en el Capı́tulo 3.
El diseño paralelo y la implementación de los algoritmos de los métodos
que resuelven el PIAVS son aportes de esta tesis y han derivado en rutinas
paralelas que han cumplido con el cometido de disminuir los tiempos de ejecución
secuenciales. Se ha detallado el diseño paralelo de cada método en el Capı́tulo 4.
En todos los diseños se ha tratado de evitar en lo posible la redistribución de
datos y de minimizar el tráfico de mensajes entre procesadores. Se han estimado
los tiempos de ejecución teóricos que han resultado ser buenas aproximaciones de
los tiempos que se han medido de los diversos experimentos que se han realizado,
de esta forma se ha podido analizar el comportamiento de los algoritmos en
situaciones hipotéticas.
En términos generales, MI y MIII han observado un comportamiento similar;
las prestaciones de los algoritmos paralelos correspondientes han sido suficien-
temente buenas desde el punto de vista del Speedup y la Eficiencia; ambos
pueden considerarse algoritmos paralelos con escalabilidad aceptable. El algo-
ritmo paralelo EP ha mejorado las prestaciones de MI y MIII cuando el número
de procesadores se ha incrementado y también ha presentado un mejor compor-
tamiento respecto de la escalabilidad. Por otra parte, FB ha requerido de intensa
redistribución de datos en el algoritmo paralelo correspondiente, lo que ha ido
en detrimento de sus prestaciones, sin embargo, el paralelismo da la posibilidad
de manejar problemas cuyo tamaño serı́a imposible de manejar secuencialmente.
Los algoritmos secuenciales y paralelos FB, MI, EP y MIII han sido diseñados
sin distinguir estructuras especiales de las matrices involucradas en el PIAVS;
sin embargo, se puede incidir en la mejora del tiempo de ejecución y de los
requerimientos de memoria al explotar las caracterı́sticas estructurales de las
matrices. En esta tesis se ha considerado la particularización de las matrices del
PIAVS en matrices tipo Toeplitz en el Capı́tulo 5, definiéndose ası́ el PIEVS.
Las caracterı́sticas estructurales de las matrices tipo Toeplitz, han dado lu-
gar al diseño e implementación de un algoritmo eficiente para el cálculo de los
valores singulares de una matriz tipo Hankel, basado en la FFT; de este modo,
como aporte en esta tesis se ha conseguido desarrollar un algoritmo de orden
166
O(n2 logn) que es de un orden de complejidad de tiempo menor que el orden
O(n3 ) correspondiente a la descomposición en valores singulares de una matriz
no estructurada. Sobre esta rutina eficiente descansa la adaptación de los algo-
ritmos MI y EP que se han rediseñando para aprovechar la estructura Toeplitz,
lo que ha dado lugar a los algoritmos MIE y EPE, cuya versión secuencial ha
resuelto el PIEVS eficientemente y ha disminuido los tiempos de ejecución de
MI y EP secuenciales, correspondientemente.
Se han desarrollado también algoritmos paralelos MIE y EPE que han lo-
grado el objetivo de disminuir los tiempos de ejecución secuenciales. Aunque las
prestaciones de estos algoritmos están por debajo de las de MI y EP paralelos, al
menos con 2 y 4 procesadores presentan prestaciones aceptables para problemas
de tamaño grandes.
Un problema que combina tanto el PIVP y el PIVS es el Problema Inverso
de Valores Singulares y Valores Propios (PIVSVP). Una primera aproximación
a la resolución del PIVSVP se ha dado en el Capı́tulo 6 de esta tesis a través
del algoritmo denominado MTriIU que resuelve un caso particular del PIVSVP.
MTriIU ha sido desarrollado por Kosowski y Smoktunowicz en [KA00]. Se han
propuesto dos algoritmos paralelos, uno diseñado bajo el modelo de memoria
distribuida y otro bajo el modelo de memoria compartida. Por la naturaleza
del algoritmo MTriIU, su paralelización ha resultado ser más adecuada bajo el
modelo de memoria compartida, logrando disminuir los tiempos de ejecución se-
cuenciales y obteniéndose un algoritmo con escalabilidad aceptable y con buenas
prestaciones con respecto a Speedup y Eficiencia.
Por último se ha desarrollado en esta tesis un método denominado MBi-
diag que, al igual que los presentados por Chu en [Chu00] y por Li y Mathi-
as en [LM01], construye una matriz con valores singulares y valores propios
prestablecidos y que, a diferencia de ellos, que construyen matrices cuasi trian-
gular superior y triangular inferior, respectivamente, construye matrices bidiag-
onales, lo que supone un bajo costo computacional. Resultados experimentales
han mostrado que el método MBidiag ha sido altamente robusto al dar solu-
ciones satisfactorias al PIVSVP, pudiendo equipararse a los algoritmos de Chu
y Li-Mathias.
Todos los algoritmos implementados en esta tesis han sido codificados en
Fortran y han utilizado rutinas portables y eficientes de bibliotecas de libre
distribución tales como: bibliotecas secuenciales del álgebra lineal numérica,
como BLAS y LAPACK; bibliotecas paralelas del álgebra lineal numérica, co-
mo PBLAS y ScaLAPACK; bibliotecas de comunicaciones a través de paso de
mensajes, como BLACS y el entorno MPI. Dado que se han implementado al-
goritmos bajo una arquitectura de memoria compartida, se ha hecho uso del
modelo de programación paralela OpenMP a través de directivas de compilador
de Fortran. El uso de estas herramientas software soportan las caracterı́sticas
167
de eficiencia y portabilidad de los algoritmos implementados.
Las arquitecturas de computadoras que han sido utilizadas en la imple-
mentación y experimentación de los algoritmos han sido multicomputadoras
de memoria distribuida, especı́ficamente clusters de PCs, ası́ como multiproce-
sadores de memoria compartida distribuida. Estas computadoras han sido para-
metrizadas con respecto a tiempo de flop, tiempo de latencia y ancho de banda
para estimar teóricamente el comportamiento temporal de los algoritmos, lo
que ha resultado en aproximaciones que han predicho suficientemente bien el
comportamiento experimental, de tal suerte que con este tipo de análisis se ha
podido prever el comportamiento de los algoritmos, identificando secciones de
baja productividad paralela, y ha permitiendo aplicar las medidas pertinentes
para mejorar los puntos débiles de los algoritmos siempre que ha sido posible.
A diferencia de los experimentos numéricos reportados hasta el momento en
la literatura (con tamaños de problemas del orden de O({100 , 101 })), en esta
tesis se han realizado experimentos con problemas de gran tamaño (del orden de
O({102 , 103 })), tanto secuencial como paralelamente, introduciendo matrices ra-
zonablemente grandes. Se han realizado experimentos numéricos con diferentes
tipos de matrices, desde matrices generales (sin estructura particular ni valores
especı́ficos) hasta matrices estructuradas como tipo Toeplitz y triangulares.
Por lo tanto, los objetivos propuestos en esta tesis han sido alcanzados.
Se han dado los primeros pasos para la resolución del Problema Inverso de
Valores Singulares mediante el diseño e implementación de algoritmos paralelos
eficientes y portables.
Perspectivas
Un trabajo inmediato que se desprende del presentado en esta tesis es el
diseño adecuado y la implementación bajo el modelo de memoria compartida
de los algoritmos que resuelven el PIAVS.
También puede realizarse un estudio de los métodos propuestos para el PI-
AVS para extenderlos al manejo de valores singulares replicados, S1∗ = S2∗ =
· · · = Sp∗ > Sp+1∗
· · · > Sn∗ ; valores singulares nulos, S1∗ > S2∗ > · · · > Sp∗ =
∗
Sp+1 = · · · = Sn∗ = 0; o al manejo de un subconjunto de valores singulares,
S1 > S2∗ > · · · > Sp∗ , con p < n.
∗
El diseño óptimo de un algoritmo secuencial y el diseño, implementación,

análisis teórico de prestaciones y experimentación de un algoritmo paralelo co-
rrespondiente al método MBidiag es un desarrollo que se tiene previsto brinde
una nueva rutina paralela, eficiente y portable que forme parte de la biblioteca
del PIVSVP, teniendo con esto un trabajo que queda por realizar en el futuro.
Un problema fundamental en los métodos de tipo Newton es la selección de
la aproximación inicial a la solución, a partir de la cual se calculan sucesivas
168
aproximaciones. Este constituye un problema abierto en esta tesis, el cual forma
parte del que llamaremos problema de globalización, cuya resolución consiste,
en términos generales, en desarrollar técnicas que permitan resolver el PIAVS
bajo cualesquiera condiciones (entre otras, partiendo de cualquier aproximación
inicial o partiendo de una de fácil cálculo y que garantice la convergencia del
algoritmo), obteniendo algoritmos que convergen bajo cualquier circunstancia,
contribuyendo ası́ a la robustez de los mismos.
Un tarea importante que queda por realizar es la implementación en el cluster
MareNostrum de todos los algoritmos diseñados en este trabajo, de modo que se
pueda tomar ventaja de las caracterı́sticas de alto rendimiento de este cluster.
Los resultados que de ello se obtengan, permitirán analizar el comportamiento
de los algoritmos y compararlos con los resultados de implementaciones en otros
clusters, como los reportados en este trabajo, para la mejora de las prestaciones
paralelas de algoritmos de alto costo computacional.
Publicaciones
El desarrollo de esta tesis ha sido soportado por el proyecto de investi-
gación Desarrollo y Optimización de Código Paralelo para Sistemas de Audio
3D (TIC2003-08238-C02-02), subvencionado por la Comisión Interministerial
de Ciencia y Tecnologı́a del 1 de Diciembre de 2003 al 30 de Noviembre del 2006.
Las publicaciones al respecto de este trabajo de tesis son:
G.B.Flores, P.V. Alberti , A.M.Vidal. Solución Paralela del Problema Inverso

Simétrico Multiplicativo de Valores Propios. XIII Jornadas de Paralelismo. Ac-
tas de las XIII Jornadas de Paralelismo. ISBN: 84-8409-159-7. Septiembre, 2002.
Lleida, España.
G.Flores, A.M.Vidal. Paralelización del Método de Elevación y Proyección para

la Resolución del Problema Inverso de Valores Singulares. Congreso interna-
cional de Computación Paralela, Distribuida y Aplicaciones. Actas del Congre-
sos. ISBN: 968-5823-04-09. Septiembre, 2003. Linares, México.
Georgina Flores Becerra, Antonio M. Vidal Maciá. Parallel Global and Local
Convergent Algorithms for Solving the Inverse Additive Singular Value Problem.
4th WSEAS International Conference on Systems Theory and Scientific Com-
putation (ISTASC’ 04). Actas en CD. ISBN: 960-8547-06-8. Diciembre, 2004.
Puerto de la Cruz (España).
Publicación en: Wseas Transactions on Circuits and Systems (ISSN: 1109-2734).
Volumen: 3, Issue 10, pp 2241-2246. Diciembre, 2004.
169
D.A.Campo, F.J.Correa, G.Flores, A.M.Vidal. Parallel Global Convergent Algo-
rithms for solving the Inverse Additive Singular Value Problem. IADIS Interna-
tional Conference 2005. Proceedings of the Conference. Febrero, 2005. Algarve
(Portugal).
Georgina Flores Becerra, Vı́ctor M. Garcı́a, Antonio M. Vidal. Numerical Ex-

periments on the Solution of the Inverse Additive Singular Value Problem. Inter-
national Conference on Computacional Science 2005. Proceedings of the Con-
ference. Mayo, 2005. Atlanta (USA).
Publicación en: Lecture Notes in Computer Science (ISSN:0302-9743). Volumen:
3514, pp 17-24. Mayo, 2005.
Georgina Flores Becerra, Vı́ctor M. Garcı́a, Antonio M. Vidal. Parallelization of

a Method for the Solution of the Inverse Additive Singular Value Problem. 8th
WSEAS International Conference on APPLIED MATHEMATICS (aceptado).
Diciembre, 2005. Islas Canarias (España).
Georgina Flores Becerra, Vı́ctor M. Garcı́a, Antonio M. Vidal. Efficient Parallel

Algorithm for Constructing a Unit Triangular Matrix with Prescribed Singular
Values. 7th International Meeting on High Performance Computing for Compu-
tational Science (VECPAR’06) (sometido). Julio, 2006. Rı́o de Janeiro, Brasil.
170
Bibliografı́a
[ABB+ 95] E. Anderson, Z. Bai, C. Bishof, Demmel J., and Dongarra J. LA-
PACK User Guide; Second edition. SIAM, 1995.
[BCC97] L.S. Blackford, J. Choi, and A. Clearly. ScaLAPACK User’s

Guide. SIAM, 1997.
[BMX03] Zheng−jian Bai, Benedetta Morini, and Shu−fang Xu. The inter-
cept method for inverse singular value problems. 2003.
[Bro91] R.W. Brockett. Dynamical sustems that sort lists and solve
the linear programming problems. Proc. 27th IEEE Conf. De-
cision and Control and Linear Alg. Appl., -,146:799–803,79–91,
1988,1991.
[BV99] J.M. Badı́a and A.M. Vidal. Resolución paralela del problema in-
verso de los valores propios de matrices de toeplitz reales simétri-
cas. Technical Report DI01-04/99, Departamento de Informática,
Universidad Jaime I, 1999.
[CBM03] Raymond H. Chan, Zheng−jian Bai, and Benedetta Morigi. On

the convergence rate of a newton-like method for inverse eigenva-
lue and inverse singular value problems. International Journal of
Applications Mathematics, 3, 2003.
[CC96] Xuzhou Chen and Moody T. Chu. On the least squares solu-
tion of inverse eigenvalue problems. SIAM,Journal on Numerical
Analysis, 33(6), 1996.
[CCFV05] D.A. Campo, F.J. Correa, G. Flores, and A.M. Vidal. Parallel
global convergent algorithms for solving the inverse additive sin-
gular value problem. Proceedings of the IADIS International Con-
ference. Applied Computing, pages 49–56, 2005.
[CDD+ 95] J. Choi, J. Demmel, I. Dhillon, J Dongarra, S. Ostrouchov, A. Pe-

titet, K. Stanley, D Walker, and R.C. Whaley. Scalapack: A
171
portable linear algebra library for distributed memory computers.
design issues and performance. 1995.
[CDK+ 01] R. Chandra, L. Dagum, D. Kohr, D. Maydan, J. McDonald, and

R. Menon. Parallel Programming in OpenMP. Morgan Kaufmann
Publishers, 2001.
[CDO+ 95] J. Choi, J. Dongarra, S. Ostrouchov, A. Petittet, and D. Walker.

A proposal for a set of parallel basic linear algebra subprograms.
Technical report ut−cs−95−292, Department of Computer Scien-
ce, University of Tennessee, 1995.
[Chu92a] Moody T. Chu. Numerical methods for inverse singular value

problems. SIAM, Journal Numerical Analysis, 29, 1992.
[Chu92b] M.T. Chu. Matrix differential equations: A continuous realiza-

tion process for linear algebra problems. Nonlinear Anal., TMA,
1(12):1125–1146, 1992.
[Chu98] Moody T. Chu. Inverse eigenvalue problems. SIAM, Review, 40,

1998.
[Chu99] Moody T. Chu. On constructing matrices with prescribed singular

values and diagonal elements. Journal Linear Algebra and its
Applications, 288:11–22, 1999.
[Chu00] Moddy T. Chu. A fast recursive algorithm for constructing ma-

trices with prescribed eigenvalues and singular values. SIAM,
Journal on Numerical Analysis, 37(3):1004–1020, 2000.
[Cor03] Intel Corporation. Intel(R) Fortran Language Reference (online

version). 2003.
[Cor04] Intel Corporation. Intel (R) Math Kernel Library. Reference Ma-
nual. 2004.
[DD95] J. Dongarra and T. Dunigan. Message-passing performance of

various computers. Technical Report, UT-CS-95-299. Department
of Computer Science, University of Tennessee, 1995.
[DHvdV93] J. Demmel, M. Heath, and H. van der Vorst. Parallel numerical

linear algebra. 1993.
[DS83] J.E. Dennis and R.B. Schnabel. Numerical Methods for Uncon-
strained Optimization and Nonlinear Equations. Prentice Hall,
1983.
172
[FBGV05] G. Flores-Becerra, V.M. Garcı́a, and A.M. Vidal. Numerical ex-
periments on the solution of the inverse additive singular value
problem. ICCS 2005: 5th International Conference. Proceedings,
Part I, pages 17–24, 2005.
[FBVM03] Georgina Flores Becerra and Antonio M. Vidal Maciá. Parale-

lización del método de elevación y proyección para la resolución
del problema inverso de valores singulares. Primer Congreso In-
ternacional de Computación Paralela, Distribuida y Aplicaciones,
2003. Linares,México.
[FNO87] S. Friedland, J.Ñocedal, and M.L. Overton. The formulation and

analysis of numerical methods for inverse eigenvalue problems.
SIAM, Journal on Numerical Analysis, 24(3), 1987.
[FVA02] G. B. Flores, A. M. Vidal, and P. V. Alberti. Solución paralela

del problema inverso simétrico multiplicativo de valores propios.
XIII Jornadas de Paralelismo, 2002. Lleida, España.
[Giu02] Mauro Giudici. Some problems for the applicat of inverse tech-
niques to environmental modelling. IndAM Workshop, Inverse
Problems and Applications, 2002.
[GLS94] W. Groupp, E. Lusk, and A. Skjellum. Using MPI: Portable Pa-

rallel Programming with Message Passing Interface. MIT Press,
1994.
[Gra98] Norman Gray. Course: Numerical astronomy 1. inverse problems.

Department of Physics and Astronomy. University of Glasgow,
1998.
[Gro99] Charles W. Groetsch. Inverse Problems. Activities for Undergra-

duates. The mathematical association of America, 1999.
[GvL96] G.H. Golub and C.F. van Loan. Matrix computations. Johns
Hopkins University Press, 1996.
[HDDCH88] S. Hammarling, J. Dongarra, J. Du Croz, and Richard J. Hanson.

An extended set of fortran basic linear algebra subroutines. ACM
Trans. Mathemathical Software, 1988.
[Hor54] A. Horn. On the eigenvalues of a matrix with prescribed singular

values. Proc. Amer. Math. Soc., 5:4, 1954.
[KA00] Przemyslaw Kosowski and Smoktunowicz Alicja. On constructing

unit triangular matrices with prescribed singular values. Compu-
ting, 64(3):279–285, 2000.
173
[Kel95] C. Kelley. Iterative Methods for Linear and Nonlinear Equations.
SIAM, 1995.
[KGGKrp94] V. Kumar, A. Grama, A. Gupta, and G. Kary pis. Introduction

to Parallel Computing. Desing and analysis algorithms. The Ben-
jamin/Cummings Publishing Company, 1994.
[LM01] Chi-Kwong Li and Roy Mathias. Construction of matrices with

prescribed singular values and eigenvalues. BIT, 41(1):115–126,
2001.
[MT97] I. Martin and F. Tirado. Relationships beteen efficiency and exe-

cution time of full multigrid methods on parallel computers. IEEE
Transactions on Parallel and Distributed Systems, 8(6), 1997.
[Pol03] Tiziano Politi. A discrete approach for the inverse singular value
problem in some quadratic group. Workshop: Numerical Methods
for Structured System. International Conference on Computation-
al Science, 2003.
[SG03] Inc. Silicon Graphics. Scientific Computing Software Li-

brary(SCSL) User’s guide. 2003.
[TF03] S. M. Tan and Colin Fox. Inverse problems. lecture courses. De-
partment of Physics, The University of Auckland, 2003.
[Tre97] W.F. Trench. Numerical solution of the inverse eigenvalue pro-

blem for real symmetric toeplitz matrices. SIAM, Journal on
Scientific Computing, 18(6):1722–1736, 1997.
[TV82] Albert Tarantola and Bernard Valette. Generalized nonlinear in-

verse problems solved using the least squares criterion. Reviews
of Geophysics and Space Physics, 20(2), 1982.
[VA01] A.M. Vidal and P.V. Alberti. Una implementación paralela de una
solución de mı́nimos cuadrados para el problema inverso aditivo
de valores propios. XII Jornadas de Paralelismo, 2001. Valen-
cia,España.
[VA02] A.M. Vidal and P.V. Alberti. Una aproximación paralela al pro-
blema inverso aditivo de valores propios. Métodos Numéricos en
Ingenierı́a V, SEMNI, 2002.
[VL92] C. Van Loan. Computational Frameworks for the Fast Fourier

Transform. SIAM, 1992.
[VP00] A.M. Vidal and J.L. Pérez. Introducción a la programación en

MPI. Publicaciones Universidad Politécnica de Valencia, 2000.
174

Borrador Georgina

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Borrador Georgina

Caricato da

Copyright:

Formati disponibili

Algoritmos Secuenciales y Paralelos para la

Resolución del Problema Inverso de Valores

Trabajo de Tesis Doctoral

2. Métodos y Algoritmos Secuenciales para la Resolución del PI-

3. Implementación, Análisis y Evaluación de los Algoritmos del

4. Algoritmos Paralelos para la Resolución del PIAVS 77

5. Resolución Paralela del PIEVS 109

6. Algoritmos para la Resolución del PIVSVP 139

7. Conclusiones y Perspectivas 165

2.1. Puntos iniciales del caso ChuBai . . . . . . . . . . . . . . . . . . 25

4.1. Tiempos de Ejecución Teóricos de FB en Kefren . . . . . . . . . 97

5.1. Tiempos de ejecución experimentales de MI y EP para el PIEVS 114

6.1. Resultados del caso Triu con MTriIU . . . . . . . . . . . . . . . . 145

4.1. Tiempos de ejecución teóricos vs. experimentales de FB . . . . . 101

5.1. Tiempos de ejecución experimentales con algoritmos PIAVS vs

6.1. Speedup experimental de MTriIU en Kefren, SIN construir A en

El propósito de coleccionar datos es obtener información significativa acerca

Entrada → P roceso → Salida

Si x simboliza la entrada y K el proceso, entonces el problema directo es encon-

Entrada P roceso Salida

Causa M odelo Ef ecto

Causa M odelo Ef ecto

mientras que en el problema de identificación del modelo, dada información de

Entrada P roceso Salida

Causa M odelo Ef ecto

Los problemas directos se caracterizan por tener solución única y estable,

Problemas Inversos en Cálculo. El cálculo es particularmente

Problemas Inversos en Ecuaciones Diferenciales. Muchos de

Problemas Inversos en Algebra Lineal. El problema básico

De acuerdo a qué elementos se identifican como incógnitas de un problema

Problemas inversos para estimar parámetros. Tratan de la

Problemas inversos para estimar funciones. Involucran la de-

Dentro de los problemas inversos para la estimación de parámetros, se en-

1.1. Definición del Problema Inverso de

1.1.1. Los Problemas Inversos de Valores Propios

Dada una familia de matrices A(c) ∈ Ψ, con c = [c1 , c2 , · · · , cl ]t ∈ F l

En [Chu98] se puede encontrar una clasificación de estos problemas inversos,

MVIEP. Problema Inverso Multivariable de Valores Propios

LSIEP. Caso Aditivo Simétrico.

Dado un conjunto de escalares λ∗1 , λ∗2 , ..., λ∗m ⊂ < encon-

y un conjunto τ = {τ1 , τ2 , ..., τm }de ı́ndices, con 1 ≤ τ1 <

donde λi (X), i = 1, n, son valores propios de la matriz X,

Dada una matriz simétrica y definida positiva A ∈ <n×n y

1.1.2. Los Problemas Inversos de Valores Singulares

Dada una familia de matrices A(c) ∈ <m×n (m ≥ n), con c =

Definición del Problema Inverso de Valores Singulares: Caso Aditi-

Dado un conjunto de matrices A0 , A1 , ..., Al ∈ <m×n (m ≥

Definición del Problema Inverso de Valores Singulares: Caso Multi-

Dada una matriz A ∈ <m×n (m ≥ n), y un conjunto de

donde A = PA SA QtA es la descomposición en valores sin-

F Diseñar algoritmos secuenciales que implementen los métodos

1.3. Estado del Arte

1.4. Planteamiento del Problema

Problema Inverso Aditivo de Valores Singulares (PIAVS).

A0 A1 = e1 et1 A2 = e2 et2 A3 = e3 et3

Problema Inverso Estructurado de Valores Singulares (PIEVS).

T = toep(primer vector columna de T, primer vector renglón de T ) =

Si a partir de T se define T̃ como

T̃ se puede reescribir como

T̃ = In +t̃1 toep(e2 , 0tn )+...+t̃(n−2) toep(en−1 , 0tn )+t̃(n−1) toep(en , 0tn )+

donde ei es el i-ésimo vector canónico y 0n es un vector columna

queda representado como un Problema Inverso Aditivo de Valores

Problema Inverso de Valores Singulares y Valores Propios