# Matrix

## Base Matrix

### hl_matrix.h

Functions

void `hl_matrix_add`(real *A_d, real *B_d, real *C_d, int dimM, int dimN, real alpha, real beta)

  Matrix addition: C_d[i] = alpha * A_d[i] + beta * B_d[i].

  Parameters
    - `A_d`: input matrix (M x N).
    - `B_d`: input matrix (M x N).
    - `C_d`: output matrix (M x N).
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `alpha`: scalar used for addition.
    - `beta`: scalar used for addition.

void `hl_matrix_softmax`(real *A_d, real *C_d, int dimM, int dimN)

  Matrix Softmax.

  Parameters
    - `A_d`: input maxtrix (M x N).
    - `C_d`: output matrix (M x N).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_softmax_derivative`(real *grad_d, real *output_d, real *sftmaxSum_d, int dimM, int dimN)

  Matrix softmax derivative.

  Parameters
    - `grad_d`: intput matrix (M x N).
    - `output_d`: output matrix (M x N).
    - `sftmaxSum_d`: softmax sum (M * 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_sequence_softmax_forward`(real *A_d, real *C_d, const int *index, int numSequence)

  Sequence softmax.

  Parameters
    - `A_d`: input vector.
    - `C_d`: output vector.
    - `index`: start positions of sequence.
    - `numSequence`: sequence number.

void `hl_matrix_classification_error`(real *A_d, int *B_d, real *C_d, int dimM, int dimN)

  Matrix classification error.

  Parameters
    - `A_d`: input matrix (M x N).
    - `B_d`: input vector (M x 1).
    - `C_d`: output vector (M x 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_cross_entropy`(real *A_d, real *C_d, int *label_d, int dimM, int dimN)

  Matrix cross entropy.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output matrix (M X 1).
    - `label_d`: input matrix (M x 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_cross_entropy_bp`(real *grad_d, real *output_d, int *label_d, int dimM, int dimN)

  Matrix cross entropy back propagation.

  Parameters
    - `grad_d`: output matrix (M x N).
    - `output_d`: input matrix (M x N).
    - `label_d`: input vector (M x 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_multi_binary_cross_entropy`(real *output, real *entropy, hl_sparse_matrix_s mat, int dimM, int dimN)

  Matrix multi-binary label cross entropy.

  Parameters
    - `output`: input matrix (M x N).
    - `entropy`: output matrix (M x 1).
    - `mat`: input sparse matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_multi_binary_cross_entropy_bp`(real *output, real *grad, hl_sparse_matrix_s mat, int dimM, int dimN)

  Matrix multi-binary label cross entropy backprop.

  Parameters
    - `output`: input matrix (M x N).
    - `grad`: output matrix (M x N).
    - `mat`: input sparse matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_zero_mem`(real *data, int num)

  Matrix zero memory.

  Parameters
    - `data`: input data.
    - `num`: length of data.

void `hl_param_relu_forward`(real *output, real *input, real *w, int width, int height, int partial_sum)

  parameter relu forward

  Parameters
    - `output`: output data
    - `input`: input data
    - `w`: parameter data
    - `width`: matrix width
    - `height`: matrix height
    - `partial_sum`:

void `hl_param_relu_backward_w`(real *grad_w, real *grad_o, real *input, int width, int height, int partial_sum)

  parameter relu backward w

  Parameters
    - `grad_w`: w grad
    - `grad_o`: output grad
    - `input`: input data
    - `width`: matrix width
    - `height`: matrix height
    - `partial_sum`:

void `hl_param_relu_backward_diff`(real *grad_o, real *input, real *w, real *diff, int width, int height, int partial_sum)

  parameter relu backward diff

  Parameters
    - `grad_o`: output grad
    - `input`: input data
    - `w`: parameter
    - `diff`: diff
    - `width`: matrix width
    - `height`: matrix height
    - `partial_sum`:

void `hl_cossim`(real *output, real *input1, real *input2, int width, int input1_height, int input2_height, real scale)

  cos sim forward

  Parameters
    - `output`: output data
    - `input1`: input1 data(matrix)
    - `input2`: input2 data(matrix or vector)
    - `width`: matrix width
    - `input1_height`: input1_height
    - `input2_height`: input2_height
    - `scale`: scale factor

void `hl_cossim_derivative`(real *grad, real *output, real *prevOutX, real *prevOutY, real *prevGradX, real *prevGradY, int width, int input1_height, int input2_height, real scale)

  cos sim derivate

  Parameters
    - `grad`: output grad
    - `output`: output data
    - `prevOutX`: input1 data
    - `prevOutY`: input2 data
    - `prevGradX`: input1 grad
    - `prevGradY`: input2 grad
    - `width`: matrix width
    - `input1_height`: input1 height
    - `input2_height`: input2 height
    - `scale`: scale factor

void `hl_matrix_add_shared_bias`(real *A_d, real *B_d, const int channel, const int dimM, const int dimN, real scale)

  Matrix addition: A_d[i][j] += scale * B_d[j/channel].

  Parameters
    - `A_d`: input matrix (M x N).
    - `B_d`: input matrix (1 x channel).
    - `channel`: width of B.
    - `dimM`: height of A.
    - `dimN`: width of A.
    - `scale`: scalar used for addition.

void `hl_matrix_collect_shared_bias`(real *B_d, real *A_d, const int channel, const int dimM, const int dimN, real scale)

  Matrix addition: A_d[i][j] += scale * B_d[j/channel].

  Parameters
    - `B_d`: input matrix (1 x channel).
    - `A_d`: input matrix (M x N).
    - `channel`: width of B.
    - `dimM`: height of A.
    - `dimN`: width of A.
    - `scale`: scalar used for addition.

### hl_matrix_base.h

Defines

`HL_MATRIX_BASE_CUH_`

`INLINE`

  CPP inline function

`DEVICE_FMAX`

`DEVICE_FMIN`

class `BaseOp`

  Public Functions

  `BaseOp`()
  `BaseOp`(const real s1)
  `BaseOp`(const real s1, const real s2)
  `INLINE vecType BaseOp::vecOp(const vecType a) const`
  `INLINE vecType BaseOp::vecOp(const vecType a, const vecType b) const`

  Public Static Attributes

  const bool `sse`

namespace `aggregate`
  class `sum`

    Inherits from aggregate::SSESum

    Public Functions

    `INLINE real aggregate::sum::init()`
    `INLINE real aggregate::sum::operator()(const real a, const real b) const`
  class `max`

    Inherits from aggregate::SSEMax

    Public Functions

    `INLINE real aggregate::max::init()`
    `INLINE real aggregate::max::operator()(const real a, const real b) const`
  class `min`

    Inherits from aggregate::SSEMin

    Public Functions

    `INLINE real aggregate::min::init()`
    `INLINE real aggregate::min::operator()(const real a, const real b) const`

namespace `base`
  namespace `binary`
    class `add`

      Inherits from base::binary::SSEAdd

      Public Functions

      `INLINE real base::binary::add::operator()(const real a, const real b) const`
    class `add2`

      Inherits from base::binary::SSEAdd2

      Public Functions

      `add2`(const real s1, const real s2)
      `INLINE real base::binary::add2::operator()(const real a, const real b) const`

      Private Members

      const real `p1`
      const real `p2`
    class `sub`

      Inherits from base::binary::SSESub

      Public Functions

      `INLINE real base::binary::sub::operator()(const real a, const real b) const`
    class `mul`

      Inherits from base::binary::SSEMul

      Public Functions

      `INLINE real base::binary::mul::operator()(const real a, const real b) const`
    class `div`

      Inherits from base::binary::SSEDiv

      Public Functions

      `INLINE real base::binary::div::operator()(const real a, const real b) const`
    class `squaredDiff`

      Inherits from base::binary::SSESquaredDiff

      Public Functions

      `INLINE real base::binary::squaredDiff::operator()(const real a, const real b) const`
    class `first`

      Inherits from base::binary::SSEFirst

      Public Functions

      `INLINE real base::binary::first::operator()(const real a, const real b) const`
    class `second`

      Inherits from base::binary::SSESecond

      Public Functions

      `INLINE real base::binary::second::operator()(const real a, const real b) const`
    class `classificationError`

      Inherits from base::binary::SSEClassificationError

      Public Functions

      `classificationError`(const real s)
      `INLINE real base::binary::classificationError::operator()(const real a, const real b) const`

      Private Members

      const real `p`
  namespace `unary`
    class `identity`

      Inherits from base::unary::SSEIdentity

      Public Functions

      `INLINE real base::unary::identity::operator()(const real a) const`

### hl_matrix_apply.cuh

Defines

`HL_MATRIX_APPLY_H_`

Functions

template <class T, class Op>
void `hl_cpu_apply_unary_op`(Op op, T *A_h, int dimM, int dimN, int lda)

  CPU element wise unary operator.

  element wise op(a) for 0 <= i < dimM & for 0 <= j < dimN.

  CPU element wise unary operator.

  Parameters
    - `op`: unary op. see namespace unary
    - `A_h`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.

template <class T, class Op, bool BAsRowVector, bool BAsColVector>
void `hl_cpu_apply_binary_op`(Op op, T *A_h, T *B_h, int dimM, int dimN, int lda, int ldb)

  CPU element wise binary operator.

  element wise op(a, b) for 0 <= i < dimM & for 0 <= j < dimN.

  if (BAsRowVector == 0 && BAsColVector == 0) op(A[i * lda + j], B[i * ldb + j])

  if (BAsRowVector == 1 && BAsColVector == 0) op(A[i * lda + j], B[j])

  if (BAsRowVector == 0 && BAsColVector == 1) op(A[i * lda + j], B[i * ldb])

  if (BAsRowVector == 1 && BAsColVector == 1) op(A[i * lda + j], B[0])

  CPU element wise binary operator.

  Parameters
    - `op`: binary op. see namespace binary.
    - `A_h`: matrix.
    - `B_h`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.
    - `ldb`: leading dimension of B.

template <class T, class Op, bool CAsRowVector, bool CAsColVector>
void `hl_cpu_apply_ternary_op`(Op op, T *A_h, T *B_h, T *C_h, int dimM, int dimN, int lda, int ldb, int ldc)

  CPU element wise ternary operator.

  element wise op(a, b, c) for 0 <= i < dimM & for 0 <= j < dimN.

  if (CAsRowVector == 0 && CAsColVector == 0) op(A[i*lda + j], B[i*ldb + j], C[i*ldc + j])

  if (CAsRowVector == 1 && CAsColVector == 0) op(A[i*lda + j], B[i*ldb + j], C[j])

  if (CAsRowVector == 0 && CAsColVector == 1) op(A[i*lda + j], B[i*ldb + j], C[i*ldc])

  if (CAsRowVector == 1 && CAsColVector == 1) op(A[i*lda + j], B[i*ldb + j], C[0])

  CPU element wise ternary operator.

  Parameters
    - `op`: ternary op. see namespace ternary.
    - `A_h`: matrix.
    - `B_h`: matrix.
    - `C_h`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.
    - `ldb`: leading dimension of B.
    - `ldc`: leading dimension of C.

template <class T, class Op>
void `hl_cpu_apply_quaternary_op`(Op op, T *A_h, T *B_h, T *C_h, T *D_h, int dimM, int dimN, int lda, int ldb, int ldc, int ldd)

  CPU element wise quaternary operator. element wise op(a, b, c, d) for 0 <= i < dimM & for 0 <= j < dimN.

  CPU element wise quaternary operator. element wise op(a, b, c, d) for 0 <= i < dimM & for 0 <= j < dimN.

  Parameters
    - `op`: quaternary op. see namespace ternary.
    - `A_h`: matrix.
    - `B_h`: matrix.
    - `C_h`: matrix.
    - `D_h`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.
    - `ldb`: leading dimension of B.
    - `ldc`: leading dimension of C.
    - `ldd`: leading dimension of D.

template <class T, class Op>
void `hl_gpu_apply_unary_op`(Op op, T *A_d, int dimM, int dimN, int lda)

  GPU element wise unary operator. element wise op(a) for 0 <= i < dimM & for 0 <= j < dimN.

  Parameters
    - `op`: unary op. see namespace unary.
    - `A_d`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.

template <class T, class Op, bool BAsRowVector, bool BAsColVector>
void `hl_gpu_apply_binary_op`(Op op, T *A_d, T *B_d, int dimM, int dimN, int lda, int ldb)

  GPU element wise binary operator.

  element wise op(a, b) for 0 <= i < dimM & for 0 <= j < dimN

  if (BAsRowVector == 0 && BAsColVector == 0) op(A[i * lda + j], B[i * ldb + j])

  if (BAsRowVector == 1 && BAsColVector == 0) op(A[i * lda + j], B[j])

  if (BAsRowVector == 0 && BAsColVector == 1) op(A[i * lda + j], B[i * ldb])

  if (BAsRowVector == 1 && BAsColVector == 1) op(A[i * lda + j], B[0])

  Parameters
    - `op`: binary op. see namespace binary.
    - `A_d`: matrix.
    - `B_d`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.
    - `ldb`: leading dimension of B.

template <class T, class Op, bool CAsRowVector, bool CAsColVector>
void `hl_gpu_apply_ternary_op`(Op op, T *A_d, T *B_d, T *C_d, int dimM, int dimN, int lda, int ldb, int ldc)

  GPU element wise ternary operator.

  element wise op(a, b, c) for 0 <= i < dimM & for 0 <= j < dimN.

  if (CAsRowVector == 0 && CAsColVector == 0) op(A[i*lda + j], B[i*ldb + j], C[i*ldc + j])

  if (CAsRowVector == 1 && CAsColVector == 0) op(A[i*lda + j], B[i*ldb + j], C[j])

  if (CAsRowVector == 0 && CAsColVector == 1) op(A[i*lda + j], B[i*ldb + j], C[i*ldc])

  if (CAsRowVector == 1 && CAsColVector == 1) op(A[i*lda + j], B[i*ldb + j], C[0])

  Parameters
    - `op`: ternary op. see namespace ternary.
    - `A_d`: matrix.
    - `B_d`: matrix.
    - `C_d`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.
    - `ldb`: leading dimension of B.
    - `ldc`: leading dimension of C.

template <class T, class Op>
void `hl_gpu_apply_quaternary_op`(Op op, T *A_d, T *B_d, T *C_d, T *D_d, int dimM, int dimN, int lda, int ldb, int ldc, int ldd)

  GPU element wise quaternary operator. element wise op(a, b, c, d) for 0 <= i < dimM & for 0 <= j < dimN.

  Parameters
    - `op`: quaternary op. see namespace ternary.
    - `A_d`: matrix.
    - `B_d`: matrix.
    - `C_d`: matrix.
    - `D_d`: matrix.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `lda`: leading dimension of A.
    - `ldb`: leading dimension of B.
    - `ldc`: leading dimension of C.
    - `ldd`: leading dimension of D.

template <class Agg, class Op, class Saver>
void `hl_cpu_matrix_row_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, int ld, real *A, int lda)

  CPU matrix row operator.

template <class Saver, class Agg, class Op>
void `hl_cpu_matrix_row_op`(Agg agg, Op op, int dimM, int dimN, real *dst, int ld, real *A, int lda, real *B, int ldb)

  CPU matrix row operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `ld`: leading dimension of dst matrix.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.
    - `*B`: matrix B.
    - `ldb`: leading dimension of matrix B.

template <class Agg, class Op, class Saver>
void `hl_cpu_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda)

  CPU matrix column operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `sv`: assignment operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.

template <class Agg, class Op, class Saver>
void `hl_cpu_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda, real *B, int ldb)

  CPU matrix column operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `sv`: assignment operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.
    - `*B`: matrix B.
    - `ldb`: leading dimension of matrix B.

template <class Agg, class Op, class Saver>
void `hl_gpu_matrix_row_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, int ld, real *A, int lda)

  GPU matrix row operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `sv`: assignment operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `ld`: leading dimension of dst.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.

template <class Saver, class Agg, class Op>
void `hl_gpu_matrix_row_op`(Agg agg, Op op, int dimM, int dimN, real *dst, int ld, real *A, int lda, real *B, int ldb)

  GPU matrix row operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `ld`: leading dimension of dst matrix.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.
    - `*B`: matrix B.
    - `ldb`: leading dimension of matrix B.

template <class Agg, class Op, class Saver>
void `hl_gpu_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda)

  GPU matrix column operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `sv`: assignment operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.

template <class Agg, class Op, class Saver>
void `hl_gpu_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda, real *B, int ldb)

  GPU matrix column operator.

  Parameters
    - `agg`: aggregate operator expression.
    - `op`: operator expression.
    - `sv`: assignment operator expression.
    - `dimM`: matrix height.
    - `dimN`: matrix width.
    - `dst`: destination matrix.
    - `*A`: matrix A.
    - `lda`: leading dimension of matrix A.
    - `*B`: matrix B.
    - `ldb`: leading dimension of matrix B.

### hl_matrix_ops.cuh

Defines

`HL_MATRIX_OPS_CUH_`

`HL_DEVICE`

`ONE_PARAMETER`(name)

  parameter macro.

`TWO_PARAMETER`(name)

`THREE_PARAMETER`(name)

`FOUR_PARAMETER`(name)

`DEFINE_MATRIX_UNARY_OP`(name, op)

  unary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b
  See

    hl_gpu_apply_unary_op

    hl_cpu_apply_unary_op

  Parameters
    - `name`: operator name.
    - `op`: operator expression.

`DEFINE_MATRIX_UNARY_PARAMETER_OP`(name, PARA_MACRO, op)

  unary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b
  See

    hl_gpu_apply_unary_op

    hl_cpu_apply_unary_op

  Parameters
    - `name`: operator name.
    - `PARA_MACRO`: parameter macro.
    - `op`: operator expression.

`DEFINE_MATRIX_BINARY_OP`(name, op)

  binary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b
  See

    hl_gpu_apply_unary_op

    hl_cpu_apply_unary_op

  Parameters
    - `name`: operator name.
    - `op`: operator expression.

`DEFINE_MATRIX_BINARY_PARAMETER_OP`(name, PARA_MACRO, op)

  binary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b
  See

    hl_gpu_apply_binary_op

    hl_cpu_apply_binary_op

  Parameters
    - `name`: operator name.
    - `PARA_MACRO`: parameter macro.
    - `op`: operator expression.

`DEFINE_MATRIX_TERNARY_OP`(name, op)

  ternary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b, c
  See

    hl_gpu_apply_ternary_op

    hl_cpu_apply_ternary_op

  Parameters
    - `name`: operator name.
    - `op`: operator expression.

`DEFINE_MATRIX_TERNARY_PARAMETER_OP`(name, PARA_MACRO, op)

  ternary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b, c
  See

    hl_gpu_apply_ternary_op

    hl_cpu_apply_ternary_op

  Parameters
    - `name`: operator name.
    - `PARA_MACRO`: parameter macro.
    - `op`: operator expression.

`DEFINE_MATRIX_QUATERNARY_OP`(name, op)

  quaternary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b, c, d
  See

    hl_gpu_apply_quaternary_op

    hl_cpu_apply_quaternary_op

  Parameters
    - `name`: operator name.
    - `op`: operator expression.

`DEFINE_MATRIX_QUATERNARY_PARAMETER_OP`(name, PARA_MACRO, op)

  quaternary operator macro.

  Note
    op format: op supports multiple expressions that are separated by a comma. e.g. a, b, c, d
  See

    hl_gpu_apply_quaternary_op

    hl_cpu_apply_quaternary_op

  Parameters
    - `name`: operator name.
    - `PARA_MACRO`: parameter macro.
    - `op`: operator expression.

### hl_matrix_type.cuh

Defines

`HL_MATRIX_TYPE_CUH_`

Typedefs

typedef __m128 `vecType`

### hl_sse_matrix_kernel.cuh

Defines

`HL_SSE_MATRIX_KERNEL_CUH_`

`VECTOR_SIZE`

`VECTOR_LEN`

`VECTOR_SET`

Functions

bool `hl_check_align`(size_t size)

bool `hl_check_align`(void *ptr)

template <class Agg>
real `hl_agg_op`(Agg agg, vecType mm)

template <class Agg, class Op, class Saver>
void `hl_sse_matrix_row_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, int ld, real *A, int lda)

template <class Agg, class Op, class Saver>
void `hl_sse_matrix_row_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, int ld, real *A, int lda, real *B, int ldb)

template <class Agg, class Op, class Saver>
void `hl_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda)

template <class Agg, class Op, class Saver>
void `hl_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda, real *B, int ldb)

template <int MaxRow, class Agg, class Op, class Saver>
void `hl_sse_column_op_with_rem`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda)

template <int Step, class Agg, class Op, class Saver>
void `hl_sse_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda)

template <class Agg, class Op, class Saver>
void `hl_sse_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda)

template <int MaxRow, class Agg, class Op, class Saver>
void `hl_sse_column_op_with_rem`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda, real *B, int ldb)

template <int Step, class Agg, class Op, class Saver>
void `hl_sse_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda, real *B, int ldb)

template <class Agg, class Op, class Saver>
void `hl_sse_matrix_column_op`(Agg agg, Op op, Saver sv, int dimM, int dimN, real *dst, real *A, int lda, real *B, int ldb)

### hl_batch_transpose.h

Functions

void `batchTranspose`(const real *input, real *output, int width, int height, int batchSize)

  Perform matrix transpose for each data in the batch.

  Note
    Both the inpt and output are arranged in batch-first order. Each batch has height * width data, which are arranged in height-first (or row-first) manner.
  Parameters
    - `input`: height * width elements in batch.
    - `output`: height * width elements in batch.
    - `width`: width of batch data.
    - `height`: height of batch data.
    - `batchSize`: batch size

## Sparse Matrix

### hl_sparse.h

Functions

void `hl_malloc_sparse_matrix`( hl_sparse_matrix_s *A_d, hl_matrix_format_t format, hl_matrix_value_t value_type, int dimM, int dimN, int nnz)

  Malloc a sparse matrix.

  Parameters
    - `A_d`: sparse matrix.
    - `format`: format.
    - `value_type`: valueType.
    - `dimM`: height.
    - `dimN`: width.
    - `nnz`: number of none zero element.

void `hl_free_sparse_matrix`( hl_sparse_matrix_s A_d)

  Free a sparse matrix.

  Parameters
    - `A_d`: GPU sparse matrix.

void `hl_construct_sparse_matrix`( hl_sparse_matrix_s *A_d, void *dest_d, size_t size, hl_matrix_format_t format, hl_matrix_value_t value_type, int dimM, int dimN, int nnz)

  Construct a sparse matrix use input gpu memory.

  Note
    Destruct api is hl_destruct_sparse_matrix.
  Parameters
    - `A_d`: sparse matrix.
    - `dest_d`: gpu memory.
    - `size`: size of dest_d.
    - `format`: format.
    - `value_type`: valueType.
    - `dimM`: height.
    - `dimN`: width.
    - `nnz`: number of none zero element.

void `hl_construct_sparse_matrix`( hl_sparse_matrix_s *A_d, real *value_d, int *rows_d, int *cols_d, hl_matrix_format_t format, hl_matrix_value_t value_type, int dimM, int dimN, int nnz)

  Use three arrays to construct sparse matrix.

  if format is HL_SPARSE_CSR, size of rows_d is dimM + 1, and size of cols_d is nnz;

  if format is HL_SPARSE_CSC, size of rows_d is nnz, and size of cols_d is dimN + 1.

  if valueType is HL_NO_VALUE, size of value_d is zero, else size of value_d is nnz.

  Note
    The corresponding destructor interface is hl_destruct_sparse_matrix.
  Parameters
    - `A_d`: sparse matrix.
    - `value_d`: value.
    - `rows_d`: row.
    - `cols_d`: col.
    - `format`: format.
    - `value_type`: valueType.
    - `dimM`: height.
    - `dimN`: width.
    - `nnz`: number of none zero element.

void `hl_destruct_sparse_matrix`( hl_sparse_matrix_s A_d)

  Destruct sparse matrix.

  Parameters
    - `A_d`: sparse matrix.

void `hl_memcpy_csr_matrix`( hl_sparse_matrix_s csr_matrix, real *csr_val, int *csr_row, int *csr_col, hl_stream_t stream)

  Copy value & index to sparse matrix.

  if csr_matrix is HL_FLOAT_VALUE.

  1. csr_val, csr_row, csr_col three pointers are not null.
  2. csr_val is not null, csr_row adn csr_col are null.

  if csr_matrix is HL_NO_VALUE.

  1. csr_val will be ignore, csr_row and csr_col are not null.

  Parameters
    - `csr_matrix`: sparse matrix.
    - `csr_val`: point to csr value array(nnz).
    - `csr_row`: point to csr row indices array(dimM+1).
    - `csr_col`: point to csr col indices array(nnz).
    - `stream`: hl_stream_t type.

void `hl_memcpy_csc_matrix`( hl_sparse_matrix_s csc_matrix, real *csc_val, int *csc_row, int *csc_col, hl_stream_t stream)

  Copy value & index to sparse matrix.

  if csr_matrix is HL_FLOAT_VALUE.

  1. csc_val, csc_row, csc_col three pointers are not null.
  2. csc_val is not null, csc_row and csc_col are null.

  if csr_matrix is HL_NO_VALUE.

  1. csc_val will be ignore, csc_row and csc_col are not null.

  Parameters
    - `csc_matrix`: sparse matrix.
    - `csc_val`: point to csc value array(nnz).
    - `csc_row`: point to csc row indices array(nnz).
    - `csc_col`: point to csc col indices array(dimN+1).
    - `stream`: hl_stream_t type.

void `hl_memcpy_sparse_matrix`( hl_sparse_matrix_s dst, hl_sparse_matrix_s src, hl_stream_t stream)

  Copy sparse matrix to sparse matrix.

  Note
    1. Format of the src matrix and dst matrix needs to be consistent.
    1. Source matrix has value, the destination matrix has value or no value can be; the source matrix is no value, then the destination matrix must also be no value;
  Parameters
    - `dst`: sparse matrix.
    - `src`: sparse matrix.
    - `stream`: hl_stream_t type.

void `hl_matrix_csr2dense`( hl_sparse_matrix_s A_d, real *C_d, int dimM, int dimN)

  csr matrix to dense matrix.

  Parameters
    - `A_d`: csr matrix.
    - `C_d`: dense matrix.
    - `dimM`: height.
    - `dimN`: width.

void `hl_matrix_csc2dense`( hl_sparse_matrix_s A_d, real *C_d, int dimM, int dimN)

  csc matrix to dense matrix.

  Parameters
    - `A_d`: csc matrix.
    - `C_d`: dense matrix.
    - `dimM`: height.
    - `dimN`: width.

void `hl_matrix_csr_mul_dense`( hl_sparse_matrix_s A_d, hl_trans_op_t transa, real *B_d, hl_trans_op_t transb, real *C_d, int dimM, int dimN, int dimK, real alpha, real beta)

  C_d = alpha*(op(A_d) * op(B_d)) + beta*C_d.

  Note
    transb is not support HPPL_OP_T.
  Parameters
    - `A_d`: csr sparse matrix.
    - `transa`: operation op(A) that is non-or transpose.
    - `B_d`: dense matrix.
    - `transb`: operation op(B) that is non-or transpose.
    - `C_d`: dense matrix.
    - `dimM`: matrix height of op(A) & C
    - `dimN`: matrix width of op(B) & C
    - `dimK`: width of op(A) & height of op(B)
    - `alpha`: scalar used for multiplication.
    - `beta`: scalar used for multiplication. If beta is zero, C does not have to be a valid input.

void `hl_matrix_csc_mul_dense`( hl_sparse_matrix_s A_d, hl_trans_op_t transa, real *B_d, hl_trans_op_t transb, real *C_d, int dimM, int dimN, int dimK, real alpha, real beta)

  C_d = alpha*(op(A_d) * op(B_d)) + beta*C_d.

  Note
    transb is not support HPPL_OP_T.
  Parameters
    - `A_d`: sparse matrix.
    - `transa`: operation op(A) that is non-or transpose.
    - `B_d`: dense matrix.
    - `transb`: operation op(B) that is non-or transpose.
    - `C_d`: dense matrix.
    - `dimM`: matrix height of op(A) & C
    - `dimN`: matrix width of op(B) & C
    - `dimK`: width of op(A) & height of op(B)
    - `alpha`: scalar used for multiplication.
    - `beta`: scalar used for multiplication. If beta is zero, C does not have to be a valid input.

void `hl_matrix_dense_mul_csc`(real *A_d, hl_trans_op_t transa, hl_sparse_matrix_s B_d, hl_trans_op_t transb, real *C_d, int dimM, int dimN, int dimK, real alpha, real beta)

  C_d = alpha*(op(A_d) * op(B_d)) + beta*C_d.

  Note
    transa is not support HPPL_OP_T.
  Parameters
    - `A_d`: dense matrix.
    - `transa`: operation op(A) that is non-or transpose.
    - `B_d`: csc sparse matrix.
    - `transb`: operation op(B) that is non-or transpose.
    - `C_d`: dense matrix.
    - `dimM`: matrix height of op(A) & C
    - `dimN`: matrix width of op(B) & C
    - `dimK`: width of op(A) & height of op(B)
    - `alpha`: scalar used for multiplication.
    - `beta`: scalar used for multiplication. If beta is zero, C does not have to be a valid input.

void `hl_sparse_matrix_mul`(real *A_d, hl_trans_op_t transa, real *B_d, hl_trans_op_t transb, hl_sparse_matrix_s C_d, int dimM, int dimN, int dimK, real alpha, real beta)

  C_d = alpha*(op(A_d) * op(B_d)) + beta*C_d. Calculated based on the non-zero elements of the matrix C.

  Note
    transb is not support HPPL_OP_T.
  Parameters
    - `A_d`: dense matrix.
    - `transa`: operation op(A) that is non-or transpose.
    - `B_d`: dense matrix.
    - `transb`: operation op(B) that is non-or transpose.
    - `C_d`: sparse matrix.
    - `dimM`: matrix height of op(A) & C
    - `dimN`: matrix width of op(B) & C
    - `dimK`: width of op(A) & height of op(B)
    - `alpha`: scalar used for multiplication.
    - `beta`: scalar used for multiplication.

void `hl_matrix_dense_mul_csr`(real *A_d, hl_trans_op_t transa, hl_sparse_matrix_s B_d, hl_trans_op_t transb, real *C_d, int dimM, int dimN, int dimK, real alpha, real beta)

  C_d = alpha*(op(A_d) * op(B_d)) + beta*C_d.

  Note
    transa is not support HPPL_OP_T.
  Parameters
    - `A_d`: dense matrix.
    - `transa`: operation op(A) that is non-or transpose.
    - `B_d`: sparse matrix.
    - `transb`: operation op(B) that is non-or transpose.
    - `C_d`: dense matrix.
    - `dimM`: matrix height of op(A) & C
    - `dimN`: matrix width of op(B) & C
    - `dimK`: width of op(A) & height of op(B)
    - `alpha`: scalar used for multiplication.
    - `beta`: scalar used for multiplication. If beta is zero, C does not have to be a valid input.

void `hl_memcpy_from_csc_matrix`(real *csc_val, size_t val_size, int *csc_row, size_t row_size, int *csc_col, size_t col_size, hl_sparse_matrix_s csc_matrix, hl_stream_t stream)

  Memcpy csc_matrix to host.

  a. according to csc_matrix, update three arrays

  1. csc_val, csc_row, csc_col are dest Address.
  2. if type of csc_matrix is HL_NO_VALUE, update csc_row and csc_col
  3. if type of csc_matrix is HL_FLOAT_VALUE, update csc_row, csc_col and csc_value.

  b. The interface is asynchronous copy. To ensure that the data is copied please call the synchronous interface;

  Parameters
    - `csc_val`: point to csc value array(nnz).
    - `val_size`: csc value size.
    - `csc_row`: point to csc row indices array(nnz).
    - `row_size`: csc row size.
    - `csc_col`: point to csc col indices array(dimN + 1).
    - `col_size`: csc column size.
    - `csc_matrix`: sparse matrix.
    - `stream`: hl_stream_t type.

void `hl_memcpy_from_csr_matrix`(real *csr_val, size_t val_size, int *csr_row, size_t row_size, int *csr_col, size_t col_size, hl_sparse_matrix_s csr_matrix, hl_stream_t stream)

  Memcpy sparse matrix to host.

  a. according to csr_matrix, update three arrays

  1. csr_val, csr_row, csr_col are dest Address.
  2. if type of csr_matrix is HL_NO_VALUE, update csr_row and csr_col
  3. if type of csr_matrix is HL_FLOAT_VALUE, update csr_row, csr_col and csr_value

  b. The interface is asynchronous copy. To ensure that the data is copied please call the synchronous interface;

  Parameters
    - `csr_val`: point to csr value array(nnz).
    - `val_size`: csr value size.
    - `csr_row`: point to csr row indices array(nnz).
    - `row_size`: csr row size.
    - `csr_col`: point to csr col indices array(dimN + 1).
    - `col_size`: csr column size.
    - `csr_matrix`: sparse matrix.
    - `stream`: hl_stream_t type.

void `hl_sparse_matrix_column_sum`(real *A_d, hl_sparse_matrix_s B_d, int dimM, int dimN, real scale)

  A_d[j] += B_d[i,j] for i in range(height)

  Parameters
    - `A_d`: vector, size = width.
    - `B_d`: sparse matrix.
    - `dimM`: height.
    - `dimN`: width.
    - `scale`: scale of B_d

void `hl_matrix_csr_column_sum`(real *A_d, hl_sparse_matrix_s B_d, int dimM, int dimN, real scale)

  implementation of csr sparse matrix in hl_sparse_matirx_column_sum

void `hl_sparse_matrix_add_bias`( hl_sparse_matrix_s A_d, real *B_d, real scale)

  A_d[i,j] += B_d[j].

  Parameters
    - `A_d`: sprare matrix.
    - `B_d`: vector, size = A_d.width.
    - `scale`: scale of B_d.

void `hl_matrix_csr_add_bias`( hl_sparse_matrix_s A_d, real *B_d, real scale)

  implementation of csr sparse matrix in hl_sparse_matrix_add_bias

void `hl_sparse_matrix_add_dense`( hl_sparse_matrix_s A_d, real *B_d, int dimM, int dimN, real alpha, real beta)

  sparseMatrix = alpha * denseMatrix + beta *sparseMatrix A_d[i,j] = alpha * B_d[i,j] + beta * A_d[i,j] Only add value of same (row, col) index in dense matrix and do not use others values whoes postions are not in sparse matirx.

  Parameters
    - `A_d`: sprare matrix.
    - `B_d`: dense matrix.
    - `dimM`: height of B_d.
    - `dimN`: width of B_d.
    - `alpha`: scale of B_d.
    - `beta`: scale of A_d.

void `hl_matrix_csr_add_dense`( hl_sparse_matrix_s A_d, real *B_d, int dimM, int dimN, real alpha, real beta)

  implementation of csr sparse matrix in hl_sparse_matrix_add_dense

int *`hl_sparse_matrix_get_rows`( hl_sparse_matrix_s sMat)

  get rows pionter of GpuSparseMatrix

  Return
    return rows pointer, which is gpu address
  Parameters
    - `sMat`: sparse matrix

int *`hl_sparse_matrix_get_cols`( hl_sparse_matrix_s sMat)

  get cols pionter of GpuSparseMatrix

  Return
    return cols pointer, which is gpu address
  Parameters
    - `sMat`: sparse matrix

real *`hl_sparse_matrix_get_value`( hl_sparse_matrix_s sMat)

  get value pionter of GpuSparseMatrix

  Return
    return value pointer, which is gpu address
  Parameters
    - `sMat`: sparse matrix

### hl_sparse.ph

Defines

`HL_SPARSE_PH_`

`__sparse_get_type_return__`(mat, type, field)

`__sparse_get_return__`(mat, field)

Typedefs

typedef struct _hl_csr_matrix *`hl_csr_matrix`

typedef struct _hl_csc_matrix *`hl_csc_matrix`

struct `_hl_csr_matrix`

  sparse matrix csr format.

  Parameters
    - `*csr_val`: nonzero values of matrix.
    - `*csr_row`: row indices.
    - `*csr_col`: column indices.
    - `nnz_s`: sizeof of csr_val & csr_col.
    - `row_s`: sizeof of csr_row.
    - `sparsity`: sparsity pattern.

  Public Members

  real *`csr_val`
  int *`csr_row`
  int *`csr_col`
  size_t `nnz_s`
  int `row_s`
  float `sparsity`

struct `_hl_csc_matrix`

  sparse matrix csc format.

  Parameters
    - `*csc_val`: nonzero values of matrix.
    - `*csc_row`: row indices.
    - `*csc_col`: column indices.
    - `nnz_s`: sizeof of csc_val & csc_row.
    - `col_s`: sizeof of csc_col.
    - `sparsity`: sparsity pattern.

  Public Members

  real *`csc_val`
  int *`csc_row`
  int *`csc_col`
  size_t `nnz_s`
  int `col_s`
  float `sparsity`

## Others

### hl_aggregate.h

Functions

void `hl_matrix_row_sum`(real *A_d, real *C_d, int dimM, int dimN)

  Calculate the sum of each row of the matrix A_d.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output matrix (M x 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_row_max`(real *A_d, real *C_d, int dimM, int dimN)

  Calculate the maximum value of each row of the matrix A_d.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output matrix (M x 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_row_min`(real *A_d, real *C_d, int dimM, int dimN)

  Calculate the minimum value of each row of the matrix A_d.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output matrix (M x 1).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_column_sum`(real *A_d, real *C_d, int dimM, int dimN)

  Calculate the sum of each column of the matrix A_d.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output Matrix (1 x N).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_column_max`(real *A_d, real *C_d, int dimM, int dimN)

  Calculate the maximum value of each column of the matrix A_d.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output matrix (1 x N).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_matrix_column_min`(real *A_d, real *C_d, int dimM, int dimN)

  Calculate the minimum value of each column of the matrix A_d.

  Parameters
    - `A_d`: input matrix (M x N).
    - `C_d`: output matrix (1 x N).
    - `dimM`: matrix height.
    - `dimN`: matrix width.

void `hl_vector_sum`(real *A_d, real *C_h, int dimM)

  C_h = sum(A_d[i]).

  Parameters
    - `A_d`: input(m).
    - `C_h`: output(host memory).
    - `dimM`: size of vector.

void `hl_vector_abs_sum`(real *A_d, real *C_h, int dimM)

  C_h = sum(abs(A_d[i])).

  Parameters
    - `A_d`: input(m).
    - `C_h`: output(host memory).
    - `dimM`: size of vector.

### hl_table_apply.h

Functions

void `hl_matrix_select_rows`(real *output, int ldo, real *table, int ldt, int *ids, int numSamples, int tableSize, int dim)

  Get row from table. output[i] += table[ids[i]] if ids[i] == -1, it will be ignored.

  Parameters
    - `output`: output matrix.
    - `ldo`: leading dimension of output.
    - `table`: table matrix.
    - `ldt`: leading dimension of table.
    - `ids`: ids vector.
    - `numSamples`: height of output.
    - `tableSize`: height of table.
    - `dim`: width of table.

void `hl_matrix_add_to_rows`(real *table, int ldt, real *input, int ldi, int *ids, int numSamples, int tableSize, int dim)

  Add row to table. table[ids[i]] += output[i] if ids[i] == -1, it will be ignored.

  Parameters
    - `table`: table matrix.
    - `ldt`: leading dimension of table.
    - `input`: input matrix.
    - `ldi`: leading dimension of input.
    - `ids`: ids vector.
    - `numSamples`: height of input.
    - `tableSize`: height of table.
    - `dim`: width of table.

template <class T>
void `hl_vector_select_from`(T *dst, int sized, const T *src, int sizes, const int *ids, int sizei)

  Select element from vector.

  Parameters
    - `dst`: output vector.
    - `sized`: size of dst.
    - `src`: input vector.
    - `sizes`: size of src.
    - `ids`: index vector.
    - `sizei`: size of ids.

### hl_top_k.h

Functions

void `hl_matrix_top_k`(real *topVal, int ldv, int *topIds, real *src, int lds, int dim, int beamSize, int numSamples)

  find top k element.

  Parameters
    - `topVal`: top k element.
    - `ldv`: leading dimension of topVal.
    - `topIds`: top k index.
    - `src`: input value.
    - `lds`: leading dimension of src.
    - `dim`: width of input value.
    - `beamSize`: beam size.
    - `numSamples`: height of input value.

void `hl_sparse_matrix_top_k`(real *topVal, int ldv, int *topIds, hl_sparse_matrix_s src, int beamSize, int numSamples)

  find top k element for each row in sparse matrix.

  Note
    Only support HL_SPARSE_CSR format.
  Parameters
    - `topVal`: top k element.
    - `ldv`: leading dimension of topVal.
    - `topIds`: top k index.
    - `src`: sparse matrix.
    - `beamSize`: beam size.
    - `numSamples`: height of input value.