9.4.2 pvposvx

a,af,equed,sr,sc,b,x,rcond,ferr,berr,info= PySLK.pvposvx(a,b[,fact,uplo,equed,ACTS_af])

La rutina "pvposvx" resuelve la ecuacion del sistema lineal siguiente:

$\begin{displaymath}A\times X = B \end{displaymath}$

donde es una matriz $n \times n$ , y y son matrices de tamaño $n \times nrhs$ .

Los errores en la solución y las condiciones de la estimación tambien se especifican en esta rutina. La rutina "pvposvx" utiliza la factorización de Cholesky

$\begin{displaymath}A = U \times T \times U \end{displaymath}$

$\begin{displaymath}A = L \times L \times T \end{displaymath}$

para computar la solución al sistema de ecuaciones anteriormente citado. La utilización de estas rútinas es mas complejas que las rutinas sencillas (), vistas en apartados anteriores. En esta rutina se realizan los siguientes pasos:

Si fact='E', con el fin de equilibrar el sistema se computan los factores reales escalares. $diag(SR) \times A \times diag(SC) \times inv(diag(SC)) \times X = diag(SR) \times B$ .
fact='E', o fact='N', se utiliza la descomposición Cholesky para factorizar la matriz como:

$\begin{displaymath}A = U \times T \times U \end{displaymath}$

o

$\begin{displaymath}A = L \times L \times T \end{displaymath}$

donde es una matriz triangular superior y es una matriz triangular inferior.
La forma factorizada de se utiliza para estimar el número de condición de la matriz . Si el número de condición es menos que la precisión de la maquina, los tres siguientes pasos se saltan.
El sistema de ecuaciones se resuelve utilizando la forma factorizada de A.
Se aplica un proceso iterativo para obtener exactitud en la solución y calcular los errores.
Si fact='E' y se utiliza equilibración, la matriz se multiplica previamente por , de este modo se resuelve la ecuación antes de la equilibración.

A continuación detallaremos los parámetros de entrada y salida de esta función:

Parámetros de Entrada
- a: Matriz de tipo PyACTS de dimensiones $n \times n$ .
- b: Matriz de tipo PyACTS de dimensiones $n \times nrhs$ .
- fact: Indicaremos si la matriz a está en su forma factorizada o no, y en el caso que no lo esté si debemos equilibrarla antes de realizar la factorización.
  - fact='F': La matriz af contendrá la forma factorizada de a. Si equed<>'N', la matriz a ha sido equilibrada con los factores dados por r y c.
  - fact='N': La matriz a se copiará en la matriz af y se factorizará.
  - fact='E': La matriz a será equilibrada si es necesario y entonces se copiará y factorizará en af.
- uplo: Indica la utilización de la matriz triangular:
  - uplo='U': La matriz triangular superior es almacenada.
  - uplo='L': La matriz triangular inferior es almacenada.
- af: Este parametro es opcional. Dependiendo de los parámetros de entrada la matriz af tendrá diferente forma.
  - Si fact='F', entonces af es un argumento de entrada y contiene la factorizacion triangular o de la factorizacion de Cholesky $A = U \times T \times U$ o $A = L \times L \times T$ .
  - Si fact='N', entonces af es un argumento de salida que devuelve la forma factorizada y de la factorización $A = P \times L \times U$ .
  - Si fact='E', entonces af es un argumento de salida que devuelve el factor triangular o de la factorización $A = U \times T \times U$ o $A = L \times L \times T$ de la matriz equilibrada .
Parámetros de Salida
- a: Como argumento de salida, si fact='E' y equed='Y', entonces a se sobreescribe por $A= diag(SR) \times A \times diag(SC)$
- af: Como argumento de salida puede tener las siguientes formas:
  - Si fact='N' : entonces af devuelve la factorización triangular o de Cholesky a partir de $A = U \times T \times U$ o $A = L \times L \times T$ donde es la matriz original.
  - Si fact='N' : entonces af devuelve la factorización triangular o de Cholesky a partir de $A = U \times T \times U$ o $A = L \times L \times T$ donde es la matriz equilibrada.
- equed: Indica la forma en la que fue realizada la equilibracion:
  - Si equed='N' : No se realizó equilibración.
  - Si equed='R' : Equilibración por filas.
  - Si equed='C' : Equilibración por columnas.
  - Si equed='B' : Ambas equilibraciones fueron realizadas (filas y columnas).
- sr: Contiene los factores de escala para las filas.
- sc: Contiene los factores de escala para las columnas.
- b: Si equed = 'N', b no se modificará; si trans='N' y equed = 'R' o 'B', b se sobrrescribe por $diag(R) \times B$ . Si trans='T' o 'C' y equed = 'R' o 'B', b se sobreescribe por $diage(C) \times B$
- x: Si info=0, la matriz solución de tamaño $N \times NRHS$ del sistema de ecuaciones original.
- rcond: Es un número real que expresa la estimación de la equilibración. Si rcond es menor que la precisión de la maquina (rcond=0), la matriz es singular a la precisión de trabajo.
- ferr: La estimación del error ''hacia delante'' para cada elemento del vector x
- berr: La estimación del error ''hacia atrás'' para cada elemento del vector x
- info: Indica el estado de salida de la rutina:
  - Si info=0 : Ejecución con éxito
  - Si info<0 : Si info=-i el i-ésimo argumento tuvo un valor ilegal.
  - Si info>0 : Si info=i, y i es
    - <=N : es exactamente cero. La factorización ha sido completada, pero el factor es singular.
    - =N+1 : rcond es menor que la precisión de la maquina

Consideramos que son muchos los parametros y las opciones de ejecución en estas rutinas para expertos. A continuación mostramos un ejemplo que resuelve el mismo problema que la rutina pvgesv vista en el apartado anterior.

from PyACTS import *
import PyACTS.PyScaLAPACK as PySLK
from RandomArray import *
from Numeric import *
n,nrhs=8,2
#Initiliaze the Grid
PyACTS.gridinit()
if PyACTS.iread==1:
        print "Ejemplo de Utilizacion ScaLAPACK: PvPOSVX"
        print "N=",n,";nprow x npcol:",PyACTS.nprow,"x",PyACTS.npcol
        print "Tam. Bloques:",PyACTS.mb,"*",PyACTS.nb
        a=8*identity(n,Float)
        print "a=",a
        b=ones((n,nrhs))
        print "b'=",transpose(b)
else:
        a,b=None,None
#We convert Numeric Array to PyACTS.Scalapack Array
ACTS_lib=1 # 1=Scalapack
a=Num2PyACTS(a,ACTS_lib)
b=Num2PyACTS(b,ACTS_lib)
#We call PBLAS routine
a,af,equed,sr,sc,b,x,rcond,ferr,berr,info= PySLK.pvposvx(a,b)

x_num=PyACTS2Num(x)
if PyACTS.iread==1:
        print "a*x=b --> x'=",transpose(x_num)
        print "r=",transpose(r)
        print "c=",transpose(c)
        print "ferr:",transpose(ferr),"; berr=",transpose(berr)
        print "Info:",info
PyACTS.gridexit()

El resultado en la ejecución de este ejemplo sería el siguiente:

[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPyScapvposvx.py
Ejemplo de Utilizacion ScaLAPACK: PvPOSVX
N= 8 ;nprow x npcol: 2 x 2
Tam. Bloques: 32 * 32
a= [[ 8.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  8.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  8.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  8.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  8.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  8.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  8.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  8.]]
b'= [[1 1 1 1 1 1 1 1]
 [1 1 1 1 1 1 1 1]]
a*x=b --> x'= [[ 0.125  0.125  0.125  0.125  0.125  0.125  0.125  0.125]
 [ 0.125  0.125  0.125  0.125  0.125  0.125  0.125  0.125]]
sr= [ [ 0.  0.  0.  0.  0.  0.  0.  0.]]
sc= [ [ 0.  0.  0.  0.  0.  0.  0.  0.]]
ferr: [ [  2.10942375e-15   2.10942375e-15   0.00000000e+00   0.00000000e+00
         0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]] ;
berr= [ [  5.55111512e-17   5.55111512e-17   0.00000000e+00   0.00000000e+00
         0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]]
Info: 0

See Sobre este documento... para sugerencias en cambios.