casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/sleqp/sparse/pub_mat.h

@@ -0,0 +1,153 @@
+#ifndef SLEQP_PUB_MAT_H
+#define SLEQP_PUB_MAT_H
+
+/**
+ * @file pub_mat.h
+ * @brief Definition of sparse matrices.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+#include "sleqp/sparse/pub_vec.h"
+
+/**
+ * A sparse matrix data structure.
+ * So far the data is stored in CSC format.
+ * Specifically:
+ *
+ * \f$ A(i, j) = data[k]\f$ iff \f$ rows[k] = i \f$ and \f$ cols[j] <= k <
+ *cols[j + 1] \f$
+ *
+ * for \f$ k = 0, \ldots, nnz - 1 \f$
+ *
+ **/
+typedef struct SleqpMat SleqpMat;
+
+/**
+ * Creates a new sparse matrix with a specified number of nonzeros
+ *
+ * @param[in] matrix     A pointer to the matrix to be created
+ * @param[in] num_rows   The desired number of rows
+ * @param[in] num_cols   The desired number of columns
+ * @param[in] nnz_max    The desired number of nonzeros
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_create(SleqpMat** matrix, int num_rows, int num_cols, int nnz_max);
+
+/**
+ * Reserves a number of nonzeros for the given matrix
+ *
+ * @param[in] matrix   The matrix
+ * @param[in] nnz      The desired number of nonzeros
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_reserve(SleqpMat* matrix, int nnz);
+
+/**
+ * Resizes the given matrix
+ *
+ * @note If the matrix is non-empty, decreasing the size can leave the matrix in
+ *an inconsistent state
+ *
+ * @param[in] matrix     The matrix
+ * @param[in] num_rows   The desired number of rows
+ * @param[in] num_cols   The desired number of columns
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_resize(SleqpMat* matrix, int num_rows, int num_cols);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_scale(SleqpMat* matrix, double scale);
+
+/**
+ * Returns the number of columns of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_num_cols(const SleqpMat* matrix);
+
+/**
+ * Returns the number of rows of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_num_rows(const SleqpMat* matrix);
+
+/**
+ * Returns the number of nonzeros of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_nnz(const SleqpMat* matrix);
+
+/**
+ * Returns the maximum number of nonzeros of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_nnz_max(const SleqpMat* matrix);
+
+/**
+ * Sets the number of nonzeros of the given matrix
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_set_nnz(SleqpMat* matrix, int nnz);
+
+/**
+ * Returns whether the given matrix is rectangular
+ **/
+SLEQP_EXPORT bool
+sleqp_mat_is_quadratic(const SleqpMat* matrix);
+
+/**
+ * Returns a pointer to the values of the matrix
+ **/
+SLEQP_EXPORT double*
+sleqp_mat_data(const SleqpMat* matrix);
+
+/**
+ * Returns a pointer to the columns of the given matrix
+ **/
+SLEQP_EXPORT int*
+sleqp_mat_cols(const SleqpMat* matrix);
+
+/**
+ * Returns a pointer to the rows of the given matrix
+ **/
+SLEQP_EXPORT int*
+sleqp_mat_rows(const SleqpMat* matrix);
+
+/**
+ * Pushes a new entry to the matrix. Fails if the matrix is at capacity
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_push(SleqpMat* matrix, int row, int col, double value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_push_vec(SleqpMat* matrix, int col, SleqpVec* vec);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_push_col(SleqpMat* matrix, int col);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_pop_col(SleqpMat* matrix, int col);
+
+/**
+ * Copies the given matrix
+ *
+ * @param[in]     source     The source matrix
+ * @param[in,out] target     The target matrix
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_copy(const SleqpMat* source, SleqpMat* target);
+
+/**
+ * Increases the reference count of the given matrix
+ */
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_capture(SleqpMat* matrix);
+
+/**
+ * Decreases the reference count of the given matrix, freeing it
+ * if the reference count reaches count
+ */
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_release(SleqpMat** star);
+
+#endif /* SLEQP_PUB_MAT_H */

casadi/include/sleqp/sparse/pub_vec.h

@@ -0,0 +1,336 @@
+#ifndef SLEQP_PUB_VEC_H
+#define SLEQP_PUB_VEC_H
+
+/**
+ * @file pub_vec.h
+ * @brief Definition of vectors.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+
+/**
+ * A sparse vector data structure. Indices
+ * are stored in an ascending fashion.
+ **/
+typedef struct SleqpVec
+{
+  double* data;
+  int* indices;
+
+  int dim;
+  int nnz;
+  int nnz_max;
+
+} SleqpVec;
+
+/**
+ * Creates a new vector. Data and indices are set to
+ * have size of nnz_max.
+ *
+ * @param[in]  vec     A pointer to the vector to be created
+ * @param[in]  dim     The desired dimension of the vector
+ * @param[in]  nnz_max The desired amount of nonzeros of the vector
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_create(SleqpVec** vec, int dim, int nnz_max);
+
+/**
+ * Creates a new vector without allocating memory
+ * for non-zero entries
+ *
+ * @param[in]  vec     A pointer to the vector to be created
+ * @param[in]  dim     The desired dimension of the vector
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_create_empty(SleqpVec** vec, int dim);
+
+/**
+ * Creates a new vector, allocating memory sufficient
+ * for `dim` non-zero entries
+ *
+ * @param[in]  vec     A pointer to the vector to be created
+ * @param[in]  dim     The desired dimension of the vector
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_create_full(SleqpVec** vec, int dim);
+
+/**
+ * Pushes a new entry on top of a vector. The new
+ * entry is assumed to have a larger index than the existing ones.
+ *
+ * @param[in,out] vec    A pointer to the vector
+ * @param[in]     idx    The index of the new entry
+ * @param[in]     value  The value of the new entry
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_push(SleqpVec* vec, int idx, double value);
+
+/**
+ * Creates the entries of a vector from a dense
+ * vector. The vector will reserve an appropriate
+ * number of entries, the dimension will be changed to
+ * match that of the dense vector.
+ *
+ * @param[in,out] vec         A pointer to the vector
+ * @param[in]     values      A vector of values
+ * @param[in]     dim         The dimension of the values input
+ * @param[in]     zero_eps    The numerical tolerance
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_set_from_raw(SleqpVec* vec,
+                       const double* values,
+                       int dim,
+                       double zero_eps);
+
+/**
+ * Fills the given vector with the given value
+ * by setting all of its element to have that precise value
+ *
+ * @param[in,out] vec         A pointer to the vector
+ * @param[in]     value       The given value
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_fill(SleqpVec* vec, double value);
+
+/**
+ * Writes the content of this vector into an array. The
+ * array is assumed to have a size of at least the dimension
+ * of the given vector
+ *
+ * @param[in] vec     A pointer to the vector
+ * @param[in] values  A pointer to the output array
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_to_raw(const SleqpVec* vec, double* values);
+
+/**
+ * Copies one vector to another
+ *
+ * @param[in] source     A pointer to the copy source
+ * @param[out] target    A pointer to the copy target
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_copy(const SleqpVec* source, SleqpVec* target);
+
+/**
+ * Clears the given vector, discarding all entries while
+ * keeping the dimension constant
+ *
+ * @param[in,out] vec     A pointer to the vector
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_clear(SleqpVec* vec);
+
+/**
+ * Reserves space for additional nonzeros
+ *
+ * @param[in,out] vec     A pointer to the vector
+ * @param[in]     nnz_max The number of nonzeros
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_reserve(SleqpVec* vec, int nnz);
+
+/**
+ * Resizes the vector to the given dimension, discarding
+ * entries if necessary
+ *
+ * @param[in,out] vec     A pointer to the vector
+ * @param[in]     dim     The new dimension
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_resize(SleqpVec* vec, int dim);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_concat(const SleqpVec* first,
+                 const SleqpVec* second,
+                 SleqpVec* result);
+
+/**
+ * Returns whether all entries of the given vector are equal
+ * up to the given tolerance
+ *
+ * @param[in]  first     A pointer to the first vector
+ * @param[in]  second    A pointer to the second vector
+ * @param[in]  eps       The desred tolerance
+ *
+ * @sa sleqp_is_eq(double x, double y, double eps)
+ **/
+SLEQP_EXPORT bool
+sleqp_vec_eq(const SleqpVec* first, const SleqpVec* second, double eps);
+
+/**
+ * Computes the dot product of two vectors
+ *
+ * @param[in]  first     A pointer to the first vector
+ * @param[in]  second    A pointer to the second vector
+ * @param[out] product   A pointer to the result
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_dot(const SleqpVec* first, const SleqpVec* second, double* product);
+
+/**
+ * Scales the vector by a factor
+ *
+ * @param[in,out] vector   A pointer to the vector
+ * @param[in]     factor   The factor
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_scale(SleqpVec* vector, const double factor);
+
+/**
+ * Computes the sum of two vectors
+ *
+ * @param[in]  first         A pointer to the first vector
+ * @param[in]  second        A pointer to the second vector
+ * @param[out] result        A pointer to the result
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_add(const SleqpVec* first,
+              const SleqpVec* second,
+              const double eps,
+              SleqpVec* result);
+
+/**
+ * Computes the weighted sum of two vectors
+ *
+ * @param[in]  first         A pointer to the first vector
+ * @param[in]  second        A pointer to the second vector
+ * @param[in]  first_factor  A factor for the first vector
+ * @param[in]  second_factor A factor for the second vector
+ * @param[out] result        A pointer to the result
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_add_scaled(const SleqpVec* first,
+                     const SleqpVec* second,
+                     const double first_factor,
+                     const double second_factor,
+                     const double eps,
+                     SleqpVec* result);
+
+/**
+ * Fills all entries of the vector with the specified value
+ *
+ * @param[in,out] vector   A pointer to the vector
+ * @param[in]      value   The value
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_fill(SleqpVec* vec, double value);
+
+/**
+ * Returns the 2-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_norm(const SleqpVec* vec);
+
+/**
+ * Returns the 1-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_one_norm(const SleqpVec* vec);
+
+/**
+ * Returns the squared 2-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_norm_sq(const SleqpVec* vec);
+
+/**
+ * Returns the oo-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_inf_norm(const SleqpVec* vec);
+
+/**
+ * Returns a pointer to the entry of the given vector at
+ * the given index, or `NULL` if the entry is not present.
+ *
+ * @param[in] vector   A pointer to the vector
+ * @param[in] index    The desired index
+ **/
+SLEQP_EXPORT double*
+sleqp_vec_at(const SleqpVec* vec, int index);
+
+/**
+ * Returns the value of the given vector at the given index
+ *
+ * @param[in] vector   A pointer to the vector
+ * @param[in] index    The desired index
+ **/
+SLEQP_EXPORT double
+sleqp_vec_value_at(const SleqpVec* vec, int index);
+
+/**
+ * Returns whether this vector is boxed, i.e., \f$ lb \leq x \leq ub \f$
+ * for all components.
+ *
+ * @param[in] x    A pointer to the vector
+ * @param[in] lb   A pointer to the lower bound vector
+ * @param[in] ub   A pointer to the upper bound vector
+ *
+ SLEQP_EXPORT * @sa sleqp_vec_clip
+**/
+SLEQP_EXPORT bool
+sleqp_vec_is_boxed(const SleqpVec* x, const SleqpVec* lb, const SleqpVec* ub);
+
+/**
+ * Clips this vector to the specified lower and upper bounds, storing
+ * the result in the pointer to a new vector, which will be boxed
+ * w.r.t. `lb` and `ub`
+ *
+ * @param[in]  x     A pointer to the vector
+ * @param[in]  lb    A pointer to the lower bound vector
+ * @param[in]  ub    A pointer to the upper bound vector
+ * @param[out] xclip A pointer to the clipped vector
+ *
+ SLEQP_EXPORT * @sa sleqp_vec_is_boxed
+**/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_clip(const SleqpVec* x,
+               const SleqpVec* lb,
+               const SleqpVec* ub,
+               const double eps,
+               SleqpVec* xclip);
+
+/**
+ * Prints this vector to the given file
+ *
+ * @param[in]  vec     A pointer to the vector
+ * @param[in]  output  A pointer to an output `FILE*`
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_fprintf(const SleqpVec* vec, FILE* output);
+
+/**
+ * Returns whether the given vector is *valid*, i.e., whether
+ * - `nnz` non-negative and less than or equal to `nnz_max`
+ * - all indices are non-negative and less than or equal to `dim`
+ * - the entries are ordered according to their indices
+ *
+ **/
+SLEQP_EXPORT bool
+sleqp_vec_is_valid(const SleqpVec* vec);
+
+/**
+ * Returns whether the entries of the given vector are finite with respect to
+ *  \ref sleqp_is_finite(double)
+ **/
+SLEQP_EXPORT bool
+sleqp_vec_is_finite(const SleqpVec* vec);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_free(SleqpVec** vec);
+
+#endif /* SLEQP_PUB_VEC_H */

casadi/include/sleqp.h

@@ -0,0 +1,38 @@
+#ifndef SLEQP_H
+#define SLEQP_H
+
+/**
+ * @file sleqp.h
+ * @brief SLEQP callable library.
+ **/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "sleqp/defs.h"
+#include "sleqp/export.h"
+
+#include "sleqp/pub_cmp.h"
+#include "sleqp/pub_dyn.h"
+#include "sleqp/pub_error.h"
+#include "sleqp/pub_func.h"
+#include "sleqp/pub_hess_struct.h"
+#include "sleqp/pub_iterate.h"
+#include "sleqp/pub_log.h"
+#include "sleqp/pub_lsq.h"
+#include "sleqp/pub_mem.h"
+#include "sleqp/pub_problem.h"
+#include "sleqp/pub_scale.h"
+#include "sleqp/pub_settings.h"
+#include "sleqp/pub_solver.h"
+#include "sleqp/pub_types.h"
+#include "sleqp/pub_working_set.h"
+#include "sleqp/sparse/pub_mat.h"
+#include "sleqp/sparse/pub_vec.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLEQP_H */

casadi/include/spral.h

@@ -0,0 +1,13 @@
+#ifndef SPRAL_H
+#define SPRAL_H
+
+#include "spral_lsmr.h"
+#include "spral_matrix_util.h"
+#include "spral_random.h"
+#include "spral_random_matrix.h"
+#include "spral_rutherford_boeing.h"
+#include "spral_scaling.h"
+#include "spral_ssids.h"
+#include "spral_ssmfe.h"
+
+#endif // SPRAL_H

casadi/include/spral_lsmr.h

@@ -0,0 +1,57 @@
+#ifndef SPRAL_LSMR_H
+#define SPRAL_LSMR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+
+/************************************
+ * Derived types
+ ************************************/
+struct spral_lsmr_options {
+   double atol;
+   double btol;
+   double conlim;
+   int ctest;
+   int itnlim;
+   int itn_test;
+   int localSize;
+   int print_freq_head;
+   int print_freq_itn;
+   int unit_diagnostics;
+   int unit_error;
+};
+
+struct spral_lsmr_inform {
+   int flag;
+   int itn;
+   int stat;
+   double normb;
+   double normAP;
+   double condAP;
+   double normr;
+   double normAPr;
+   double normy;
+};
+
+/************************************
+ * Subroutines 
+ ************************************/
+
+/* Initalise options structure to defaults */
+void spral_lsmr_default_options(struct spral_lsmr_options *options);
+/* Solve a least squares problem */
+int spral_lsmr_solve(int *action, int m, int n, double u[], double v[],
+   double y[], void **keep, struct spral_lsmr_options const *options,
+   struct spral_lsmr_inform *inform, double *damp);
+/* Free memory after solution */
+int spral_lsmr_free(void **keep);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_LSMR_H

casadi/include/spral_matrix_util.h

@@ -0,0 +1,40 @@
+#include <stdint.h>
+
+#ifndef SPRAL_MATRIX_UTIL_H
+#define SPRAL_MATRIX_UTIL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Note: At present, interface is only partially defined! */
+
+enum spral_matrix_type {
+   // User doesn't wish to specify, use default behaviour
+   SPRAL_MATRIX_UNSPECIFIED=0,
+   // Rectangular matrix, m!=n
+   SPRAL_MATRIX_REAL_RECT=1,        SPRAL_MATRIX_CPLX_RECT=-1,
+   // Square unsymmetric matrix m==n
+   SPRAL_MATRIX_REAL_UNSYM=2,       SPRAL_MATRIX_CPLX_UNSYM=-2,
+   // Symmetric/Hermitian positive-definite matrix
+   SPRAL_MATRIX_REAL_SYM_PSDEF=3,   SPRAL_MATRIX_CPLX_HERM_PSDEF=-3,
+   // Symmetric/Hermitian indefinite matrix
+   SPRAL_MATRIX_REAL_SYM_INDEF=4,   SPRAL_MATRIX_CPLX_HERM_INDEF=-4,
+   // Complex symmetric matrix
+                                    SPRAL_MATRIX_CPLX_SYM=-5,
+   // Skew-symmetric matrix
+   SPRAL_MATRIX_REAL_SKEW=6,        SPRAL_MATRIX_CPLX_SKEW=-6
+};
+
+void spral_half_to_full_i64d(int n, int64_t *ptr, int *row, double *a, int base);
+void spral_print_matrix(int lines, enum spral_matrix_type matrix_type, int m,
+      int n, const int *ptr, const int *row, const double *val, int base);
+void spral_print_matrix_i64d(int lines, enum spral_matrix_type matrix_type,
+      int m, int n, const int64_t *ptr, const int *row, const double *val,
+      int base);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_MATRIX_UTIL_H

casadi/include/spral_random.h

@@ -0,0 +1,26 @@
+#ifndef SPRAL_RANDOM_H
+#define SPRAL_RANDOM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define SPRAL_RANDOM_INITIAL_SEED 486502
+
+/* Generate a sample from Unif(-1,1) or Unif(0,1) */
+double spral_random_real(int *state, bool positive);
+/* Generate a sample from discrete Unif(1,...,n) */
+int spral_random_integer(int *state, int n);
+/* Generate a sample from discrete Unif(1,...,n) */
+int64_t spral_random_long(int *state, int64_t n);
+/* Generate a sample with equal probability of true or false */
+bool spral_random_logical(int *state);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_RANDOM_H

casadi/include/spral_random_matrix.h

@@ -0,0 +1,27 @@
+#ifndef SPRAL_RANDOM_MATRIX_H
+#define SPRAL_RANDOM_MATRIX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include "spral_matrix_util.h"
+
+#define SPRAL_RANDOM_MATRIX_FINDEX        1
+#define SPRAL_RANDOM_MATRIX_NONSINGULAR   2
+#define SPRAL_RANDOM_MATRIX_SORT          4
+
+/* Generate an m x n random matrix with nnz non-zero entries */
+int spral_random_matrix_generate(int *state, enum spral_matrix_type matrix_type,
+      int m, int n, int nnz, int *ptr, int *row, double *val, int flags);
+/* Generate an m x n random matrix with nnz non-zero entries (nnz,ptr int64_t) */
+int spral_random_matrix_generate_long(int *state,
+      enum spral_matrix_type matrix_type, int m, int n, int64_t nnz, int64_t *ptr,
+      int *row, double *val, int flags);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_RANDOM_MATRIX_H