8.4.11 pvsyr

a= PyPBLAS.pvsyr(alpha,x,a,[uplo='U'])

La función "PyPBLAS.pvsyr" implementa la siguiente operación entre vectores y matrices con elementos de tipo real:

$\begin{displaymath}\alpha \cdot x \times x^{T} + A \to A \end{displaymath}$

En el caso que las dimensiones de alguna de las entradas no sea correcta, la rutina PyPBLASpvsyr informará de ello y no podrá finalizar la operación.

Por otro lado, debido a las características de la operacion a realizar la matriz resultante es simétrica, por tanto únicamente se proporcionará el resultado de los elementos situados en la diagonal principal y por encima o por debajo de la misma, dependiendo del parametro "uplo". Esta rutina se provee únicamente para matrices con elementos de tipo complejo.

Las características de cada uno de los parámetros son las siguientes:

Parametros de Entrada
- "alpha":Escalar.
- "x": Vector de dimensiones $m \times 1$ .
- "a": Matriz de dimensiones $m\times n$ .
- "uplo": Caracter que indica cómo queremos obtener el resultado en "a".
  - uplo='U': Triangular Superior (valor por defecto).
  - uplo='L': Triangular Inferior.
Parametros de Salida
- "a": Vector distribuido donde se almacena el resultado.

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


from PyACTS import *
import PyPBLAS
from RandomArray import *
from Numeric import *
#Dimension of Arrays
n=8
#Initiliaze the Grid
PyACTS.gridinit()
if PyACTS.iread==1:
        print "Example of using PyPBLAS 2: PvSYR"
        print "N=",n,";nprow x npcol:",PyACTS.nprow,"x",PyACTS.npcol
        print "Block's size:",PyACTS.mb,"*",PyACTS.nb
        alpha=5
        print "alpha=",alpha
        x=reshape(range(n),[n,1])
        print "x'=",transpose(x)
        a=identity(n)
        print "a=",a
else:
        alpha,a,x=None,None,None
#We convert Numeric Array to PyACTS.Scalapack Array
ACTS_lib=1 # 1=Scalapack
alpha=Scal2PyACTS(alpha,ACTS_lib)
x=Num2PyACTS(x,ACTS_lib)
a=Num2PyACTS(a,ACTS_lib)
#We call PBLAS routine
a= PyPBLAS.pvsyr(alpha,x,a)
a_num=PyACTS2Num(a)
if PyACTS.iread==1:
        print "PvSYR=",transpose(a_num)
PyACTS.gridexit()

El resultado de este código es el siguiente:

[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPypvsyr.py
Example of using PyPBLAS 2: PvSYR
N= 8 ;nprow x npcol: 2 x 2
Block's size: 2 * 2
alpha= 5
x'= [ [0 1 2 3 4 5 6 7]]
a= [[1 0 0 0 0 0 0 0]
 [0 1 0 0 0 0 0 0]
 [0 0 1 0 0 0 0 0]
 [0 0 0 1 0 0 0 0]
 [0 0 0 0 1 0 0 0]
 [0 0 0 0 0 1 0 0]
 [0 0 0 0 0 0 1 0]
 [0 0 0 0 0 0 0 1]]
PvSYR= [[   1.    0.    0.    0.    0.    0.    0.    0.]
 [   0.    6.    0.    0.    0.    0.    0.    0.]
 [   0.   10.   21.    0.    0.    0.    0.    0.]
 [   0.   15.   30.   46.    0.    0.    0.    0.]
 [   0.   20.   40.   60.   81.    0.    0.    0.]
 [   0.   25.   50.   75.  100.  126.    0.    0.]
 [   0.   30.   60.   90.  120.  150.  181.    0.]
 [   0.   35.   70.  105.  140.  175.  210.  246.]]

Se ha de tener en cuenta que el parámetro por defecto para uplo='U', es decir, realizaremos los calculos unicamente que se encuentre en y por encima de la diagonal de la matriz resultante. Si quisieramos obtener la parte por debajo de la diagonal llamaríamos a la rutina del siguiente modo:

a,desca= PyPBLAS.pvsyr(alpha,x,a,uplo='L')

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