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

casadi/include/spral_rutherford_boeing.h

@@ -0,0 +1,51 @@
+#ifndef SPRAL_RUTHERFORD_BOEING_H
+#define SPRAL_RUTHERFORD_BOEING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+struct spral_rb_read_options {
+   int array_base;
+   bool add_diagonal;
+   float extra_space;
+   int lwr_upr_full;
+   int values;
+};
+
+struct spral_rb_write_options {
+   int array_base;
+   char val_format[21];
+};
+
+void spral_rb_default_read_options(struct spral_rb_read_options *options);
+void spral_rb_default_write_options(struct spral_rb_write_options *options);
+int spral_rb_peek(const char *filename, int *m, int *n, int64_t *nelt, int64_t *nvar,
+      int64_t *nval, enum spral_matrix_type *matrix_type, char *type_code,
+      char *title, char *identifier);
+int spral_rb_read(const char *filename, void **handle,
+      enum spral_matrix_type *matrix_type, int *m, int *n, int64_t **ptr,
+      int **row, double **val, const struct spral_rb_read_options *options,
+      char *title, char *identifier, int *state);
+int spral_rb_read_ptr32(const char *filename, void **handle,
+      enum spral_matrix_type *matrix_type, int *m, int *n, int **ptr,
+      int **row, double **val, const struct spral_rb_read_options *options,
+      char *title, char *identifier, int *state);
+int spral_rb_write(const char *filename, enum spral_matrix_type matrix_type,
+      int m, int n, const int64_t *ptr, const int *row, const double * val,
+      const struct spral_rb_write_options *options, const char *title,
+      const char *identifier);
+int spral_rb_write_ptr32(const char *filename,
+      enum spral_matrix_type matrix_type,
+      int m, int n, const int *ptr, const int *row, const double * val,
+      const struct spral_rb_write_options *options, const char *title,
+      const char *identifier);
+void spral_rb_free_handle(void **handle);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_RUTHERFORD_BOEING_H

casadi/include/spral_scaling.h

@@ -0,0 +1,139 @@
+#ifndef SPRAL_SCALING_H
+#define SPRAL_SCALING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/************************************
+ * Derived types
+ ************************************/
+
+struct spral_scaling_auction_options {
+   int array_base; // Not in Fortran type
+   int max_iterations;
+   int max_unchanged[3];
+   float min_proportion[3];
+   float eps_initial;
+   char unused[80]; // Allow for future expansion
+};
+struct spral_scaling_auction_inform {
+   int flag;
+   int stat;
+   int matched;
+   int iterations;
+   int unmatchable;
+   char unused[80]; // Allow for future expansion
+};
+
+struct spral_scaling_equilib_options {
+   int array_base; // Not in Fortran type
+   int max_iterations;
+   float tol;
+   char unused[80]; // Allow for future expansion
+};
+struct spral_scaling_equilib_inform {
+   int flag;
+   int stat;
+   int iterations;
+   char unused[80]; // Allow for future expansion
+};
+
+struct spral_scaling_hungarian_options {
+   int array_base; // Not in Fortran type
+   bool scale_if_singular;
+   char unused[80]; // Allow for future expansion
+};
+struct spral_scaling_hungarian_inform {
+   int flag;
+   int stat;
+   int matched;
+   char unused[80]; // Allow for future expansion
+};
+
+/************************************
+ * Default setting subroutines
+ ************************************/
+
+/* Set default values for auction_options */
+void spral_scaling_auction_default_options(
+      struct spral_scaling_auction_options *options);
+/* Set default values for equilib_options */
+void spral_scaling_equilib_default_options(
+      struct spral_scaling_equilib_options *options);
+/* Set default values for hungarian_options */
+void spral_scaling_hungarian_default_options(
+      struct spral_scaling_hungarian_options *options);
+
+/************************************
+ * Symmetric subroutines
+ ************************************/
+
+/* Scale a symmetric matrix using auction algorithm */
+void spral_scaling_auction_sym(int n, const int *ptr, const int *row,
+      const double *val, double *scaling, int *match,
+      const struct spral_scaling_auction_options *options,
+      struct spral_scaling_auction_inform *inform);
+void spral_scaling_auction_sym_long(int n, const int64_t *ptr, const int *row,
+      const double *val, double *scaling, int *match,
+      const struct spral_scaling_auction_options *options,
+      struct spral_scaling_auction_inform *inform);
+/* Scale a symmetric matrix using norm equilibriation algorithm */
+void spral_scaling_equilib_sym(int n, const int *ptr, const int *row,
+      const double *val, double *scaling,
+      const struct spral_scaling_equilib_options *options,
+      struct spral_scaling_equilib_inform *inform);
+void spral_scaling_equilib_sym_long(int n, const int64_t *ptr, const int *row,
+      const double *val, double *scaling,
+      const struct spral_scaling_equilib_options *options,
+      struct spral_scaling_equilib_inform *inform);
+/* Scale a symmetric matrix using Hungarian algorithm */
+void spral_scaling_hungarian_sym(int n, const int *ptr, const int *row,
+      const double *val, double *scaling, int *match,
+      const struct spral_scaling_hungarian_options *options,
+      struct spral_scaling_hungarian_inform *inform);
+void spral_scaling_hungarian_sym_long(int n, const int64_t *ptr, const int *row,
+      const double *val, double *scaling, int *match,
+      const struct spral_scaling_hungarian_options *options,
+      struct spral_scaling_hungarian_inform *inform);
+
+/************************************
+ * Unsymmetric subroutines
+ ************************************/
+
+/* Scale a symmetric matrix using auction algorithm */
+void spral_scaling_auction_unsym(int m, int n, const int *ptr,
+      const int *row, const double *val, double *rscaling, double *cscaling,
+      int *match, const struct spral_scaling_auction_options *options,
+      struct spral_scaling_auction_inform *inform);
+void spral_scaling_auction_unsym_long(int m, int n, const int64_t *ptr,
+      const int *row, const double *val, double *rscaling, double *cscaling,
+      int *match, const struct spral_scaling_auction_options *options,
+      struct spral_scaling_auction_inform *inform);
+/* Scale a symmetric matrix using norm equilibriation algorithm */
+void spral_scaling_equilib_unsym(int m, int n, const int *ptr,
+      const int *row, const double *val, double *rscaling, double *cscaling,
+      const struct spral_scaling_equilib_options *options,
+      struct spral_scaling_equilib_inform *inform);
+void spral_scaling_equilib_unsym_long(int m, int n, const int64_t *ptr,
+      const int *row, const double *val, double *rscaling, double *cscaling,
+      const struct spral_scaling_equilib_options *options,
+      struct spral_scaling_equilib_inform *inform);
+/* Scale a symmetric matrix using Hungarian algorithm */
+void spral_scaling_hungarian_unsym(int m, int n, const int *ptr,
+      const int *row, const double *val, double *rscaling, double *cscaling,
+      int *match, const struct spral_scaling_hungarian_options *options,
+      struct spral_scaling_hungarian_inform *inform);
+void spral_scaling_hungarian_unsym_long(int m, int n, const int64_t *ptr,
+      const int *row, const double *val, double *rscaling, double *cscaling,
+      int *match, const struct spral_scaling_hungarian_options *options,
+      struct spral_scaling_hungarian_inform *inform);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_SCALING_H

casadi/include/spral_ssids.h

@@ -0,0 +1,121 @@
+#ifndef SPRAL_SSIDS_H
+#define SPRAL_SSIDS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/************************************
+ * Derived types
+ ************************************/
+
+struct spral_ssids_options {
+   int array_base; // Not in Fortran type
+   int print_level;
+   int unit_diagnostics;
+   int unit_error;
+   int unit_warning;
+   int ordering;
+   int nemin;
+   bool ignore_numa;
+   bool use_gpu;
+   int64_t min_gpu_work;
+   float max_load_inbalance;
+   float gpu_perf_coeff;
+   int scaling;
+   int64_t small_subtree_threshold;
+   int cpu_block_size;
+   bool action;
+   int pivot_method;
+   double small;
+   double u;
+   char unused[80]; // Allow for future expansion
+};
+
+struct spral_ssids_inform {
+   int flag;
+   int matrix_dup;
+   int matrix_missing_diag;
+   int matrix_outrange;
+   int matrix_rank;
+   int maxdepth;
+   int maxfront;
+   int num_delay;
+   int64_t num_factor;
+   int64_t num_flops;
+   int num_neg;
+   int num_sup;
+   int num_two;
+   int stat;
+   int cuda_error;
+   int cublas_error;
+   char unused[80]; // Allow for future expansion
+};
+
+/************************************
+ * Basic subroutines
+ ************************************/
+
+/* Initialize options to defaults */
+void spral_ssids_default_options(struct spral_ssids_options *options);
+/* Perform analysis phase for CSC data */
+void spral_ssids_analyse(bool check, int n, int *order, const int64_t *ptr,
+      const int *row, const double *val, void **akeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+void spral_ssids_analyse_ptr32(bool check, int n, int *order, const int *ptr,
+      const int *row, const double *val, void **akeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+/* Perform analysis phase for coordinate data */
+void spral_ssids_analyse_coord(int n, int *order, int64_t ne, const int *row,
+      const int *col, const double *val, void **akeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+/* Perform numerical factorization */
+void spral_ssids_factor(bool posdef, const int64_t *ptr, const int *row,
+      const double *val, double *scale, void *akeep, void **fkeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+void spral_ssids_factor_ptr32(bool posdef, const int *ptr, const int *row,
+      const double *val, double *scale, void *akeep, void **fkeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+/* Perform triangular solve(s) for single rhs */
+void spral_ssids_solve1(int job, double *x1, void *akeep, void *fkeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+/* Perform triangular solve(s) for one or more rhs */
+void spral_ssids_solve(int job, int nrhs, double *x, int ldx, void *akeep,
+      void *fkeep, const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+/* Free memory */
+int spral_ssids_free_akeep(void **akeep);
+int spral_ssids_free_fkeep(void **fkeep);
+int spral_ssids_free(void **akeep, void **fkeep);
+
+/************************************
+ * Advanced subroutines
+ ************************************/
+
+/* Retrieve information on pivots (positive-definite case) */
+void spral_ssids_enquire_posdef(const void *akeep, const void *fkeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform, double *d);
+/* Retrieve information on pivots (indefinite case) */
+void spral_ssids_enquire_indef(const void *akeep, const void *fkeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform, int *piv_order, double *d);
+/* Alter pivots (indefinite case only) */
+void spral_ssids_alter(const double *d, const void *akeep, void *fkeep,
+      const struct spral_ssids_options *options,
+      struct spral_ssids_inform *inform);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_SSIDS_H

casadi/include/spral_ssmfe.h

@@ -0,0 +1,268 @@
+#ifndef SPRAL_SSMFE_H
+#define SPRAL_SSMFE_H
+
+#include <stdbool.h>
+
+// Define complex types that work with both C and C++
+#include "spral_complex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/************************************
+ * Derived types
+ ************************************/
+
+struct spral_ssmfe_rcid {
+   int job;
+   int nx;
+   int jx;
+   int kx;
+   int ny;
+   int jy;
+   int ky;
+   int i;
+   int j;
+   int k;
+   double alpha;
+   double beta;
+   double *x;
+   double *y;
+   char unused[80]; // Allow for future expansion
+};
+
+struct spral_ssmfe_rciz {
+   int job;
+   int nx;
+   int jx;
+   int kx;
+   int ny;
+   int jy;
+   int ky;
+   int i;
+   int j;
+   int k;
+   spral_double_complex alpha;
+   spral_double_complex beta;
+   spral_double_complex *x;
+   spral_double_complex *y;
+   char unused[80]; // Allow for future expansion
+};
+
+struct spral_ssmfe_core_options {
+   int array_base; // Not in Fortran type
+   double cf_max;
+   int err_est;
+   int extra_left;
+   int extra_right;
+   double min_gap;
+   bool minAprod;
+   bool minBprod;
+   char unused[80]; // Allow for future expansion
+};
+
+struct spral_ssmfe_options {
+   int array_base;
+   int print_level;
+   int unit_error;
+   int unit_warning;
+   int unit_diagnostic;
+   int max_iterations;
+   int user_x;
+   int err_est;
+   double abs_tol_lambda;
+   double rel_tol_lambda;
+   double abs_tol_residual;
+   double rel_tol_residual;
+   double tol_x;
+   double left_gap;
+   double right_gap;
+   int extra_left;
+   int extra_right;
+   int max_left;
+   int max_right;
+   bool minAprod;
+   bool minBprod;
+};
+
+struct spral_ssmfe_inform {
+   int flag;
+   int stat;
+   int non_converged;
+   int iteration;
+   int left;
+   int right;
+   int *converged;
+   double next_left;
+   double next_right;
+   double *residual_norms;
+   double *err_lambda;
+   double *err_X;
+   char unused[80]; // Allow for future expansion
+};
+
+/************************************
+ * SSMFE subroutines 
+ ************************************/
+
+/* Initialize options to defaults */
+void spral_ssmfe_default_options(struct spral_ssmfe_options *options);
+/* Leftmost real eigenpairs of std eigenvalue problem */
+void spral_ssmfe_standard_double(struct spral_ssmfe_rcid *rci, int left,
+      int mep, double *lambda, int n, double *x, int ldx,
+      void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Leftmost complex eigenpairs of std eigenvalue problem */
+void spral_ssmfe_standard_double_complex(struct spral_ssmfe_rciz *rci,
+      int left, int mep, double *lambda, int n, spral_double_complex *x,
+      int ldx, void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Real eigenpairs around shift for std eigenvalue problem */
+void spral_ssmfe_standard_shift_double(struct spral_ssmfe_rcid *rci,
+      double sigma, int left, int right, int mep, double *lambda, int n,
+      double *x, int ldx, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Complex eigenpairs around shift for std eigenvalue problem */
+void spral_ssmfe_standard_shift_double_complex(
+      struct spral_ssmfe_rciz *rci, double sigma, int left, int right, int mep,
+      double *lambda, int n, spral_double_complex *x, int ldx, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Leftmost real eigenpairs of generalized eigenvalue problem */
+void spral_ssmfe_generalized_double(struct spral_ssmfe_rcid *rci,
+      int left, int mep, double *lambda, int n, double *x, int ldx,
+      void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Leftmost complex eigenpairs of generalized eigenvalue problem */
+void spral_ssmfe_generalized_double_complex(struct spral_ssmfe_rciz *rci,
+      int left, int mep, double *lambda, int n, spral_double_complex *x,
+      int ldx, void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Real eigenpairs around shift for generalized eigenvalue problem */
+void spral_ssmfe_generalized_shift_double(struct spral_ssmfe_rcid *rci,
+      double sigma, int left, int right, int mep, double *lambda, int n,
+      double *x, int ldx, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Complex eigenpairs around shift for generalized eigenvalue problem */
+void spral_ssmfe_generalized_shift_double_complex(
+      struct spral_ssmfe_rciz *rci, double sigma, int left, int right, int mep,
+      double *lambda, int n, spral_double_complex *x, int ldx, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Real eigenpairs around shift for buckling problem */
+void spral_ssmfe_buckling_double(struct spral_ssmfe_rcid *rci,
+      double sigma, int left, int right, int mep, double *lambda, int n,
+      double *x, int ldx, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Complex eigenpairs around shift for buckling problem */
+void spral_ssmfe_buckling_double_complex(struct spral_ssmfe_rciz *rci,
+      double sigma, int left, int right, int mep, double *lambda, int n,
+      spral_double_complex *x, int ldx, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Free memory (real) */
+void spral_ssmfe_free_double(void **keep, struct spral_ssmfe_inform *inform);
+/* Free memory (complex) */
+void spral_ssmfe_free_double_complex(void **keep, struct spral_ssmfe_inform *inform);
+
+/************************************
+ * SSMFE_EXPERT subroutines (additional to those shared with SSMFE)
+ ************************************/
+
+/* Leftmost real eigenpairs of std eigenvalue problem */
+void spral_ssmfe_expert_standard_double(struct spral_ssmfe_rcid *rci, int left,
+      int mep, double *lambda, int m, double *rr, int *ind,
+      void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Leftmost complex eigenpairs of std eigenvalue problem */
+void spral_ssmfe_expert_standard_double_complex(struct spral_ssmfe_rciz *rci,
+      int left, int mep, double *lambda, int m, spral_double_complex *rr,
+      int *ind, void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Real eigenpairs around shift for std eigenvalue problem */
+void spral_ssmfe_expert_standard_shift_double(struct spral_ssmfe_rcid *rci,
+      double sigma, int left, int right, int mep, double *lambda, int m,
+      double *rr, int *ind, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Complex eigenpairs around shift for std eigenvalue problem */
+void spral_ssmfe_expert_standard_shift_double_complex(
+      struct spral_ssmfe_rciz *rci, double sigma, int left, int right, int mep,
+      double *lambda, int m, spral_double_complex *rr, int *ind, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Leftmost real eigenpairs of generalized eigenvalue problem */
+void spral_ssmfe_expert_generalized_double(struct spral_ssmfe_rcid *rci,
+      int left, int mep, double *lambda, int m, double *rr, int *ind,
+      void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Leftmost complex eigenpairs of generalized eigenvalue problem */
+void spral_ssmfe_expert_generalized_double_complex(struct spral_ssmfe_rciz *rci,
+      int left, int mep, double *lambda, int m, spral_double_complex *rr,
+      int *ind, void **keep, const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Real eigenpairs around shift for generalized eigenvalue problem */
+void spral_ssmfe_expert_generalized_shift_double(struct spral_ssmfe_rcid *rci,
+      double sigma, int left, int right, int mep, double *lambda, int m,
+      double *rr, int *ind, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Complex eigenpairs around shift for generalized eigenvalue problem */
+void spral_ssmfe_expert_generalized_shift_double_complex(
+      struct spral_ssmfe_rciz *rci, double sigma, int left, int right, int mep,
+      double *lambda, int m, spral_double_complex *rr, int *ind, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Real eigenpairs around shift for buckling problem */
+void spral_ssmfe_expert_buckling_double(struct spral_ssmfe_rcid *rci,
+      double sigma, int left, int right, int mep, double *lambda, int m,
+      double *rr, int *ind, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Complex eigenpairs around shift for buckling problem */
+void spral_ssmfe_expert_buckling_double_complex(struct spral_ssmfe_rciz *rci,
+      double sigma, int left, int right, int mep, double *lambda, int m,
+      spral_double_complex *rr, int *ind, void **keep,
+      const struct spral_ssmfe_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Free memory */
+void spral_ssmfe_expert_free(void **keep, struct spral_ssmfe_inform *inform);
+
+/************************************
+ * SSMFE_CORE subroutines 
+ ************************************/
+
+/* Initialize options to defaults */
+void spral_ssmfe_core_default_options(struct spral_ssmfe_core_options *options);
+/* Core driver routine for left and right values of (real) eigenproblems */
+void spral_ssmfe_double(struct spral_ssmfe_rcid *rci, int problem,
+      int left, int right, int m, double *lambda, double *rr, int *ind,
+      void **keep, const struct spral_ssmfe_core_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Core driver routine for left and right values of (complex) eigenproblems */
+void spral_ssmfe_double_complex(struct spral_ssmfe_rciz *rci, int problem,
+      int left, int right, int m, double *lambda, spral_double_complex *rr,
+      int *ind, void **keep, const struct spral_ssmfe_core_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Core driver routine for largest values of (real) eigenproblems */
+void spral_ssmfe_largest_double(struct spral_ssmfe_rcid *rci, int problem,
+      int nep, int m, double *lambda, double *rr, int *ind,
+      void **keep, const struct spral_ssmfe_core_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Core driver routine for largest values of (complex) eigenproblems */
+void spral_ssmfe_largest_double_complex(struct spral_ssmfe_rciz *rci,
+      int problem, int nep, int m, double *lambda, spral_double_complex *rr,
+      int *ind, void **keep, const struct spral_ssmfe_core_options *options,
+      struct spral_ssmfe_inform *inform);
+/* Free memory */
+void spral_ssmfe_core_free(void **keep, struct spral_ssmfe_inform *inform);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif // SPRAL_SSMFE_H