9.1.1 pvgesv

b,info=pvgesv(a,b[,ia=1,ja=1,ib=1,jb=1])

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


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

La resolución de este sistema de ecuaciones se lleva a cabo mediante la descomposición LU utilizando la pivotacion parcial y el intercambio de filas de A. De este modo obtenemos sub( A ) = P * L * U, donde P es una matriz permutada, L es una matriz triangular unitaria, y U es una matriz triangular supperior. La forma factorizada de A se utiliza para resolver entonces este múltiple sistema de ecuaciones sub( A ) * X = sub( B ). El vector de salida es un vector donde cada columna representa la solución a cada uno de los sistemas planteados mediante la matriz b de entrada.

La forma de resolver este sistema lineal depende de las características de la matriz y deberemos usar una rutina u otra de esta sección dependiendo del tipo de matriz. En este manual, trataremos de describir de una forma sencilla y clara las principales características de cada uno de los métodos de resolución de este sistema lineal.

Para matrices de tipo general, la resolución se realiza mediante factorización LU con pivotación parcial:


\begin{displaymath}A=P L U \end{displaymath}

donde $P$ es una matriz permutación, L es una matriz triangular inferior con los elementos de la diagonal unitarios, y U es una matriz triangular superior (trapezoidal superior si m<n)

Esta rutina se provee para matrices con elementos de tipo real y complejo. Las características de cada uno de los parámetros son las siguientes:

A continuación mostramos un ejemplo en la utilización de esta rutina:

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 "Example of using ScaLAPACK: PvGESV"
        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
b,info= PySLK.pvgesv(a,b)
b_num=PyACTS2Num(b)
if PyACTS.iread==1:
        print "a*x=b --> x'=",transpose(b_num)
        print "Info:",info
PyACTS.gridexit()
El resultado de este código es el siguiente:
[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPyScapvgesv.py
Example of using ScaLAPACK: PvGESV
N= 8 ;nprow x npcol: 2 x 2
Tam. Bloques: 2 * 2
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]]
Info: 0

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