27 #ifndef CASADI_SPARSITY_INTERNAL_HPP 
   28 #define CASADI_SPARSITY_INTERNAL_HPP 
   30 #include "sparsity.hpp" 
   31 #include "shared_object.hpp" 
   32 #ifdef CASADI_WITH_THREAD 
   33 #ifdef CASADI_WITH_THREAD_MINGW 
   34 #include <mingw.mutex.h> 
   40 #include "filesystem_impl.hpp" 
   46   class CASADI_EXPORT SparsityInternal : 
public SharedObjectInternal {
 
   57     std::vector<casadi_int> sp_;
 
   64       std::vector<casadi_int> rowperm, colperm;
 
   65       std::vector<casadi_int> rowblock, colblock;
 
   66       std::vector<casadi_int> coarse_rowblock, coarse_colblock;
 
   76 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS 
   78     mutable std::mutex btf_mtx_;
 
   83     SparsityInternal(casadi_int nrow, casadi_int ncol,
 
   84                      const casadi_int* colind, 
const casadi_int* row);
 
   87     ~SparsityInternal() 
override;
 
   92     inline const std::vector<casadi_int>& sp()
 const { 
return sp_;}
 
   97     inline casadi_int size1()
 const { 
return sp_[0];}
 
  102     inline casadi_int size2()
 const { 
return sp_[1];}
 
  107     inline const casadi_int* colind()
 const { 
return &sp_.front()+2;}
 
  112     inline const casadi_int* row()
 const { 
return colind()+size2()+1;}
 
  115     inline casadi_int nnz()
 const { 
return colind()[size2()];}
 
  122     Sparsity get_diag(std::vector<casadi_int>& mapping) 
const;
 
  125     bool has_diag() 
const;
 
  128     Sparsity drop_diag() 
const;
 
  137     casadi_int dfs(casadi_int j, casadi_int top, std::vector<casadi_int>& xi,
 
  138                    std::vector<casadi_int>& pstack,
 
  139                    const std::vector<casadi_int>& pinv, std::vector<bool>& marked) 
const;
 
  148     casadi_int scc(std::vector<casadi_int>& p, std::vector<casadi_int>& r) 
const;
 
  157     std::vector<casadi_int> amd() 
const;
 
  169     static void etree(
const casadi_int* sp, casadi_int* parent, casadi_int *w, casadi_int ata);
 
  179     static casadi_int postorder_dfs(casadi_int j, casadi_int k, casadi_int* head,
 
  180         const casadi_int* next, casadi_int* post, casadi_int* stack);
 
  192     static void postorder(
const casadi_int* parent, casadi_int n, casadi_int* post, casadi_int* w);
 
  202     static casadi_int leaf(casadi_int i, casadi_int j, 
const casadi_int* first,
 
  203                     casadi_int* maxfirst,
 
  204                     casadi_int* prevleaf, casadi_int* ancestor, casadi_int* jleaf);
 
  216     static casadi_int qr_counts(
const casadi_int* tr_sp, 
const casadi_int* parent,
 
  217                          const casadi_int* post, casadi_int* counts, casadi_int* w);
 
  230     static casadi_int qr_nnz(
const casadi_int* sp, casadi_int* pinv, casadi_int* leftmost,
 
  231                       const casadi_int* parent, casadi_int* nrow_ext, casadi_int* w);
 
  241     static void qr_init(
const casadi_int* sp, 
const casadi_int* sp_tr,
 
  242                         casadi_int* leftmost, casadi_int* parent, casadi_int* pinv,
 
  243                         casadi_int* nrow_ext, casadi_int* v_nnz, casadi_int* r_nnz, casadi_int* w);
 
  261     static void qr_sparsities(
 
  262                   const casadi_int* sp_a, casadi_int nrow_ext, casadi_int* sp_v, casadi_int* sp_r,
 
  263                   const casadi_int* leftmost, 
const casadi_int* parent, 
const casadi_int* pinv,
 
  278     static void ldl_colind(
const casadi_int* sp, casadi_int* parent,
 
  279       casadi_int* l_colind, casadi_int* w);
 
  291     static void ldl_row(
const casadi_int* sp, 
const casadi_int* parent,
 
  292       casadi_int* l_colind, casadi_int* l_row, casadi_int *w);
 
  302     Sparsity transpose(std::vector<casadi_int>& mapping, 
bool invert_mapping=
false) 
const;
 
  305     bool is_transpose(
const SparsityInternal& y) 
const;
 
  308     bool is_reshape(
const SparsityInternal& y) 
const;
 
  317     void bfs(casadi_int n, std::vector<casadi_int>& wi, std::vector<casadi_int>& wj,
 
  318              std::vector<casadi_int>& queue, 
const std::vector<casadi_int>& imatch,
 
  319              const std::vector<casadi_int>& jmatch, casadi_int mark) 
const;
 
  329       casadi_int n, 
const std::vector<casadi_int>& wj, 
const std::vector<casadi_int>& imatch,
 
  330       std::vector<casadi_int>& p, std::vector<casadi_int>& q, std::vector<casadi_int>& cc,
 
  331       std::vector<casadi_int>& rr, casadi_int set, casadi_int mark);
 
  340     static void unmatched(casadi_int m, 
const std::vector<casadi_int>& wi,
 
  341       std::vector<casadi_int>& p, std::vector<casadi_int>& rr, casadi_int set);
 
  350     static casadi_int rprune(casadi_int i, casadi_int j, 
double aij, 
void *other);
 
  359     static casadi_int drop(casadi_int (*fkeep)(casadi_int, casadi_int, 
double, 
void *), 
void *other,
 
  360                     casadi_int nrow, casadi_int ncol,
 
  361                     std::vector<casadi_int>& colind, std::vector<casadi_int>& row);
 
  364     casadi_int btf(std::vector<casadi_int>& rowperm, std::vector<casadi_int>& colperm,
 
  365                           std::vector<casadi_int>& rowblock, std::vector<casadi_int>& colblock,
 
  366                           std::vector<casadi_int>& coarse_rowblock,
 
  367                           std::vector<casadi_int>& coarse_colblock)
 const {
 
  368       T()->dmperm(colperm, rowperm, colblock, rowblock,
 
  369                   coarse_colblock, coarse_rowblock);
 
  370       return rowblock.size()-1;
 
  374     const Btf& btf() 
const;
 
  383     void dmperm(std::vector<casadi_int>& rowperm, std::vector<casadi_int>& colperm,
 
  384                 std::vector<casadi_int>& rowblock, std::vector<casadi_int>& colblock,
 
  385                 std::vector<casadi_int>& coarse_rowblock,
 
  386                 std::vector<casadi_int>& coarse_colblock) 
const;
 
  395     void maxtrans(std::vector<casadi_int>& imatch,
 
  396                   std::vector<casadi_int>& jmatch, Sparsity& trans, casadi_int seed) 
const;
 
  405     void augment(casadi_int k, std::vector<casadi_int>& jmatch,
 
  406                  casadi_int *cheap, std::vector<casadi_int>& w, casadi_int *js,
 
  407                  casadi_int *is, casadi_int *ps) 
const;
 
  418     static std::vector<casadi_int> randperm(casadi_int n, casadi_int seed);
 
  423     static std::vector<casadi_int> invertPermutation(
const std::vector<casadi_int>& p);
 
  426     Sparsity permute(
const std::vector<casadi_int>& pinv,
 
  427       const std::vector<casadi_int>& q, casadi_int values) 
const;
 
  436     void permute(
const std::vector<casadi_int>& pinv,
 
  437                  const std::vector<casadi_int>& q, casadi_int values,
 
  438                  std::vector<casadi_int>& colind_C,
 
  439                  std::vector<casadi_int>& row_C) 
const;
 
  448     static casadi_int wclear(casadi_int mark, casadi_int lemax, casadi_int *w, casadi_int n);
 
  457     static casadi_int diag(casadi_int i, casadi_int j, 
double aij, 
void *other);
 
  466     Sparsity multiply(
const Sparsity& B) 
const;
 
  475     casadi_int scatter(casadi_int j, std::vector<casadi_int>& w, casadi_int mark,
 
  476                        casadi_int* Ci, casadi_int nz) 
const;
 
  479     std::vector<casadi_int> get_row() 
const;
 
  482     std::vector<casadi_int> get_colind() 
const;
 
  485     std::vector<casadi_int> get_col() 
const;
 
  488     Sparsity _resize(casadi_int nrow, casadi_int ncol) 
const;
 
  491     Sparsity _reshape(casadi_int nrow, casadi_int ncol) 
const;
 
  494     casadi_int numel() 
const;
 
  497     casadi_int nnz_lower(
bool strictly=
false) 
const;
 
  500     casadi_int nnz_upper(
bool strictly=
false) 
const;
 
  503     casadi_int nnz_diag() 
const;
 
  508     casadi_int bw_upper() 
const;
 
  513     casadi_int bw_lower() 
const;
 
  516     std::pair<casadi_int, casadi_int> size() 
const;
 
  519     bool is_scalar(
bool scalar_and_dense) 
const;
 
  527     bool is_empty(
bool both=
false) 
const;
 
  530     bool is_dense() 
const;
 
  540     bool is_column() 
const;
 
  545     bool is_vector() 
const;
 
  548     bool is_diag() 
const;
 
  551     bool is_square() 
const;
 
  556     bool is_permutation() 
const;
 
  561     bool is_selection(
bool allow_empty=
false) 
const;
 
  566     bool is_orthonormal(
bool allow_empty=
false) 
const;
 
  571     bool is_orthonormal_rows(
bool allow_empty=
false) 
const;
 
  576     bool is_orthonormal_columns(
bool allow_empty=
false) 
const;
 
  579     bool is_symmetric() 
const;
 
  582     bool is_tril(
bool strictly) 
const;
 
  585     bool is_triu(
bool strictly) 
const;
 
  588     Sparsity _triu(
bool includeDiagonal) 
const;
 
  591     Sparsity _tril(
bool includeDiagonal) 
const;
 
  594     std::vector<casadi_int> get_lower() 
const;
 
  597     std::vector<casadi_int> get_upper() 
const;
 
  600     std::string dim(
bool with_nz=
false) 
const;
 
  603     std::string repr_el(casadi_int k) 
const;
 
  606     Sparsity _mtimes(
const Sparsity& y) 
const;
 
  610     Sparsity combine(
const Sparsity& y, 
bool f0x_is_zero, 
bool function0_is_zero,
 
  611                             std::vector<unsigned char>& mapping) 
const;
 
  612     Sparsity combine(
const Sparsity& y, 
bool f0x_is_zero, 
bool function0_is_zero) 
const;
 
  614     template<
bool with_mapping>
 
  615     Sparsity combineGen1(
const Sparsity& y, 
bool f0x_is_zero, 
bool function0_is_zero,
 
  616                                 std::vector<unsigned char>& mapping) 
const;
 
  618     template<
bool with_mapping, 
bool f0x_is_zero, 
bool function0_is_zero>
 
  619     Sparsity combineGen(
const Sparsity& y, std::vector<unsigned char>& mapping) 
const;
 
  623     bool is_subset(
const Sparsity& rhs) 
const;
 
  626     Sparsity pattern_inverse() 
const;
 
  629     bool is_equal(
const Sparsity& y) 
const;
 
  632     bool is_equal(casadi_int y_nrow, casadi_int y_ncol, 
const std::vector<casadi_int>& y_colind,
 
  633                  const std::vector<casadi_int>& y_row) 
const;
 
  636     bool is_equal(casadi_int y_nrow, casadi_int y_ncol,
 
  637                   const casadi_int* y_colind, 
const casadi_int* y_row) 
const;
 
  640     bool is_stacked(
const Sparsity& y, casadi_int n) 
const;
 
  643     Sparsity _enlargeRows(casadi_int nrow, 
const std::vector<casadi_int>& rr, 
bool ind1) 
const;
 
  646     Sparsity _enlargeColumns(casadi_int ncol, 
const std::vector<casadi_int>& cc, 
bool ind1) 
const;
 
  649     Sparsity makeDense(std::vector<casadi_int>& mapping) 
const;
 
  652     Sparsity _erase(
const std::vector<casadi_int>& rr, 
const std::vector<casadi_int>& cc,
 
  653                       bool ind1, std::vector<casadi_int>& mapping) 
const;
 
  656     Sparsity _erase(
const std::vector<casadi_int>& rr, 
bool ind1,
 
  657                       std::vector<casadi_int>& mapping) 
const;
 
  660     Sparsity _appendVector(
const SparsityInternal& sp) 
const;
 
  663     Sparsity _appendColumns(
const SparsityInternal& sp) 
const;
 
  671     Sparsity sub(
const std::vector<casadi_int>& rr, 
const std::vector<casadi_int>& cc,
 
  672                  std::vector<casadi_int>& mapping, 
bool ind1) 
const;
 
  680     Sparsity sub(
const std::vector<casadi_int>& rr, 
const SparsityInternal& sp,
 
  681                  std::vector<casadi_int>& mapping, 
bool ind1) 
const;
 
  684     casadi_int get_nz(casadi_int rr, casadi_int cc) 
const;
 
  687     std::vector<casadi_int> get_nz(
const std::vector<casadi_int>& rr,
 
  688                                     const std::vector<casadi_int>& cc) 
const;
 
  691     void get_nz(std::vector<casadi_int>& indices) 
const;
 
  694     bool rowsSequential(
bool strictly) 
const;
 
  702     Sparsity _removeDuplicates(std::vector<casadi_int>& mapping) 
const;
 
  705     void find(std::vector<casadi_int>& loc, 
bool ind1) 
const;
 
  708     std::size_t hash() 
const;
 
  711     std::string class_name()
 const override {
return "SparsityInternal";}
 
  714     void disp(std::ostream& stream, 
bool more) 
const override;
 
  722     Sparsity uni_coloring(
const Sparsity& AT, casadi_int cutoff) 
const;
 
  729     Sparsity star_coloring(casadi_int ordering, casadi_int cutoff) 
const;
 
  736     Sparsity star_coloring2(casadi_int ordering, casadi_int cutoff) 
const;
 
  739     std::vector<casadi_int> largest_first() 
const;
 
  742     Sparsity pmult(
const std::vector<casadi_int>& p, 
bool permute_rows=
true, 
bool permute_cols=
true,
 
  743                    bool invert_permutation=
false) 
const;
 
  748     void spy(std::ostream &stream) 
const;
 
  751     void spy_matlab(
const std::string& mfile) 
const;
 
  756     void export_code(
const std::string& lang, std::ostream &stream,
 
  757        const Dict& options) 
const;
 
  760     void spsolve(bvec_t* X, bvec_t* B, 
bool tr) 
const;
 
GenericType::Dict Dict
C++ equivalent of Python's dict or MATLAB's struct.