Function af_create_sparse_array_from_ptr

src/api/c/sparse.cpp:249–301

}

af_err af_create_sparse_array_from_ptr(
    af_array *out, const dim_t nRows, const dim_t nCols, const dim_t nNZ,
    const void *const values, const int *const rowIdx, const int *const colIdx,
    const af_dtype type, const af_storage stype, const af_source source) {
    try {
        // Checks:
        // rowIdx and colIdx arrays are of s32 type
        // values is of floating point type
        // if COO, rowIdx, colIdx and values should have same dims
        // if CRS, colIdx and values should have same dims, rowIdx.dims = nRows
        // if CRC, rowIdx and values should have same dims, colIdx.dims = nCols
        // stype is within acceptable range
        // type is floating type
        if (!(stype == AF_STORAGE_CSR || stype == AF_STORAGE_CSC ||
              stype == AF_STORAGE_COO)) {
            AF_ERROR("Storage type is out of range/unsupported", AF_ERR_ARG);
        }

        TYPE_ASSERT(type == f32 || type == f64 || type == c32 || type == c64);

        af_array output = nullptr;

        dim4 dims(nRows, nCols);

        switch (type) {
            case f32:
                output = createSparseArrayFromPtr<float>(
                    dims, nNZ, static_cast<const float *>(values), rowIdx,
                    colIdx, stype, source);
                break;
            case f64:
                output = createSparseArrayFromPtr<double>(
                    dims, nNZ, static_cast<const double *>(values), rowIdx,
                    colIdx, stype, source);
                break;
            case c32:
                output = createSparseArrayFromPtr<cfloat>(
                    dims, nNZ, static_cast<const cfloat *>(values), rowIdx,
                    colIdx, stype, source);
                break;
            case c64:
                output = createSparseArrayFromPtr<cdouble>(
                    dims, nNZ, static_cast<const cdouble *>(values), rowIdx,
                    colIdx, stype, source);
                break;
            default: TYPE_ERROR(1, type);
        }
        std::swap(*out, output);
    }
    CATCHALL;

    return AF_SUCCESS;
}

af_err af_create_sparse_array_from_dense(af_array *out, const af_array in,
                                         const af_storage stype) {