Multiplies the dense matrix *B* by the sparse matrix *A* and adds the result to the dense matrix *C*, all with double-precision values.

SDKs

- iOS 9.0+
- macOS 10.11+
- Mac Catalyst 13.0+
- tvOS 9.0+
- watchOS 3.0+

Framework

- Accelerate

## Declaration

## Parameters

`order`

The storage order for the dense matrices

*B*and*C*. Must be one of*CblasRowMajor*or*CblasColMajor*.`transa`

Specifies whether to perform the operation with

*A*or the transpose of*A*. Must be one of*CblasNoTrans*or*CblasTrans*.`n`

The number of columns of the matrices

*B*and*C*.`alpha`

Scalar multiplier of

*A*.`A`

The sparse matrix,

*A*.`B`

Pointer to the dense matrix

*B*. The number of rows must be equal to the number of columns of*A*and the number of columns is`n`

. Behavior undefined if this is not met. The parameter`ldb`

describes how many elements to move between one row (row major) or column (column major).`ldb`

Increment in elements between rows (row major) or columns (column major) of

*B*. Must be greater than or equal to`n`

when row major, or number of columns of*A*when column major.`C`

Pointer to the dense matrix

*C*. The number of rows must be equal to the number of rows of*A*and the number of columns is`n`

. Behavior undefined if this is not met. The argument`ldc`

describes how many elements to move between one row (row major) or column (column major).*C*is updated with the result of the operation.`ldc`

Increment in elements between rows (row major) or columns (column major) of

*C*. Must be greater than or equal to`n`

when row major, or number of rows of*A*when column major.

## Return Value

On success, `SPARSE`

is returned and `C`

has been updated with result of the operation. Will return `SPARSE`

if order or `transa`

is not valid or the leading dimension parameters do not meet their dimension requirements. On error, `C`

is unchanged.

## Discussion

Multiplies the dense matrix *B* by the sparse matrix *A* and adds the result to the dense matrix *C* (*C = alpha * op(A) * B + C*, where *op(A)* is either *A* or the transpose of *A*). If *A* is of size *M x N*, then *B* is of size *N x n* and *C* is of size *M x n*.If the desired operation is *C = A * B*, then an efficient option is to create the *C* buffer of zeros and then perform the operation with the zero filled *C*.