sparsity_internal.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *    Copyright (C) 2005-2013 Timothy A. Davis
 *
 *    CasADi is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_SPARSITY_INTERNAL_HPP
#define CASADI_SPARSITY_INTERNAL_HPP
 
#include "sparsity.hpp"
#include "shared_object.hpp"
#ifdef CASADI_WITH_THREAD
#ifdef CASADI_WITH_THREAD_MINGW
#include <mingw.mutex.h>
#else // CASADI_WITH_THREAD_MINGW
#include <mutex>
#endif // CASADI_WITH_THREAD_MINGW
#endif //CASADI_WITH_THREAD
 
#include "filesystem_impl.hpp"
 
 
namespace casadi {
 
  class CASADI_EXPORT SparsityInternal : public SharedObjectInternal {
  private:
    std::vector<casadi_int> sp_;
 
    struct Btf {
      casadi_int nb;
      std::vector<casadi_int> rowperm, colperm;
      std::vector<casadi_int> rowblock, colblock;
      std::vector<casadi_int> coarse_rowblock, coarse_colblock;
    };
 
    mutable Btf* btf_;
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    mutable std::mutex btf_mtx_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
  public:
    SparsityInternal(casadi_int nrow, casadi_int ncol,
                     const casadi_int* colind, const casadi_int* row);
 
    ~SparsityInternal() override;
 
    inline const std::vector<casadi_int>& sp() const { return sp_;}
 
    inline casadi_int size1() const { return sp_[0];}
 
    inline casadi_int size2() const { return sp_[1];}
 
    inline const casadi_int* colind() const { return &sp_.front()+2;}
 
    inline const casadi_int* row() const { return colind()+size2()+1;}
 
    inline casadi_int nnz() const { return colind()[size2()];}
 
    Sparsity get_diag(std::vector<casadi_int>& mapping) const;
 
    bool has_diag() const;
 
    Sparsity drop_diag() const;
 
    casadi_int dfs(casadi_int j, casadi_int top, std::vector<casadi_int>& xi,
                   std::vector<casadi_int>& pstack,
                   const std::vector<casadi_int>& pinv, std::vector<bool>& marked) const;
 
    casadi_int scc(std::vector<casadi_int>& p, std::vector<casadi_int>& r) const;
 
    std::vector<casadi_int> amd() const;
 
    static void etree(const casadi_int* sp, casadi_int* parent, casadi_int *w, casadi_int ata);
 
    static casadi_int postorder_dfs(casadi_int j, casadi_int k, casadi_int* head,
        const casadi_int* next, casadi_int* post, casadi_int* stack);
 
    static void postorder(const casadi_int* parent, casadi_int n, casadi_int* post, casadi_int* w);
 
    static casadi_int leaf(casadi_int i, casadi_int j, const casadi_int* first,
                    casadi_int* maxfirst,
                    casadi_int* prevleaf, casadi_int* ancestor, casadi_int* jleaf);
 
    static casadi_int qr_counts(const casadi_int* tr_sp, const casadi_int* parent,
                         const casadi_int* post, casadi_int* counts, casadi_int* w);
 
    static casadi_int qr_nnz(const casadi_int* sp, casadi_int* pinv, casadi_int* leftmost,
                      const casadi_int* parent, casadi_int* nrow_ext, casadi_int* w);
 
    static void qr_init(const casadi_int* sp, const casadi_int* sp_tr,
                        casadi_int* leftmost, casadi_int* parent, casadi_int* pinv,
                        casadi_int* nrow_ext, casadi_int* v_nnz, casadi_int* r_nnz, casadi_int* w);
 
    static void qr_sparsities(
                  const casadi_int* sp_a, casadi_int nrow_ext, casadi_int* sp_v, casadi_int* sp_r,
                  const casadi_int* leftmost, const casadi_int* parent, const casadi_int* pinv,
                  casadi_int* iw);
 
    static void ldl_colind(const casadi_int* sp, casadi_int* parent,
      casadi_int* l_colind, casadi_int* w);
 
    static void ldl_row(const casadi_int* sp, const casadi_int* parent,
      casadi_int* l_colind, casadi_int* l_row, casadi_int *w);
 
    Sparsity T() const;
 
    Sparsity transpose(std::vector<casadi_int>& mapping, bool invert_mapping=false) const;
 
    bool is_transpose(const SparsityInternal& y) const;
 
    bool is_reshape(const SparsityInternal& y) const;
 
    void bfs(casadi_int n, std::vector<casadi_int>& wi, std::vector<casadi_int>& wj,
             std::vector<casadi_int>& queue, const std::vector<casadi_int>& imatch,
             const std::vector<casadi_int>& jmatch, casadi_int mark) const;
 
    static void matched(
      casadi_int n, const std::vector<casadi_int>& wj, const std::vector<casadi_int>& imatch,
      std::vector<casadi_int>& p, std::vector<casadi_int>& q, std::vector<casadi_int>& cc,
      std::vector<casadi_int>& rr, casadi_int set, casadi_int mark);
 
    static void unmatched(casadi_int m, const std::vector<casadi_int>& wi,
      std::vector<casadi_int>& p, std::vector<casadi_int>& rr, casadi_int set);
 
    static casadi_int rprune(casadi_int i, casadi_int j, double aij, void *other);
 
    static casadi_int drop(casadi_int (*fkeep)(casadi_int, casadi_int, double, void *), void *other,
                    casadi_int nrow, casadi_int ncol,
                    std::vector<casadi_int>& colind, std::vector<casadi_int>& row);
 
    casadi_int btf(std::vector<casadi_int>& rowperm, std::vector<casadi_int>& colperm,
                          std::vector<casadi_int>& rowblock, std::vector<casadi_int>& colblock,
                          std::vector<casadi_int>& coarse_rowblock,
                          std::vector<casadi_int>& coarse_colblock) const {
      T()->dmperm(colperm, rowperm, colblock, rowblock,
                  coarse_colblock, coarse_rowblock);
      return rowblock.size()-1;
    }
 
    const Btf& btf() const;
 
    void dmperm(std::vector<casadi_int>& rowperm, std::vector<casadi_int>& colperm,
                std::vector<casadi_int>& rowblock, std::vector<casadi_int>& colblock,
                std::vector<casadi_int>& coarse_rowblock,
                std::vector<casadi_int>& coarse_colblock) const;
 
    void maxtrans(std::vector<casadi_int>& imatch,
                  std::vector<casadi_int>& jmatch, Sparsity& trans, casadi_int seed) const;
 
    void augment(casadi_int k, std::vector<casadi_int>& jmatch,
                 casadi_int *cheap, std::vector<casadi_int>& w, casadi_int *js,
                 casadi_int *is, casadi_int *ps) const;
 
    static std::vector<casadi_int> randperm(casadi_int n, casadi_int seed);
 
    static std::vector<casadi_int> invertPermutation(const std::vector<casadi_int>& p);
 
    Sparsity permute(const std::vector<casadi_int>& pinv,
      const std::vector<casadi_int>& q, casadi_int values) const;
 
    void permute(const std::vector<casadi_int>& pinv,
                 const std::vector<casadi_int>& q, casadi_int values,
                 std::vector<casadi_int>& colind_C,
                 std::vector<casadi_int>& row_C) const;
 
    static casadi_int wclear(casadi_int mark, casadi_int lemax, casadi_int *w, casadi_int n);
 
    static casadi_int diag(casadi_int i, casadi_int j, double aij, void *other);
 
    Sparsity multiply(const Sparsity& B) const;
 
    casadi_int scatter(casadi_int j, std::vector<casadi_int>& w, casadi_int mark,
                       casadi_int* Ci, casadi_int nz) const;
 
    std::vector<casadi_int> get_row() const;
 
    std::vector<casadi_int> get_colind() const;
 
    std::vector<casadi_int> get_col() const;
 
    Sparsity _resize(casadi_int nrow, casadi_int ncol) const;
 
    Sparsity _reshape(casadi_int nrow, casadi_int ncol) const;
 
    casadi_int numel() const;
 
    casadi_int nnz_lower(bool strictly=false) const;
 
    casadi_int nnz_upper(bool strictly=false) const;
 
    casadi_int nnz_diag() const;
 
    casadi_int bw_upper() const;
 
    casadi_int bw_lower() const;
 
    std::pair<casadi_int, casadi_int> size() const;
 
    bool is_scalar(bool scalar_and_dense) const;
 
    bool is_empty(bool both=false) const;
 
    bool is_dense() const;
 
    bool is_row() const;
 
    bool is_column() const;
 
    bool is_vector() const;
 
    bool is_diag() const;
 
    bool is_square() const;
 
    bool is_permutation() const;
 
    bool is_selection(bool allow_empty=false) const;
 
    bool is_orthonormal(bool allow_empty=false) const;
 
    bool is_orthonormal_rows(bool allow_empty=false) const;
 
    bool is_orthonormal_columns(bool allow_empty=false) const;
 
    bool is_symmetric() const;
 
    bool is_tril(bool strictly) const;
 
    bool is_triu(bool strictly) const;
 
    Sparsity _triu(bool includeDiagonal) const;
 
    Sparsity _tril(bool includeDiagonal) const;
 
    std::vector<casadi_int> get_lower() const;
 
    std::vector<casadi_int> get_upper() const;
 
    std::string dim(bool with_nz=false) const;
 
    std::string repr_el(casadi_int k) const;
 
    Sparsity _mtimes(const Sparsity& y) const;
 
    Sparsity combine(const Sparsity& y, bool f0x_is_zero, bool function0_is_zero,
                            std::vector<unsigned char>& mapping) const;
    Sparsity combine(const Sparsity& y, bool f0x_is_zero, bool function0_is_zero) const;
 
    template<bool with_mapping>
    Sparsity combineGen1(const Sparsity& y, bool f0x_is_zero, bool function0_is_zero,
                                std::vector<unsigned char>& mapping) const;
 
    template<bool with_mapping, bool f0x_is_zero, bool function0_is_zero>
    Sparsity combineGen(const Sparsity& y, std::vector<unsigned char>& mapping) const;
 
    bool is_subset(const Sparsity& rhs) const;
 
    Sparsity pattern_inverse() const;
 
    bool is_equal(const Sparsity& y) const;
 
    bool is_equal(casadi_int y_nrow, casadi_int y_ncol, const std::vector<casadi_int>& y_colind,
                 const std::vector<casadi_int>& y_row) const;
 
    bool is_equal(casadi_int y_nrow, casadi_int y_ncol,
                  const casadi_int* y_colind, const casadi_int* y_row) const;
 
    bool is_stacked(const Sparsity& y, casadi_int n) const;
 
    Sparsity _enlargeRows(casadi_int nrow, const std::vector<casadi_int>& rr, bool ind1) const;
 
    Sparsity _enlargeColumns(casadi_int ncol, const std::vector<casadi_int>& cc, bool ind1) const;
 
    Sparsity makeDense(std::vector<casadi_int>& mapping) const;
 
    Sparsity _erase(const std::vector<casadi_int>& rr, const std::vector<casadi_int>& cc,
                      bool ind1, std::vector<casadi_int>& mapping) const;
 
    Sparsity _erase(const std::vector<casadi_int>& rr, bool ind1,
                      std::vector<casadi_int>& mapping) const;
 
    Sparsity _appendVector(const SparsityInternal& sp) const;
 
    Sparsity _appendColumns(const SparsityInternal& sp) const;
 
    Sparsity sub(const std::vector<casadi_int>& rr, const std::vector<casadi_int>& cc,
                 std::vector<casadi_int>& mapping, bool ind1) const;
 
    Sparsity sub(const std::vector<casadi_int>& rr, const SparsityInternal& sp,
                 std::vector<casadi_int>& mapping, bool ind1) const;
 
    casadi_int get_nz(casadi_int rr, casadi_int cc) const;
 
    std::vector<casadi_int> get_nz(const std::vector<casadi_int>& rr,
                                    const std::vector<casadi_int>& cc) const;
 
    void get_nz(std::vector<casadi_int>& indices) const;
 
    bool rowsSequential(bool strictly) const;
 
    Sparsity _removeDuplicates(std::vector<casadi_int>& mapping) const;
 
    void find(std::vector<casadi_int>& loc, bool ind1) const;
 
    std::size_t hash() const;
 
    std::string class_name() const override {return "SparsityInternal";}
 
    void disp(std::ostream& stream, bool more) const override;
 
    Sparsity uni_coloring(const Sparsity& AT, casadi_int cutoff) const;
 
    Sparsity star_coloring(casadi_int ordering, casadi_int cutoff) const;
 
    Sparsity star_coloring2(casadi_int ordering, casadi_int cutoff) const;
 
    std::vector<casadi_int> largest_first() const;
 
    Sparsity pmult(const std::vector<casadi_int>& p, bool permute_rows=true, bool permute_cols=true,
                   bool invert_permutation=false) const;
 
    void spy(std::ostream &stream) const;
 
    void spy_matlab(const std::string& mfile) const;
 
    void export_code(const std::string& lang, std::ostream &stream,
       const Dict& options) const;
 
    void spsolve(bvec_t* X, bvec_t* B, bool tr) const;
};
 
} // namespace casadi
 
#endif // CASADI_SPARSITY_INTERNAL_HPP