8.4.10 pvher2

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

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

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

Se ha de tener en cuenta que $x^{H}$ será el vector transpuesto conjugado de x, mientras que $x^{T}$ se corresponde con la transpuesta de x. En el caso que las dimensiones de alguna de las entradas no sea correcta, la rutina PyPBLASpvher2 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 PyPBLAS
from RandomArray import *
from Numeric import *
#Dimension of Arrays
n=6
#Initiliaze the Grid
PyACTS.gridinit()
if PyACTS.iread==1:
        print "Example of using PyPBLAS 2: PvHER2"
        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=ones([n,1])+1.j*reshape(range(n),[n,1])
        print "x'=",transpose(x)
        y=reshape(range(n),[n,1])+1.j*ones([n,1])
        print "y'=",transpose(y)
        a=identity(n,Complex)
        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.pvher2(alpha,x,y,a)
a_num=PyACTS2Num(a)
if PyACTS.iread==1:
        print "PvHER2=",transpose(a_num)
PyACTS.gridexit()

El resultado de este código es el siguiente:

[vgaliano@localhost EXAMPLES]$ mpirun -np 4 mpipython exPypvher2.py
Example of using PyPBLAS 2: PvHER2
N= 6 ;nprow x npcol: 2 x 2
Block's size: 2 * 2
alpha= 5
x'= [ [ 1.+0.j  1.+1.j  1.+2.j  1.+3.j  1.+4.j  1.+5.j]]
y'= [ [ 0.+1.j  1.+1.j  2.+1.j  3.+1.j  4.+1.j  5.+1.j]]
a= [[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j]]
PvHER2= [[   1.+0.j    0.+0.j    0.+0.j    0.+0.j    0.+0.j    0.+0.j]
 [  10.+0.j   21.+0.j    0.+0.j    0.+0.j    0.+0.j    0.+0.j]
 [  20.+0.j   30.+0.j   41.+0.j    0.+0.j    0.+0.j    0.+0.j]
 [  30.+0.j   40.+0.j   50.+0.j   61.+0.j    0.+0.j    0.+0.j]
 [  40.+0.j   50.+0.j   60.+0.j   70.+0.j   81.+0.j    0.+0.j]
 [  50.+0.j   60.+0.j   70.+0.j   80.+0.j   90.+0.j  101.+0.j]]

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

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