8.5.6 pvsyr2k

c=PyPBLAS.pvsyr2k(alpha,a,b,beta,c[,uplo,trans])

La función "PyPBLAS.pvsyr2k" implementa la siguiente operación entre matrices teniendo en cuenta que este tipo de matrices son simétricas:

$\begin{displaymath}\alpha \cdot A\times B^T + \alpha \cdot B\times A^T + beta \cdot C \to C\end{displaymath}$

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

Esta rutina se provee para matrices simétricas con elementos de tipo real o complejo. Un detalle importante en esta rutina es la suposición que las matrices de entrada son simétricas, de este modo se realizan los cálculos con la parte superior (o inferior) a la diagonal. El resultado válido en la matriz devuelta por la función será el situado en la posición que le indiquemos a través del parámetro uplo. Las características de cada uno de los parámetros son las siguientes:

Parametros de Entrada
- "alpha":Escalar.
- "a": Matriz de dimensiones $m \times m$ .
- "b": Matriz de dimensiones $m \times m$ .
- "beta":Escalar.
- "c": Matriz de dimensiones $m \times m$ .
- "uplo": Debido a que las matrices son simétricas, con este caracter indicamos en que lado de la diagonal principal vamos a realizar cálculos y obtener los resultados:
  - uplo='U': (Valor por defecto).Se obtienen los resultados en la diagonal principal y por encima de ella.
  - uplo='L': Se obtienen los resultados en la diagonal principal y por debajo de ella.
- "trans": A partir de este parámtetro se pueden realizar dos operaciones diferentes, realizando (o no) la transpuesta de la matriz a y b:
  - trans='N': (Valor por defecto).La operación que se lleva a cabo es : $\alpha \cdot A\times B^T + \alpha \cdot B\times A^T + beta \cdot C \to C$ .
  - trans='T': La operación que se lleva a cabo es : $\alpha \cdot A^T\times B + \alpha \cdot B^T\times A + beta \cdot C \to C$ .
Parametros de Salida
- "c": 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
def make_sym_b(x,y):
        return x*y
def make_sym_c(x,y):
        return x+y
n=6
#Initiliaze the Grid
PyACTS.gridinit()
if PyACTS.iread==1:
        print "Example of using PyPBLAS 3: PvSYR2K"
        print "N=",n,";nprow x npcol:",PyACTS.nprow,"x",PyACTS.npcol
        print "Block's size:",PyACTS.mb,"*",PyACTS.nb
        a=ones([n,n])
        print "a=",a
        b=fromfunction(make_sym_b,(n,n))
        print "b=",b
        c=fromfunction(make_sym_c,(n,n))
        print "c=",c
        alpha,beta=2.,3.
        print "alpha=",alpha,";","beta=",beta
else:
        alpha,a,b,beta,c=None,None,None,None,None
#We convert Numeric Array to PyACTS.Scalapack Array
ACTS_lib=1 # 1=Scalapack
alpha=Scal2PyACTS(alpha,ACTS_lib)
beta=Scal2PyACTS(beta,ACTS_lib)
a=Num2PyACTS(a,ACTS_lib)
b=Num2PyACTS(b,ACTS_lib)
c=Num2PyACTS(c,ACTS_lib)
#We call PBLAS routine
c= PyPBLAS.pvsyr2k(alpha,a,b,beta,c)
c_num=PyACTS2Num(c)
if PyACTS.iread==1:
        print "PvSYR2K=",transpose(c_num)
PyACTS.gridexit()

El resultado de este código es el siguiente:

[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPypvsyr2k.py
Example of using PyPBLAS 3: PvSYR2K
N= 6 ;nprow x npcol: 2 x 2
Block's size: 2 * 2
a= [[1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]]
b= [[ 0  0  0  0  0  0]
 [ 0  1  2  3  4  5]
 [ 0  2  4  6  8 10]
 [ 0  3  6  9 12 15]
 [ 0  4  8 12 16 20]
 [ 0  5 10 15 20 25]]
c= [[ 0  1  2  3  4  5]
 [ 1  2  3  4  5  6]
 [ 2  3  4  5  6  7]
 [ 3  4  5  6  7  8]
 [ 4  5  6  7  8  9]
 [ 5  6  7  8  9 10]]
alpha= 2.0 ; beta= 3.0
PvSYR2K= [[   0.    1.    2.    3.    4.    5.]
 [  33.   66.    3.    4.    5.    6.]
 [  66.   99.  132.    5.    6.    7.]
 [  99.  132.  165.  198.    7.    8.]
 [ 132.  165.  198.  231.  264.    9.]
 [ 165.  198.  231.  264.  297.  330.]]

Podemos ver en este ejemplo, que el resultado no es una matriz simétrica aunque debiera serlo puesto que a y c lo son y el resultado de la operación descrita ha de genera una matriz simétrica. Como por defecto uplo='U', el resultado es una matriz simétrica con los valores correctos situados en y por encima de la diagonal. Si ejecutaramos c=PyPBLAS.pvsyr2k(alpha,a,b,beta,c,uplo='L'), podríamos comprobar que los valores correctos se obtienen en y por debajo de la diagonal principal.

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