9.4.1 pvgesvx

a,af,equed,r,c,b,x,rcond,ferr,berr,info= PySLK.pvgesvx(a,b[,fact,trans,equed,ACTS_af,ACTS_x])

La rutina "pvgesvx" 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 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.
- Si trans='N': $diag(R) \times A \times diag(C) \times inv(diag(C)) \times X = diag(R) \times B$
- Si trans='T': $(diag(R) \times A \times diag(C))^T \times inv(diag(R))\times X = diag(C)\times B$
- Si trans='C': $(diag(R) \times A \times diag(C))^H \times inv(diag(R))\times X = diag(C)\times B$
Que el sistema sea o no equilibrado depende de la matriz , pero si la equilibración es utilizada , se sobreescribirá por $diag(R) \times A \times diag(C)$ y por $diag(R) \times B$ (si trans='N') o por $diag(C) \times B$ (si trans='T').
fact='E', o fact='N', se utiliza la descomposición para factorizar la matriz como:
$A = P \times L \times U$
, donde es una matriz permutación, es una matriz unitaria triangular inferior, y es una matriz triangular.
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 iteratico 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 (si trans='N') o por (si trans='T' o 'C'). De este modo se resuelve la ecuación antes de la equilibración.

pvgesvx(ACTS_a,ACTS_b,fact='N',trans='N',equed='N',x=None,ACTS_af=None,rcond=0

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 entra 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.
- trans: Indica la forma del sistema de ecuaciones:
  - trans='N': $A \times X = B$ (No traspuesta).
  - trans='T': $A^T \times X = B$ (traspuesta).
  - trans='C': $A^H \times X = B$ (traspuesta).
- 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 los factores L y U de la factorizacion $A = P \times L \times U$ computada con psgetrf. Si equed='N', entonces af contiene la forma factorizada forma de la matriz a.
  - 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 la forma factorizada y de la factorización $A = P \times L \times U$ de la matriz equilibrada a.
x
Parámetros de Salida
- a: Como argumento de salida, si equed<>'N' , entonces a es escalada del siguiente modo:
  - Si equed='R' : $A= diag(R) \times A$
  - Si equed='C' : $A= A \times diag(C)$
  - Si equed='B' : $A= diag(R) \times A \times diag(C)$
- af: Como argumento de salida puede tener las siguientes formas:
  - Si fact='N' : entonces af es devuelve los factores y de la factorización $A = P \times L \times U$ de la matriz original a.
  - Si fact='E' : entonces af es devuelve los factores y de la factorización $A = P \times L \times U$ de la matriz equilibrada a.
- 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).
- r: Contiene los factores de escala para las filas.
- c: 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$ .
- 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: PvGESVX"
        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,r,c,b,x,rcond,ferr,berr,info= PySLK.pvgesvx(a,b,fact='E')

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 exPyScapvgesvx.py
Ejemplo de Utilizacion ScaLAPACK: PvGESVX
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]]
r= [ [ 0.125  0.125  0.125  0.125  0.125  0.125  0.125  0.125]]
c= [ [ 1.  1.  1.  1.  1.  1.  1.  1.]]
ferr: [ [  1.99840144e-15   1.99840144e-15   0.00000000e+00   0.00000000e+00
         0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]] ; berr= [ [ 0.  0.  0.  0.  0.  0.  0.  0.]]
Info: 0

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