8.4.12 pvsyr2

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

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

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

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

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$ .
- "y": 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 PyACTS.PyPBLAS as 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: PvSYR2"
        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)
        y=ones([n,1])
        print "y'=",transpose(y)
        a=identity(n,Float)
        print "a=",a
else:
        alpha,a,x,y=None,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)
y=Num2PyACTS(y,ACTS_lib)
a=Num2PyACTS(a,ACTS_lib)
#We call PBLAS routine
a= PyPBLAS.pvsyr2(alpha,x,y,a)
a_num=PyACTS2Num(a)
if PyACTS.iread==1:
        print "PvSYR2'=",transpose(a_num)
PyACTS.gridexit()

El resultado de este código es el siguiente:

[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPypvsyr2.py
Example of using PyPBLAS 2: PvSYR2
N= 8 ;nprow x npcol: 2 x 2
Block's size: 2 * 2
alpha= 5
x'= [ [0 1 2 3 4 5 6 7]]
y'= [ [1 1 1 1 1 1 1 1]]
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.]]
PvSYR2= [[  1.   0.   0.   0.   0.   0.   0.   0.]
 [  5.  11.   0.   0.   0.   0.   0.   0.]
 [ 10.  15.  21.   0.   0.   0.   0.   0.]
 [ 15.  20.  25.  31.   0.   0.   0.   0.]
 [ 20.  25.  30.  35.  41.   0.   0.   0.]
 [ 25.  30.  35.  40.  45.  51.   0.   0.]
 [ 30.  35.  40.  45.  50.  55.  61.   0.]
 [ 35.  40.  45.  50.  55.  60.  65.  71.]]

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.pvsyr2(alpha,x,y,a,uplo='L')

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