8.5.5 pvherk

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

Esta rutina se provee para matrices simétricas con elementos de tipo 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:

from PyACTS import *
import PyACTS.PyPBLAS as PyPBLAS
from RandomArray import *
from Numeric import *
#Dimension of Arrays
n,k=6,6
def make_sym(x,y):
        return x*y+(x+y)*1j
#Initiliaze the Grid
PyACTS.gridinit()
if PyACTS.iread==1:
        print "Example of using PyPBLAS 3: PvHERK"
        print "N=",n,";nprow x npcol:",PyACTS.nprow,"x",PyACTS.npcol
        print "Block's size:",PyACTS.mb,"*",PyACTS.nb
        a=ones([n,k])+1j*ones([n,k])
        print "a=",a
        c=fromfunction(make_sym,(n,n))
        print "c=",c
        alpha,beta=2.,3.
        print "alpha=",alpha,";","beta=",beta
else:
        alpha,a,beta,c=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)
c=Num2PyACTS(c,ACTS_lib)
#We call PBLAS routine
c= PyPBLAS.pvherk(alpha,a,beta,c)
c_num=PyACTS2Num(c)
if PyACTS.iread==1:
        print "PvHERK=",transpose(c_num)
PyACTS.gridexit()

[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPypvherk.py
Example of using PyPBLAS 3: PvHERK
N= 6 ;nprow x npcol: 2 x 2
Block's size: 2 * 2
a= [[ 1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j]
 [ 1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j]
 [ 1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j]
 [ 1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j]
 [ 1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j]
 [ 1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j  1.+1.j]]
c= [[  0. +0.j   0. +1.j   0. +2.j   0. +3.j   0. +4.j   0. +5.j]
 [  0. +1.j   1. +2.j   2. +3.j   3. +4.j   4. +5.j   5. +6.j]
 [  0. +2.j   2. +3.j   4. +4.j   6. +5.j   8. +6.j  10. +7.j]
 [  0. +3.j   3. +4.j   6. +5.j   9. +6.j  12. +7.j  15. +8.j]
 [  0. +4.j   4. +5.j   8. +6.j  12. +7.j  16. +8.j  20. +9.j]
 [  0. +5.j   5. +6.j  10. +7.j  15. +8.j  20. +9.j  25.+10.j]]
alpha= 2.0 ; beta= 3.0
PvHERK= [[ 24. +0.j   0. +1.j   0. +2.j   0. +3.j   0. +4.j   0. +5.j]
 [ 24. +3.j  27. +0.j   2. +3.j   3. +4.j   4. +5.j   5. +6.j]
 [ 24. +6.j  30. +9.j  36. +0.j   6. +5.j   8. +6.j  10. +7.j]
 [ 24. +9.j  33.+12.j  42.+15.j  51. +0.j  12. +7.j  15. +8.j]
 [ 24.+12.j  36.+15.j  48.+18.j  60.+21.j  72. +0.j  20. +9.j]
 [ 24.+15.j  39.+18.j  54.+21.j  69.+24.j  84.+27.j  99. +0.j]]

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.pvherk(alpha,a,beta,c,uplo='L'), podríamos comprobar que los valores correctos se obtienen en y por debajo de la diagonal principal.