Welcome to pyclblas’s documentation!¶

Contents:

Blas Families¶

BLAS Level 1 Functions¶

SWAP - Swap elements from 2 vectors¶

pyclblas.clblasCswap(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasCswap

interchanges two vectors of complex-float elements.

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDswap(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDswap

interchanges two vectors of double.

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSswap(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSswap

interchanges two vectors of float.

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZswap(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZswap

interchanges two vectors of double-complex elements.

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SCAL - Scales a vector by a constant¶

pyclblas.clblasCscal(N, alpha, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasCscal

Scales a complex-float vector by a complex-float constant.

( X ← α X )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (complex [in]) – The constant factor for vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDscal(N, alpha, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasDscal

Scales a double vector by a double constant.

( X ← α X )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (float [in]) – The constant factor for vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSscal(N, alpha, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasSscal

Scales a float vector by a float constant.

( X ← α X )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (float [in]) – The constant factor for vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZscal(N, alpha, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasZscal

Scales a complex-double vector by a complex-double constant.

( X ← α X )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (complex [in]) – The constant factor for vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SSCAL - Scales a complex vector by a real constant¶

pyclblas.clblasCsscal(N, alpha, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasCsscal

Scales a complex-float vector by a float constant.

( X ← α X )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (float [in]) – The constant factor for vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZdscal(N, alpha, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasZdscal

Scales a complex-double vector by a double constant.

( X ← α X )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (float [in]) – The constant factor for vector X.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

COPY - Copies elements from vector X to vector Y¶

pyclblas.clblasCcopy(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasCcopy

Copies complex-float elements from vector X to vector Y.

( Y ← X )

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDcopy(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDcopy

Copies double elements from vector X to vector Y.

( Y ← X )

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasScopy(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasScopy

Copies float elements from vector X to vector Y.

( Y ← X )

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZcopy(N, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZcopy

Copies complex-double elements from vector X to vector Y.

( Y ← X )

Parameters:

N (int [in]) – Number of elements in vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

AXPY - Scale X and add to Y¶

pyclblas.clblasCaxpy(N, alpha, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasCaxpy

Scale vector X of complex-float elements and add to Y.

( Y ← α X + Y )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (complex [in]) – The constant factor for vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDaxpy(N, alpha, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDaxpy

Scale vector X of double elements and add to Y.

( Y ← α X + Y )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (float [in]) – The constant factor for vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSaxpy(N, alpha, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSaxpy

Scale vector X of float elements and add to Y.

( Y ← α X + Y )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (float [in]) – The constant factor for vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZaxpy(N, alpha, X, offx, incx, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZaxpy

Scale vector X of double-complex elements and add to Y.

( Y ← α X + Y )

Parameters:

N (int [in]) – Number of elements in vector X.
alpha (complex [in]) – The constant factor for vector X.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

DOT - Dot product of two vectors¶

pyclblas.clblasDdot(N, dotProduct, offDP, X, offx, incx, Y, offy, incy, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDdot

dot product of two vectors containing double elements

Parameters:

N (int [in]) – Number of elements in vector X.
dotProduct (pyopencl.Buffer [out]) – Buffer object that will contain the dot-product value.
offDP (int [in]) – Offset to dot-product in dotProduct buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSdot(N, dotProduct, offDP, X, offx, incx, Y, offy, incy, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasSdot

dot product of two vectors containing float elements

Parameters:

N (int [in]) – Number of elements in vector X.
dotProduct (pyopencl.Buffer [out]) – Buffer object that will contain the dot-product value.
offDP (int [in]) – Offset to dot-product in dotProduct buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasCdotu(N, dotProduct, offDP, X, offx, incx, Y, offy, incy, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasCdotu

dot product of two vectors containing float-complex elements

Parameters:

N (int [in]) – Number of elements in vector X.
dotProduct (pyopencl.Buffer [out]) – Buffer object that will contain the dot-product value.
offDP (int [in]) – Offset to dot-product in dotProduct buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZdotu(N, dotProduct, offDP, X, offx, incx, Y, offy, incy, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasZdotu

dot product of two vectors containing double-complex elements

Parameters:

N (int [in]) – Number of elements in vector X.
dotProduct (pyopencl.Buffer [out]) – Buffer object that will contain the dot-product value.
offDP (int [in]) – Offset to dot-product in dotProduct buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasCdotc(N, dotProduct, offDP, X, offx, incx, Y, offy, incy, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasCdotc

dot product of two vectors containing float-complex elements conjugating the first vector

Parameters:

N (int [in]) – Number of elements in vector X.
dotProduct (pyopencl.Buffer [out]) – Buffer object that will contain the dot-product value.
offDP (int [in]) – Offset to dot-product in dotProduct buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZdotc(N, dotProduct, offDP, X, offx, incx, Y, offy, incy, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasZdotc

dot product of two vectors containing double-complex elements conjugating the first vector

Parameters:

N (int [in]) – Number of elements in vector X.
dotProduct (pyopencl.Buffer [out]) – Buffer object that will contain the dot-product value.
offDP (int [in]) – Offset to dot-product in dotProduct buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

ROTG - Constructs givens plane rotation¶

pyclblas.clblasCrotg(CA, offCA, CB, offCB, C, offC, S, offS, commandQueues, eventWaitList)¶

wraps: clblasCrotg

construct givens plane rotation on float-complex elements

Parameters:

CA (pyopencl.Buffer [out]) – Buffer object that contains CA.
offCA (int [in]) – Offset to CA in CA buffer object. Counted in elements.
CB (pyopencl.Buffer [out]) – Buffer object that contains CB.
offCB (int [in]) – Offset to CB in CB buffer object. Counted in elements.
C (pyopencl.Buffer [out]) – Buffer object that contains C. C is real.
offC (int [in]) – Offset to C in C buffer object. Counted in elements.
S (pyopencl.Buffer [out]) – Buffer object that contains S.
offS (int [in]) – Offset to S in S buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDrotg(DA, offDA, DB, offDB, C, offC, S, offS, commandQueues, eventWaitList)¶

wraps: clblasDrotg

construct givens plane rotation on double elements

Parameters:

DA (pyopencl.Buffer [out]) – Buffer object that contains DA.
offDA (int [in]) – Offset to DA in DA buffer object. Counted in elements.
DB (pyopencl.Buffer [out]) – Buffer object that contains DB.
offDB (int [in]) – Offset to DB in DB buffer object. Counted in elements.
C (pyopencl.Buffer [out]) – Buffer object that contains C.
offC (int [in]) – Offset to C in C buffer object. Counted in elements.
S (pyopencl.Buffer [out]) – Buffer object that contains S.
offS (int [in]) – Offset to S in S buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSrotg(SA, offSA, SB, offSB, C, offC, S, offS, commandQueues, eventWaitList)¶

wraps: clblasSrotg

construct givens plane rotation on float elements

Parameters:

SA (pyopencl.Buffer [out]) – Buffer object that contains SA.
offSA (int [in]) – Offset to SA in SA buffer object. Counted in elements.
SB (pyopencl.Buffer [out]) – Buffer object that contains SB.
offSB (int [in]) – Offset to SB in SB buffer object. Counted in elements.
C (pyopencl.Buffer [out]) – Buffer object that contains C.
offC (int [in]) – Offset to C in C buffer object. Counted in elements.
S (pyopencl.Buffer [out]) – Buffer object that contains S.
offS (int [in]) – Offset to S in S buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZrotg(CA, offCA, CB, offCB, C, offC, S, offS, commandQueues, eventWaitList)¶

wraps: clblasZrotg

construct givens plane rotation on double-complex elements

Parameters:

CA (pyopencl.Buffer [out]) – Buffer object that contains CA.
offCA (int [in]) – Offset to CA in CA buffer object. Counted in elements.
CB (pyopencl.Buffer [out]) – Buffer object that contains CB.
offCB (int [in]) – Offset to CB in CB buffer object. Counted in elements.
C (pyopencl.Buffer [out]) – Buffer object that contains C. C is real.
offC (int [in]) – Offset to C in C buffer object. Counted in elements.
S (pyopencl.Buffer [out]) – Buffer object that contains S.
offS (int [in]) – Offset to S in S buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

ROTMG - Constructs the modified givens rotation¶

pyclblas.clblasDrotmg(DD1, offDD1, DD2, offDD2, DX1, offDX1, DY1, offDY1, DPARAM, offDparam, commandQueues, eventWaitList)¶

wraps: clblasDrotmg

construct the modified givens rotation on double elements

Parameters:

DD1 (pyopencl.Buffer [out]) – Buffer object that contains DD1.
offDD1 (int [in]) – Offset to DD1 in DD1 buffer object. Counted in elements.
DD2 (pyopencl.Buffer [out]) – Buffer object that contains DD2.
offDD2 (int [in]) – Offset to DD2 in DD2 buffer object. Counted in elements.
DX1 (pyopencl.Buffer [out]) – Buffer object that contains DX1.
offDX1 (int [in]) – Offset to DX1 in DX1 buffer object. Counted in elements.
DY1 (pyopencl.Buffer [in]) – Buffer object that contains DY1.
offDY1 (int [in]) – Offset to DY1 in DY1 buffer object. Counted in elements.
DPARAM (pyopencl.Buffer [out]) – Buffer object that contains DPARAM array of minimum length 5 DPARAM(0) = DFLAG DPARAM(1) = DH11 DPARAM(2) = DH21 DPARAM(3) = DH12 DPARAM(4) = DH22.
offDparam (int [in]) – Offset to DPARAM in DPARAM buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSrotmg(SD1, offSD1, SD2, offSD2, SX1, offSX1, SY1, offSY1, SPARAM, offSparam, commandQueues, eventWaitList)¶

wraps: clblasSrotmg

construct the modified givens rotation on float elements

Parameters:

SD1 (pyopencl.Buffer [out]) – Buffer object that contains SD1.
offSD1 (int [in]) – Offset to SD1 in SD1 buffer object. Counted in elements.
SD2 (pyopencl.Buffer [out]) – Buffer object that contains SD2.
offSD2 (int [in]) – Offset to SD2 in SD2 buffer object. Counted in elements.
SX1 (pyopencl.Buffer [out]) – Buffer object that contains SX1.
offSX1 (int [in]) – Offset to SX1 in SX1 buffer object. Counted in elements.
SY1 (pyopencl.Buffer [in]) – Buffer object that contains SY1.
offSY1 (int [in]) – Offset to SY1 in SY1 buffer object. Counted in elements.
SPARAM (pyopencl.Buffer [out]) – Buffer object that contains SPARAM array of minimum length 5 SPARAM(0) = SFLAG SPARAM(1) = SH11 SPARAM(2) = SH21 SPARAM(3) = SH12 SPARAM(4) = SH22.
offSparam (int [in]) – Offset to SPARAM in SPARAM buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

ROT - Apply givens rotation¶

pyclblas.clblasDrot(N, X, offx, incx, Y, offy, incy, C, S, commandQueues, eventWaitList)¶

wraps: clblasDrot

applies a plane rotation for double elements

Parameters:

N (int [in]) – Number of elements in vector X and Y.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
C (float [in]) – C specifies the cosine, cos.
S (float [in]) – S specifies the sine, sin.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSrot(N, X, offx, incx, Y, offy, incy, C, S, commandQueues, eventWaitList)¶

wraps: clblasSrot

applies a plane rotation for float elements

Parameters:

N (int [in]) – Number of elements in vector X and Y.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
C (float [in]) – C specifies the cosine, cos.
S (float [in]) – S specifies the sine, sin.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasCsrot(N, X, offx, incx, Y, offy, incy, C, S, commandQueues, eventWaitList)¶

wraps: clblasCsrot

applies a plane rotation for float-complex elements

Parameters:

N (int [in]) – Number of elements in vector X and Y.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
C (float [in]) – C specifies the cosine, cos. This number is real.
S (float [in]) – S specifies the sine, sin. This number is real.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZdrot(N, X, offx, incx, Y, offy, incy, C, S, commandQueues, eventWaitList)¶

wraps: clblasZdrot

applies a plane rotation for double-complex elements

Parameters:

N (int [in]) – Number of elements in vector X and Y.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
C (float [in]) – C specifies the cosine, cos. This number is real.
S (float [in]) – S specifies the sine, sin. This number is real.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

ROTM - Apply modified givens rotation for points in the plane¶

pyclblas.clblasDrotm(N, X, offx, incx, Y, offy, incy, DPARAM, offDparam, commandQueues, eventWaitList)¶

wraps: clblasDrotm

modified givens rotation for double elements

Parameters:

N (int [in]) – Number of elements in vector X and Y.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
DPARAM (pyopencl.Buffer [in]) – Buffer object that contains SPARAM array of minimum length 5 DPARAM(1)=DFLAG DPARAM(2)=DH11 DPARAM(3)=DH21 DPARAM(4)=DH12 DPARAM(5)=DH22.
offDparam (int [in]) – Offset of first element of array DPARAM in buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSrotm(N, X, offx, incx, Y, offy, incy, SPARAM, offSparam, commandQueues, eventWaitList)¶

wraps: clblasSrotm

modified givens rotation for float elements

Parameters:

N (int [in]) – Number of elements in vector X and Y.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
SPARAM (pyopencl.Buffer [in]) – Buffer object that contains SPARAM array of minimum length 5 SPARAM(1)=SFLAG SPARAM(2)=SH11 SPARAM(3)=SH21 SPARAM(4)=SH12 SPARAM(5)=SH22.
offSparam (int [in]) – Offset of first element of array SPARAM in buffer object. Counted in elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

NRM2 - Euclidean norm of a vector¶

pyclblas.clblasDnrm2(N, NRM2, offNRM2, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDnrm2

computes the euclidean norm of vector containing double elements NRM2 = sqrt( X’ * X )

Parameters:

N (int [in]) – Number of elements in vector X.
NRM2 (pyopencl.Buffer [out]) – Buffer object that will contain the NRM2 value.
offNRM2 (int [in]) – Offset to NRM2 value in NRM2 buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object that can hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSnrm2(N, NRM2, offNRM2, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasSnrm2

computes the euclidean norm of vector containing float elements NRM2 = sqrt( X’ * X )

Parameters:

N (int [in]) – Number of elements in vector X.
NRM2 (pyopencl.Buffer [out]) – Buffer object that will contain the NRM2 value.
offNRM2 (int [in]) – Offset to NRM2 value in NRM2 buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object that can hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasScnrm2(N, NRM2, offNRM2, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasScnrm2

computes the euclidean norm of vector containing float-complex elements NRM2 = sqrt( X**H * X )

Parameters:

N (int [in]) – Number of elements in vector X.
NRM2 (pyopencl.Buffer [out]) – Buffer object that will contain the NRM2 value. Note that the answer of Scnrm2 is a real value.
offNRM2 (int [in]) – Offset to NRM2 value in NRM2 buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object that can hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDznrm2(N, NRM2, offNRM2, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDznrm2

computes the euclidean norm of vector containing double-complex elements NRM2 = sqrt( X**H * X )

Parameters:

N (int [in]) – Number of elements in vector X.
NRM2 (pyopencl.Buffer [out]) – Buffer object that will contain the NRM2 value. Note that the answer of Dznrm2 is a real value.
offNRM2 (int [in]) – Offset to NRM2 value in NRM2 buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object that can hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

iAMAX - Index of max absolute value¶

pyclblas.clblasiSamax(N, iMax, offiMax, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasiSamax

index of max absolute value in a float array

Parameters:

N (int [in]) – Number of elements in vector X.
iMax (pyopencl.Buffer [out]) – Buffer object storing the index of first absolute max. The index will be of type unsigned int.
offiMax (int [in]) – Offset for storing index in the buffer iMax Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temprory cl_mem object to store intermediate results It should be able to hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasiDamax(N, iMax, offiMax, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasiDamax

index of max absolute value in a double array

Parameters:

N (int [in]) – Number of elements in vector X.
iMax (pyopencl.Buffer [out]) – Buffer object storing the index of first absolute max. The index will be of type unsigned int.
offiMax (int [in]) – Offset for storing index in the buffer iMax Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temprory cl_mem object to store intermediate results It should be able to hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasiCamax(N, iMax, offiMax, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasiCamax

index of max absolute value in a complex float array

Parameters:

N (int [in]) – Number of elements in vector X.
iMax (pyopencl.Buffer [out]) – Buffer object storing the index of first absolute max. The index will be of type unsigned int.
offiMax (int [in]) – Offset for storing index in the buffer iMax Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temprory cl_mem object to store intermediate results It should be able to hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasiZamax(N, iMax, offiMax, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasiZamax

index of max absolute value in a complex double array

Parameters:

N (int [in]) – Number of elements in vector X.
iMax (pyopencl.Buffer [out]) – Buffer object storing the index of first absolute max. The index will be of type unsigned int.
offiMax (int [in]) – Offset for storing index in the buffer iMax Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temprory cl_mem object to store intermediate results It should be able to hold minimum of (2*N) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

ASUM - Sum of absolute values¶

pyclblas.clblasDasum(N, asum, offAsum, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDasum

absolute sum of values of a vector containing double elements

Parameters:

N (int [in]) – Number of elements in vector X.
asum (pyopencl.Buffer [out]) – Buffer object that will contain the absoulte sum value.
offAsum (int [in]) – Offset to absoule sum in asum buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSasum(N, asum, offAsum, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasSasum

absolute sum of values of a vector containing float elements

Parameters:

N (int [in]) – Number of elements in vector X.
asum (pyopencl.Buffer [out]) – Buffer object that will contain the absoule sum value.
offAsum (int [in]) – Offset to absolute sum in asum buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasScasum(N, asum, offAsum, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasScasum

absolute sum of values of a vector containing float-complex elements

Parameters:

N (int [in]) – Number of elements in vector X.
asum (pyopencl.Buffer [out]) – Buffer object that will contain the absolute sum value.
offAsum (int [in]) – Offset to absolute sum in asum buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDzasum(N, asum, offAsum, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDzasum

absolute sum of values of a vector containing double-complex elements

Parameters:

N (int [in]) – Number of elements in vector X.
asum (pyopencl.Buffer [out]) – Buffer object that will contain the absolute sum value.
offAsum (int [in]) – Offset to absolute sum in asum buffer object. Counted in elements.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object of minimum size N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

BLAS Level 2 Functions¶

GEMV - General matrix-Vector multiplication¶

pyclblas.clblasCgemv(order, transA, M, N, alpha, A, offA, lda, x, offx, incx, beta, y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasCgemv

Matrix-vector product with a general rectangular matrix and float complex elements. Extended version. Matrix-vector products:

( y ← α A x + β y )
( y ← α A^Tx + β y )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
x (pyopencl.Buffer [in]) – Buffer object storing vector x.
offx (int [in]) – Offset of first element of vector x in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of x. It cannot be zero.
beta (complex [in]) – The factor of the vector y.
y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDgemv(order, transA, M, N, alpha, A, offA, lda, x, offx, incx, beta, y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDgemv

Matrix-vector product with a general rectangular matrix and double elements. Extended version. Matrix-vector products:

( y ← α A x + β y )
( y ← α A^Tx + β y )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
x (pyopencl.Buffer [in]) – Buffer object storing vector x.
offx (int [in]) – Offset of first element of vector x in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of x. It cannot be zero.
beta (float [in]) – The factor of the vector y.
y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSgemv(order, transA, M, N, alpha, A, offA, lda, x, offx, incx, beta, y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSgemv

Matrix-vector product with a general rectangular matrix and float elements. Extended version. Matrix-vector products:

( y ← α A x + β y )
( y ← α A^Tx + β y )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
x (pyopencl.Buffer [in]) – Buffer object storing vector x.
offx (int [in]) – Offset of first element of vector x in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of x. It cannot be zero.
beta (float [in]) – The factor of the vector y.
y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZgemv(order, transA, M, N, alpha, A, offA, lda, x, offx, incx, beta, y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZgemv

Matrix-vector product with a general rectangular matrix and double complex elements. Extended version. Matrix-vector products:

( y ← α A x + β y )
( y ← α A^Tx + β y )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
x (pyopencl.Buffer [in]) – Buffer object storing vector x.
offx (int [in]) – Offset of first element of vector x in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of x. It cannot be zero.
beta (complex [in]) – The factor of the vector y.
y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SYMV - Symmetric matrix-Vector multiplication¶

pyclblas.clblasDsymv(order, uplo, N, alpha, A, offA, lda, x, offx, incx, beta, y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDsymv

Matrix-vector product with a symmetric matrix and double elements. Matrix-vector products:

( y ← α A x + β y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix A.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot less than N.
x (pyopencl.Buffer [in]) – Buffer object storing vector x.
offx (int [in]) – Offset of first element of vector x in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector x. It cannot be zero.
beta (float [in]) – The factor of vector y.
y (pyopencl.Buffer [out]) – Buffer object storing vector y.
offy (int [in]) – Offset of first element of vector y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsymv(order, uplo, N, alpha, A, offA, lda, x, offx, incx, beta, y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSsymv

Matrix-vector product with a symmetric matrix and float elements. Matrix-vector products:

( y ← α A x + β y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix A.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot less than N.
x (pyopencl.Buffer [in]) – Buffer object storing vector x.
offx (int [in]) – Offset of first element of vector x in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector x. It cannot be zero.
beta (float [in]) – The factor of vector y.
y (pyopencl.Buffer [out]) – Buffer object storing vector y.
offy (int [in]) – Offset of first element of vector y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HEMV - Hermitian matrix-vector multiplication¶

pyclblas.clblasChemv(order, uplo, N, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasChemv

Matrix-vector product with a hermitian matrix and float-complex elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot less than N.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (complex [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZhemv(order, uplo, N, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZhemv

Matrix-vector product with a hermitian matrix and double-complex elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot less than N.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (complex [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TRMV - Triangular matrix vector multiply¶

pyclblas.clblasCtrmv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasCtrmv

Matrix-vector product with a triangular matrix and float complex elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtrmv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDtrmv

Matrix-vector product with a triangular matrix and double elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStrmv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasStrmv

Matrix-vector product with a triangular matrix and float elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtrmv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasZtrmv

Matrix-vector product with a triangular matrix and double complex elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TRSV - Triangular matrix vector Solve¶

pyclblas.clblasCtrsv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasCtrsv

solving triangular matrix problems with float-complex elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtrsv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasDtrsv

solving triangular matrix problems with double elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStrsv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasStrsv

solving triangular matrix problems with float elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtrsv(order, uplo, trans, diag, N, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasZtrsv

solving triangular matrix problems with double-complex elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

GER - General matrix rank 1 operation¶

pyclblas.clblasDger(order, M, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasDger

vector-vector product with double elements and performs the rank 1 operation A Vector-vector products:

( A ← α X Y^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – specifies the scalar alpha.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A. On exit, A is overwritten by the updated matrix.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSger(order, M, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasSger

vector-vector product with float elements and performs the rank 1 operation A Vector-vector products:

( A ← α X Y^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – specifies the scalar alpha.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A. On exit, A is overwritten by the updated matrix.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

GERU - General matrix rank 1 operation¶

pyclblas.clblasCgeru(order, M, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasCgeru

vector-vector product with float complex elements and performs the rank 1 operation A Vector-vector products:

( A ← α X Y^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – specifies the scalar alpha.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A. On exit, A is overwritten by the updated matrix.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZgeru(order, M, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasZgeru

vector-vector product with double complex elements and performs the rank 1 operation A Vector-vector products:

( A ← α X Y^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – specifies the scalar alpha.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A. On exit, A is overwritten by the updated matrix.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

GERC - General matrix rank 1 operation¶

pyclblas.clblasCgerc(order, M, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasCgerc

vector-vector product with float complex elements and performs the rank 1 operation A Vector-vector products:

( A ← α X Y^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – specifies the scalar alpha.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A. On exit, A is overwritten by the updated matrix.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZgerc(order, M, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasZgerc

vector-vector product with double complex elements and performs the rank 1 operation A Vector-vector products:

( A ← α X Y^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – specifies the scalar alpha.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A. On exit, A is overwritten by the updated matrix.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SYR - Symmetric rank 1 update¶

pyclblas.clblasDsyr(order, uplo, N, alpha, X, offx, incx, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasDsyr

Symmetric rank 1 operation with a general triangular matrix and double elements. Symmetric rank 1 operation:

( A ← α x x^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset of first element of matrix A in buffer object.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsyr(order, uplo, N, alpha, X, offx, incx, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasSsyr

Symmetric rank 1 operation with a general triangular matrix and float elements. Symmetric rank 1 operation:

( A ← α x x^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset of first element of matrix A in buffer object.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HER - Hermitian rank 1 operation¶

pyclblas.clblasCher(order, uplo, N, alpha, X, offx, incx, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasCher

hermitian rank 1 operation with a general triangular matrix and float-complex elements. hermitian rank 1 operation:

( A ← α X X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A (a scalar float value).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZher(order, uplo, N, alpha, X, offx, incx, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasZher

hermitian rank 1 operation with a general triangular matrix and double-complex elements. hermitian rank 1 operation:

( A ← α X X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A (a scalar double value).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SYR2 - Symmetric rank 2 update¶

pyclblas.clblasDsyr2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasDsyr2

Symmetric rank 2 operation with a general triangular matrix and double elements. Symmetric rank 2 operation:

( A ← α x y^T+ α y x^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset of first element of matrix A in buffer object.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsyr2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasSsyr2

Symmetric rank 2 operation with a general triangular matrix and float elements. Symmetric rank 2 operation:

( A ← α x y^T+ α y x^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset of first element of matrix A in buffer object.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HER2 - Hermitian rank 2 update¶

pyclblas.clblasCher2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasCher2

Hermitian rank 2 operation with a general triangular matrix and float-compelx elements. Hermitian rank 2 operation:

( A ← α X Y^H+ conj{ α } Y X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZher2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, A, offa, lda, commandQueues, eventWaitList)¶

wraps: clblasZher2

Hermitian rank 2 operation with a general triangular matrix and double-compelx elements. Hermitian rank 2 operation:

( A ← α X Y^H+ conj{ α } Y X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
A (pyopencl.Buffer [out]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TPMV - Triangular packed matrix-vector multiply¶

pyclblas.clblasCtpmv(order, uplo, trans, diag, N, AP, offa, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasCtpmv

Matrix-vector product with a packed triangular matrix and float-complex elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix AP is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix AP is unit triangular.
N (int [in]) – Number of rows/columns in matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing matrix AP in packed format.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtpmv(order, uplo, trans, diag, N, AP, offa, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDtpmv

Matrix-vector product with a packed triangular matrix and double elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix AP is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix AP is unit triangular.
N (int [in]) – Number of rows/columns in matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing matrix AP in packed format.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStpmv(order, uplo, trans, diag, N, AP, offa, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasStpmv

Matrix-vector product with a packed triangular matrix and float elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix AP is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix AP is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
AP (pyopencl.Buffer [in]) – Buffer object storing matrix AP in packed format.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtpmv(order, uplo, trans, diag, N, AP, offa, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasZtpmv

Matrix-vector product with a packed triangular matrix and double-complex elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix AP is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix AP is unit triangular.
N (int [in]) – Number of rows/columns in matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing matrix AP in packed format.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TPSV - Triangular packed matrix vector solve¶

pyclblas.clblasCtpsv(order, uplo, trans, diag, N, A, offa, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasCtpsv

solving triangular packed matrix problems with float complex elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix in packed format. A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtpsv(order, uplo, trans, diag, N, A, offa, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasDtpsv

solving triangular packed matrix problems with double elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix in packed format. A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStpsv(order, uplo, trans, diag, N, A, offa, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasStpsv

solving triangular packed matrix problems with float elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix in packed format. A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtpsv(order, uplo, trans, diag, N, A, offa, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasZtpsv

solving triangular packed matrix problems with double complex elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix in packed format. A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SPMV - Symmetric packed matrix vector multiply¶

pyclblas.clblasDspmv(order, uplo, N, alpha, AP, offa, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDspmv

Matrix-vector product with a symmetric packed-matrix and double elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix AP.
alpha (float [in]) – The factor of matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing matrix AP.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (float [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSspmv(order, uplo, N, alpha, AP, offa, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSspmv

Matrix-vector product with a symmetric packed-matrix and float elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix AP.
alpha (float [in]) – The factor of matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing matrix AP.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (float [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HPMV - Hermitian packed matrix-vector multiplication¶

pyclblas.clblasChpmv(order, uplo, N, alpha, AP, offa, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasChpmv

Matrix-vector product with a packed hermitian matrix and float-complex elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix AP.
alpha (complex [in]) – The factor of matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing packed matrix AP.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (complex [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZhpmv(order, uplo, N, alpha, AP, offa, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZhpmv

Matrix-vector product with a packed hermitian matrix and double-complex elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in matrix AP.
alpha (complex [in]) – The factor of matrix AP.
AP (pyopencl.Buffer [in]) – Buffer object storing packed matrix AP.
offa (int [in]) – Offset in number of elements for first element in matrix AP.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (complex [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SPR - Symmetric packed matrix rank 1 update¶

pyclblas.clblasDspr(order, uplo, N, alpha, X, offx, incx, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasDspr

Symmetric rank 1 operation with a general triangular packed-matrix and double elements. Symmetric rank 1 operation:

( A ← α X X^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing packed-matrix AP.
offa (int [in]) – Offset of first element of matrix AP in buffer object.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSspr(order, uplo, N, alpha, X, offx, incx, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasSspr

Symmetric rank 1 operation with a general triangular packed-matrix and float elements. Symmetric rank 1 operation:

( A ← α X X^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing packed-matrix AP.
offa (int [in]) – Offset of first element of matrix AP in buffer object.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HPR - Hermitian packed matrix rank 1 update¶

pyclblas.clblasChpr(order, uplo, N, alpha, X, offx, incx, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasChpr

hermitian rank 1 operation with a general triangular packed-matrix and float-complex elements. hermitian rank 1 operation:

( A ← α X X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A (a scalar float value).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing matrix AP.
offa (int [in]) – Offset in number of elements for the first element in matrix AP.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZhpr(order, uplo, N, alpha, X, offx, incx, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasZhpr

hermitian rank 1 operation with a general triangular packed-matrix and double-complex elements. hermitian rank 1 operation:

( A ← α X X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A (a scalar float value).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing matrix AP.
offa (int [in]) – Offset in number of elements for the first element in matrix AP.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SPR2 - Symmetric packed matrix rank 2 update¶

pyclblas.clblasDspr2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasDspr2

Symmetric rank 2 operation with a general triangular packed-matrix and double elements. Symmetric rank 2 operation:

( A ← α X Y^T+ α Y X^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing packed-matrix AP.
offa (int [in]) – Offset of first element of matrix AP in buffer object.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSspr2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasSspr2

Symmetric rank 2 operation with a general triangular packed-matrix and float elements. Symmetric rank 2 operation:

( A ← α X Y^T+ α Y X^T+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (float [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing packed-matrix AP.
offa (int [in]) – Offset of first element of matrix AP in buffer object.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HPR2 - Hermitian packed matrix rank 2 update¶

pyclblas.clblasChpr2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasChpr2

Hermitian rank 2 operation with a general triangular packed-matrix and float-compelx elements. Hermitian rank 2 operation:

( A ← α X Y^H+ conj( alpha ) Y X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing packed-matrix AP.
offa (int [in]) – Offset in number of elements for the first element in matrix AP.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZhpr2(order, uplo, N, alpha, X, offx, incx, Y, offy, incy, AP, offa, commandQueues, eventWaitList)¶

wraps: clblasZhpr2

Hermitian rank 2 operation with a general triangular packed-matrix and double-compelx elements. Hermitian rank 2 operation:

( A ← α X Y^H+ conj( alpha ) Y X^H+ A )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of columns in matrix A.
alpha (complex [in]) – The factor of matrix A.
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for the first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
Y (pyopencl.Buffer [in]) – Buffer object storing vector Y.
offy (int [in]) – Offset in number of elements for the first element in vector Y.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
AP (pyopencl.Buffer [out]) – Buffer object storing packed-matrix AP.
offa (int [in]) – Offset in number of elements for the first element in matrix AP.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

GBMV - General banded matrix-vector multiplication¶

pyclblas.clblasCgbmv(order, trans, M, N, KL, KU, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasCgbmv

Matrix-vector product with a general rectangular banded matrix and float-complex elements. Matrix-vector products:

( Y ← α A X + β Y )
( Y ← α A^TX + β Y )

Parameters:

order (clblasOrder [in]) – Row/column order.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in banded matrix A.
N (int [in]) – Number of columns in banded matrix A.
KL (int [in]) – Number of sub-diagonals in banded matrix A.
KU (int [in]) – Number of super-diagonals in banded matrix A.
alpha (complex [in]) – The factor of banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing banded matrix A.
offa (int [in]) – Offset in number of elements for the first element in banded matrix A.
lda (int [in]) – Leading dimension of banded matrix A. It cannot be less than ( KL + KU + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
beta (complex [in]) – The factor of the vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDgbmv(order, trans, M, N, KL, KU, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDgbmv

Matrix-vector product with a general rectangular banded matrix and double elements. Matrix-vector products:

( Y ← α A X + β Y )
( Y ← α A^TX + β Y )

Parameters:

order (clblasOrder [in]) – Row/column order.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in banded matrix A.
N (int [in]) – Number of columns in banded matrix A.
KL (int [in]) – Number of sub-diagonals in banded matrix A.
KU (int [in]) – Number of super-diagonals in banded matrix A.
alpha (float [in]) – The factor of banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing banded matrix A.
offa (int [in]) – Offset in number of elements for the first element in banded matrix A.
lda (int [in]) – Leading dimension of banded matrix A. It cannot be less than ( KL + KU + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
beta (float [in]) – The factor of the vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSgbmv(order, trans, M, N, KL, KU, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSgbmv

Matrix-vector product with a general rectangular banded matrix and float elements. Matrix-vector products:

( Y ← α A X + β Y )
( Y ← α A^TX + β Y )

Parameters:

order (clblasOrder [in]) – Row/column order.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in banded matrix A.
N (int [in]) – Number of columns in banded matrix A.
KL (int [in]) – Number of sub-diagonals in banded matrix A.
KU (int [in]) – Number of super-diagonals in banded matrix A.
alpha (float [in]) – The factor of banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing banded matrix A.
offa (int [in]) – Offset in number of elements for the first element in banded matrix A.
lda (int [in]) – Leading dimension of banded matrix A. It cannot be less than ( KL + KU + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
beta (float [in]) – The factor of the vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZgbmv(order, trans, M, N, KL, KU, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZgbmv

Matrix-vector product with a general rectangular banded matrix and double-complex elements. Matrix-vector products:

( Y ← α A X + β Y )
( Y ← α A^TX + β Y )

Parameters:

order (clblasOrder [in]) – Row/column order.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
M (int [in]) – Number of rows in banded matrix A.
N (int [in]) – Number of columns in banded matrix A.
KL (int [in]) – Number of sub-diagonals in banded matrix A.
KU (int [in]) – Number of super-diagonals in banded matrix A.
alpha (complex [in]) – The factor of banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing banded matrix A.
offa (int [in]) – Offset in number of elements for the first element in banded matrix A.
lda (int [in]) – Leading dimension of banded matrix A. It cannot be less than ( KL + KU + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of X. Must not be zero.
beta (complex [in]) – The factor of the vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing the vector y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of Y. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TBMV - Triangular banded matrix vector multiply¶

pyclblas.clblasCtbmv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasCtbmv

Matrix-vector product with a triangular banded matrix and float-complex elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtbmv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasDtbmv

Matrix-vector product with a triangular banded matrix and double elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStbmv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasStbmv

Matrix-vector product with a triangular banded matrix and float elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtbmv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, scratchBuff, commandQueues, eventWaitList)¶

wraps: clblasZtbmv

Matrix-vector product with a triangular banded matrix and double-complex elements. Matrix-vector products:

( X ← A X )
( X ← A^TX )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
scratchBuff (pyopencl.Buffer [in]) – Temporary cl_mem scratch buffer object which can hold a minimum of (1 + (N-1)*abs(incx)) elements.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SBMV - Symmetric banded matrix-vector multiplication¶

pyclblas.clblasDsbmv(order, uplo, N, K, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasDsbmv

Matrix-vector product with a symmetric banded matrix and double elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in banded matrix A.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (float [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsbmv(order, uplo, N, K, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasSsbmv

Matrix-vector product with a symmetric banded matrix and float elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in banded matrix A.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (float [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HBMV - Hermitian banded matrix-vector multiplication¶

pyclblas.clblasChbmv(order, uplo, N, K, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasChbmv

Matrix-vector product with a hermitian banded matrix and float elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in banded matrix A.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (complex [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZhbmv(order, uplo, N, K, alpha, A, offa, lda, X, offx, incx, beta, Y, offy, incy, commandQueues, eventWaitList)¶

wraps: clblasZhbmv

Matrix-vector product with a hermitian banded matrix and double elements. Matrix-vector products:

( Y ← α A X + β Y )

Parameters:

order (clblasOrder [in]) – Row/columns order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
N (int [in]) – Number of rows and columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in banded matrix A.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [in]) – Buffer object storing vector X.
offx (int [in]) – Offset of first element of vector X in buffer object. Counted in elements.
incx (int [in]) – Increment for the elements of vector X. It cannot be zero.
beta (complex [in]) – The factor of vector Y.
Y (pyopencl.Buffer [out]) – Buffer object storing vector Y.
offy (int [in]) – Offset of first element of vector Y in buffer object. Counted in elements.
incy (int [in]) – Increment for the elements of vector Y. It cannot be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TBSV - Solving triangular banded matrix¶

pyclblas.clblasCtbsv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasCtbsv

solving triangular banded matrix problems with float-complex elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtbsv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasDtbsv

solving triangular banded matrix problems with double elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStbsv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasStbsv

solving triangular banded matrix problems with float elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtbsv(order, uplo, trans, diag, N, K, A, offa, lda, X, offx, incx, commandQueues, eventWaitList)¶

wraps: clblasZtbsv

solving triangular banded matrix problems with double-complex elements. Matrix-vector products:

( A X ← X )
( A^TX ← X )

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix A is unit triangular.
N (int [in]) – Number of rows/columns in banded matrix A.
K (int [in]) – Number of sub-diagonals/super-diagonals in triangular banded matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset in number of elements for first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than ( K + 1 ).
X (pyopencl.Buffer [out]) – Buffer object storing vector X.
offx (int [in]) – Offset in number of elements for first element in vector X.
incx (int [in]) – Increment for the elements of X. Must not be zero.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

BLAS Level 3 Functions¶

GEMM - General matrix-matrix multiplication¶

pyclblas.clblasCgemm(order, transA, transB, M, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasCgemm

Matrix-matrix product of general rectangular matrices with float complex elements. Extended version. <dl class=”section note”> <dt> Note </dt> <dd> This function is not thread-safe. </dd> </dl> Matrix-matrix products:

( C ← α A B + β C )
( C ← α A^TB + β C )
( C ← α A B^T+ β C )
( C ← α A^TB^T+ β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
transB (clblasTranspose [in]) – How matrix B is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix B.
K (int [in]) – Number of columns in matrix A and rows in matrix B.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDgemm(order, transA, transB, M, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasDgemm

Matrix-matrix product of general rectangular matrices with double elements. Extended version. <dl class=”section note”> <dt> Note </dt> <dd> This function is not thread-safe. </dd> </dl> Matrix-matrix products:

( C ← α A B + β C )
( C ← α A^TB + β C )
( C ← α A B^T+ β C )
( C ← α A^TB^T+ β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
transB (clblasTranspose [in]) – How matrix B is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix B.
K (int [in]) – Number of columns in matrix A and rows in matrix B.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
beta (float [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSgemm(order, transA, transB, M, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasSgemm

Matrix-matrix product of general rectangular matrices with float elements. Extended version. <dl class=”section note”> <dt> Note </dt> <dd> This function is not thread-safe. </dd> </dl> Matrix-matrix products:

( C ← α A B + β C )
( C ← α A^TB + β C )
( C ← α A B^T+ β C )
( C ← α A^TB^T+ β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
transB (clblasTranspose [in]) – How matrix B is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix B.
K (int [in]) – Number of columns in matrix A and rows in matrix B.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K when the order parameter is set to clblasRowMajor, or less than M when the parameter is set to clblasColumnMajor.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than K when it is set to clblasColumnMajor.
beta (float [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZgemm(order, transA, transB, M, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasZgemm

Matrix-matrix product of general rectangular matrices with double complex elements. Exteneded version. <dl class=”section note”> <dt> Note </dt> <dd> This function is not thread-safe. </dd> </dl> Matrix-matrix products:

( C ← α A B + β C )
( C ← α A^TB + β C )
( C ← α A B^T+ β C )
( C ← α A^TB^T+ β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
transB (clblasTranspose [in]) – How matrix B is to be transposed.
M (int [in]) – Number of rows in matrix A.
N (int [in]) – Number of columns in matrix B.
K (int [in]) – Number of columns in matrix A and rows in matrix B.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TRMM - Triangular matrix-matrix multiplication¶

pyclblas.clblasCtrmm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasCtrmm

Multiplying a matrix by a triangular matrix with float complex elements. Extended version. Matrix-triangular matrix products:

( B ← α A B )
( B ← α A^TB )
( B ← α B A )
( B ← α B A^T)

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtrmm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasDtrmm

Multiplying a matrix by a triangular matrix with double elements. Extended version. Matrix-triangular matrix products:

( B ← α A B )
( B ← α A^TB )
( B ← α B A )
( B ← α B A^T)

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStrmm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasStrmm

Multiplying a matrix by a triangular matrix with float elements. Extended version. Matrix-triangular matrix products:

( B ← α A B )
( B ← α A^TB )
( B ← α B A )
( B ← α B A^T)

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when it is set to clblasRight.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or not less than M when it is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtrmm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasZtrmm

Multiplying a matrix by a triangular matrix with double complex elements. Extended version. Matrix-triangular matrix products:

( B ← α A B )
( B ← α A^TB )
( B ← α B A )
( B ← α B A^T)

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

TRSM - Solving triangular systems of equations¶

pyclblas.clblasCtrsm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasCtrsm

Solving triangular systems of equations with multiple right-hand sides and float complex elements. Extended version. Solving triangular systems of equations:

( B ← α A^-1B )
( B ← α A^{-T} B )
( B ← α B A^-1)
( B ← α B A^{-T} )

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDtrsm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasDtrsm

Solving triangular systems of equations with multiple right-hand sides and double elements. Extended version. <dl class=”section note”> <dt> Note </dt> <dd> This function is not thread-safe. </dd> </dl> Solving triangular systems of equations:

( B ← α A^-1B )
( B ← α A^{-T} B )
( B ← α B A^-1)
( B ← α B A^{-T} )

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasStrsm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasStrsm

Solving triangular systems of equations with multiple right-hand sides and float elements. Extended version. <dl class=”section note”> <dt> Note </dt> <dd> This function is not thread-safe. </dd> </dl> Solving triangular systems of equations:

( B ← α A^-1B )
( B ← α A^{-T} B )
( B ← α B A^-1)
( B ← α B A^{-T} )

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when it is set to clblasRight.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZtrsm(order, side, uplo, transA, diag, M, N, alpha, A, offA, lda, B, offB, ldb, commandQueues, eventWaitList)¶

wraps: clblasZtrsm

Solving triangular systems of equations with multiple right-hand sides and double complex elements. Extended version. Solving triangular systems of equations:

( B ← α A^-1B )
( B ← α A^{-T} B )
( B ← α B A^-1)
( B ← α B A^{-T} )

where T is an upper or lower triangular matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
diag (clblasDiag [in]) – Specify whether matrix is unit triangular.
M (int [in]) – Number of rows in matrix B.
N (int [in]) – Number of columns in matrix B.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [out]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SYRK - Symmetric rank-k update of a matrix¶

pyclblas.clblasCsyrk(order, uplo, transA, N, K, alpha, A, offA, lda, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasCsyrk

Rank-k update of a symmetric matrix with complex float elements. Extended version. Rank-k updates:

( C ← α A A^T+ β C )
( C ← α A^TA + β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
beta (complex [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDsyrk(order, uplo, transA, N, K, alpha, A, offA, lda, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasDsyrk

Rank-k update of a symmetric matrix with double elements. Extended version. Rank-k updates:

( C ← α A A^T+ β C )
( C ← α A^TA + β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
beta (float [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsyrk(order, uplo, transA, N, K, alpha, A, offA, lda, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasSsyrk

Rank-k update of a symmetric matrix with float elements. Extended version. Rank-k updates:

( C ← α A A^T+ β C )
( C ← α A^TA + β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K if A is in the row-major format, and less than N otherwise.
beta (float [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matric C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZsyrk(order, uplo, transA, N, K, alpha, A, offA, lda, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasZsyrk

Rank-k update of a symmetric matrix with complex double elements. Extended version. Rank-k updates:

( C ← α A A^T+ β C )
( C ← α A^TA + β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
beta (complex [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SYR2K - Symmetric rank-2k update to a matrix¶

pyclblas.clblasCsyr2k(order, uplo, transAB, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasCsyr2k

Rank-2k update of a symmetric matrix with complex float elements. Extended version. Rank-k updates:

( C ← α A B^T+ α B A^T+ β C )
( C ← α A^TB + α B^TA β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transAB (clblasTranspose [in]) – How matrices A and B is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrices A and B if they are not transposed, and number of rows otherwise.
alpha (complex [in]) – The factor of matrices A and B.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDsyr2k(order, uplo, transAB, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasDsyr2k

Rank-2k update of a symmetric matrix with double elements. Extended version. Rank-k updates:

( C ← α A B^T+ α B A^T+ β C )
( C ← α A^TB + α B^TA β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transAB (clblasTranspose [in]) – How matrices A and B is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrices A and B if they are not transposed, and number of rows otherwise.
alpha (float [in]) – The factor of matrices A and B.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
beta (float [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsyr2k(order, uplo, transAB, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasSsyr2k

Rank-2k update of a symmetric matrix with float elements. Extended version. Rank-k updates:

( C ← α A B^T+ α B A^T+ β C )
( C ← α A^TB + α B^TA β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transAB (clblasTranspose [in]) – How matrices A and B is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrices A and B if they are not transposed, and number of rows otherwise.
alpha (float [in]) – The factor of matrices A and B.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K if A is in the row-major format, and less than N otherwise.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less less than K if B matches to the op( B ) matrix in the row-major format, and less than N otherwise.
beta (float [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZsyr2k(order, uplo, transAB, N, K, alpha, A, offA, lda, B, offB, ldb, beta, C, offC, ldc, commandQueues, eventWaitList)¶

wraps: clblasZsyr2k

Rank-2k update of a symmetric matrix with complex double elements. Extended version. Rank-k updates:

( C ← α A B^T+ α B A^T+ β C )
( C ← α A^TB + α B^TA β C )

where C is a symmetric matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transAB (clblasTranspose [in]) – How matrices A and B is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrices A and B if they are not transposed, and number of rows otherwise.
alpha (complex [in]) – The factor of matrices A and B.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offA (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offB (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offC (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

SYMM - Symmetric matrix-matrix multiply¶

pyclblas.clblasCsymm(order, side, uplo, M, N, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasCsymm

Matrix-matrix product of symmetric rectangular matrices with float-complex elements. Matrix-matrix products:

( C ← α A B + β C )
( C ← α B A + β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
M (int [in]) – Number of rows in matrices B and C.
N (int [in]) – Number of columns in matrices B and C.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when the parameter is set to clblasRight.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offb (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasDsymm(order, side, uplo, M, N, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasDsymm

Matrix-matrix product of symmetric rectangular matrices with double elements. Matrix-matrix products:

( C ← α A B + β C )
( C ← α B A + β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
M (int [in]) – Number of rows in matrices B and C.
N (int [in]) – Number of columns in matrices B and C.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when the parameter is set to clblasRight.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offb (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
beta (float [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasSsymm(order, side, uplo, M, N, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasSsymm

Matrix-matrix product of symmetric rectangular matrices with float elements. Matrix-matrix products:

( C ← α A B + β C )
( C ← α B A + β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
M (int [in]) – Number of rows in matrices B and C.
N (int [in]) – Number of columns in matrices B and C.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when the parameter is set to clblasRight.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offb (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
beta (float [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZsymm(order, side, uplo, M, N, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasZsymm

Matrix-matrix product of symmetric rectangular matrices with double-complex elements. Matrix-matrix products:

( C ← α A B + β C )
( C ← α B A + β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
M (int [in]) – Number of rows in matrices B and C.
N (int [in]) – Number of columns in matrices B and C.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when the parameter is set to clblasRight.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offb (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HEMM - Hermitian matrix-matrix multiplication¶

pyclblas.clblasChemm(order, side, uplo, M, N, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasChemm

Matrix-matrix product of hermitian rectangular matrices with float-complex elements. Matrix-matrix products:

( C ← α A B + β C )
( C ← α B A + β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
M (int [in]) – Number of rows in matrices B and C.
N (int [in]) – Number of columns in matrices B and C.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when the parameter is set to clblasRight.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offb (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZhemm(order, side, uplo, M, N, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasZhemm

Matrix-matrix product of hermitian rectangular matrices with double-complex elements. Matrix-matrix products:

( C ← α A B + β C )
( C ← α B A + β C )

Parameters:

order (clblasOrder [in]) – Row/column order.
side (clblasSide [in]) – The side of triangular matrix.
uplo (clblasUplo [in]) – The triangle in matrix being referenced.
M (int [in]) – Number of rows in matrices B and C.
N (int [in]) – Number of columns in matrices B and C.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing matrix A.
offa (int [in]) – Offset of the first element of the matrix A in the buffer object. Counted in elements.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than M when the side parameter is set to clblasLeft, or less than N when the parameter is set to clblasRight.
B (pyopencl.Buffer [in]) – Buffer object storing matrix B.
offb (int [in]) – Offset of the first element of the matrix B in the buffer object. Counted in elements.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajor.
beta (complex [in]) – The factor of matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset of the first element of the matrix C in the buffer object. Counted in elements.
ldc (int [in]) – Leading dimension of matrix C. It cannot be less than N when the order parameter is set to clblasRowMajor, or less than M when it is set to clblasColumnMajorOrder.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HERK - Hermitian rank-k update to a matrix¶

pyclblas.clblasCherk(order, uplo, transA, N, K, alpha, A, offa, lda, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasCherk

Rank-k update of a hermitian matrix with float-complex elements. Rank-k updates:

( C ← α A A^H+ β C )
( C ← α A^HA + β C )

where C is a hermitian matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K if A is in the row-major format, and less than N otherwise.
beta (float [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset in number of elements for the first element in matrix C.
ldc (int [in]) – Leading dimension of matric C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZherk(order, uplo, transA, N, K, alpha, A, offa, lda, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasZherk

Rank-k update of a hermitian matrix with double-complex elements. Rank-k updates:

( C ← α A A^H+ β C )
( C ← α A^HA + β C )

where C is a hermitian matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
transA (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (float [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K if A is in the row-major format, and less than N otherwise.
beta (float [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset in number of elements for the first element in matrix C.
ldc (int [in]) – Leading dimension of matric C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

HER2K - Hermitian rank-2k update to a matrix¶

pyclblas.clblasCher2k(order, uplo, trans, N, K, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasCher2k

Rank-2k update of a hermitian matrix with float-complex elements. Rank-k updates:

( C ← α A B^H+ conj( α ) B A^H+ β C )
( C ← α A^HB + conj( α ) B^HA + β C )

where C is a hermitian matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K if A is in the row-major format, and less than N otherwise. Vice-versa for transpose case.
B (pyopencl.Buffer [in]) – Buffer object storing the matrix B.
offb (int [in]) – Offset in number of elements for the first element in matrix B.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than K if B is in the row-major format, and less than N otherwise. Vice-versa for transpose case.
beta (float [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset in number of elements for the first element in matrix C.
ldc (int [in]) – Leading dimension of matric C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.

pyclblas.clblasZher2k(order, uplo, trans, N, K, alpha, A, offa, lda, B, offb, ldb, beta, C, offc, ldc, commandQueues, eventWaitList)¶

wraps: clblasZher2k

Rank-2k update of a hermitian matrix with double-complex elements. Rank-k updates:

( C ← α A B^H+ conj( α ) B A^H+ β C )
( C ← α A^HB + conj( α ) B^HA + β C )

where C is a hermitian matrix.

Parameters:

order (clblasOrder [in]) – Row/column order.
uplo (clblasUplo [in]) – The triangle in matrix C being referenced.
trans (clblasTranspose [in]) – How matrix A is to be transposed.
N (int [in]) – Number of rows and columns in matrix C.
K (int [in]) – Number of columns of the matrix A if it is not transposed, and number of rows otherwise.
alpha (complex [in]) – The factor of matrix A.
A (pyopencl.Buffer [in]) – Buffer object storing the matrix A.
offa (int [in]) – Offset in number of elements for the first element in matrix A.
lda (int [in]) – Leading dimension of matrix A. It cannot be less than K if A is in the row-major format, and less than N otherwise. Vice-versa for transpose case.
B (pyopencl.Buffer [in]) – Buffer object storing the matrix B.
offb (int [in]) – Offset in number of elements for the first element in matrix B.
ldb (int [in]) – Leading dimension of matrix B. It cannot be less than K if B is in the row-major format, and less than N otherwise. Vice-versa for transpose case.
beta (float [in]) – The factor of the matrix C.
C (pyopencl.Buffer [out]) – Buffer object storing matrix C.
offc (int [in]) – Offset in number of elements for the first element in matrix C.
ldc (int [in]) – Leading dimension of matric C. It cannot be less than N.
commandQueues (pyopencl.CommandQueue [in]) – OpenCL command queues. A list, tuple, or single instance of pyopencl.CommandQueue. Must not be None.
eventWaitList (pyopencl.Event [in]) – Event wait list. A list, tuple, or single instance of pyopencl.Event. May be None.

Returns:

A tuple of pyopencl.Event instances, one for each commandQueue supplied.