Template Class ColumnMatrix

• Defined in File col_matrix.hpp

Inheritance Relationships

Base Type

• public AbstractMatrix (Class AbstractMatrix)

Class Documentation

template<class TC>
class ColumnMatrix : public AbstractMatrix

Public Types

using val_type = typename TC::val_type

using col_type = TC

using tmp_type = typename TC::tmp_type

Public Functions

inline ColumnMatrix()

inline ColumnMatrix(size_t m, size_t n)

inline ColumnMatrix(size_t _m, size_t _n, val_type a)

construct column matrix filled with entry a

inline ColumnMatrix(const std::vector<TC> &_col)

inline ColumnMatrix(size_t _m, size_t _n, const std::vector<TC> &_col)

template<typename TC2>
inline ColumnMatrix(const ColumnMatrix<TC2> &other)

inline ColumnMatrix(const CSCMatrix<int, size_t> &A)

inline void read(std::istream &io)

inline ColumnMatrix(std::istream &io)

inline ColumnMatrix(std::string &fname)

inline size_t nrow() const

inline size_t ncol() const

inline std::vector<TC> &cols()

inline const std::vector<TC> &cols() const

inline void set_nrow(size_t mnew)

inline auto getval(const size_t i, const size_t j) const

inline void permute_rows(const std::vector<size_t> &rowperm)

inline void ipermute_rows(const std::vector<size_t> &rowperm)

template<class ...Ts>
inline void append_column(Ts (&... args))

append a column to the end of the matrix

calls a column vector constructor on arguments passed in.

template<class ...Ts>
inline void append_column(Ts (&&... args))

inline void append_row()

append an empty row to the end of the matrix

template<class ...Ts>
inline void insert_column(const size_t &index, Ts (&&... args))

Do not recommend, because if we want to insert multiple columns, the index will change after the first insertion. Thus the important thing we need to assume is the index list are in ascending order!

inline void append_column()

inline void insert_column(const size_t &index)

inline void insert_columns(const std::vector<size_t> &c_inds, std::vector<TC> &insert_col)

insert list of columns at list of specified indices

mutates input inserted columns

inline void append_row(const std::vector<val_type> &row)

inline void append_sparse_row(const col_type &new_row)

inline void insert_row(const size_t &ind, const std::vector<val_type> &row)

inline void insert_sparse_rows(const std::vector<size_t> &r_inds, const std::vector<col_type> &new_rows)

Insert sparse rows by permutation Input: r_inds: new row indices new_rows: a vector of sparse row vectors

inline void insert_rows(const std::vector<size_t> &r_inds, const std::vector<std::vector<size_t>> &r_col_inds, const std::vector<std::vector<val_type>> &r_col_vals)

inline void insert_row(const size_t &ind)

inline void insert_rows(const std::vector<size_t> &r_inds)

insert zero rows at specified locations

inline void insert_rows(const std::vector<size_t> &r_inds, const std::vector<TC> &rows)

insert rows represented by sparse vectors

inline void erase_column(const size_t &index)

insert zero rows at specified locations new_rows[i] at index r_inds[i]

inline void erase_column()

inline void erase_final_columns(const size_t &ndelete)

deletes ndelete columns at end of matrix

inline void erase_initial_cols(const size_t ndelete)

deletes ndelete columns at beginning of matrix

inline void erase_row(const size_t &index)

erase specified row

inline void erase_row()

erase last row

inline void erase_rows(size_t n_delete_rows)

erase last a few rows

inline void erase_row_unsafe()

assumes that last row is zero so we only need to decrement number of rows

inline void erase_final_rows_unsafe(size_t n_delete_rows)

assumes that last row is zero so we only need to decrement number of rows

inline void erase_initial_rows(size_t ndelete)

erases initial rows

inline TC &operator[](size_t index)

inline const TC &operator[](size_t index) const

inline auto operator()(size_t i, size_t j) const

inline bool operator==(const ColumnMatrix &other) const

inline std::vector<std::vector<val_type>> to_row_array() const

inline val_type *dump_dense() const

inline ColumnMatrix submatrix(const std::vector<size_t> &rind, const std::vector<size_t> &cind) const

inline ColumnMatrix block(const size_t i0, const size_t i1, const size_t j0, const size_t j1) const

inline void set_block(const size_t i0, const size_t i1, const size_t j0, const size_t j1, const ColumnMatrix &B)

inline void clear_rows(const std::vector<bool> &c)

clear rows i for which c[i] is true use vector of bools for quick lookup - vector of inds would require search

inline void clear_cols(const std::vector<bool> &c)

clear columns j for which c[j] is true

frees memory as well

inline void swap_rows(const size_t i, const size_t i2)

inline void mix_rows(const size_t i, const size_t i2, const val_type &a, const val_type &b, const val_type &c, const val_type &d)

inline void add_rows(const size_t i, const val_type &c, const size_t i2)

inline TC gemv(const TC &x) const

inline TC gemv(const TC &x, tmp_type &tmpx) const

inline ColumnMatrix operator*(const val_type a) const

inline TC operator*(const TC &x) const

inline ColumnMatrix operator*(const ColumnMatrix &B) const

inline ColumnMatrix operator+(const ColumnMatrix &B) const

inline ColumnMatrix &operator+=(const ColumnMatrix &B)

inline ColumnMatrix operator-(const ColumnMatrix &B) const

inline ColumnMatrix transpose() const

inline ColumnMatrix T() const

inline void permute_cols(const std::vector<size_t> &colperm)

inline void ipermute_cols(const std::vector<size_t> &colperm)

inline void mix_cols(const size_t j, const size_t k, const val_type &a, const val_type &b, const val_type &c, const val_type &d)

inline void permute(const std::vector<size_t> &rowperm, const std::vector<size_t> &colperm)

inline ColumnMatrix &J_right_inplace()

inline ColumnMatrix J_right() const

inline ColumnMatrix &J_left_inplace()

inline ColumnMatrix J_left() const

inline ColumnMatrix &J_conjugation_inplace()

inline ColumnMatrix J_conjugation() const

inline void swap_cols(size_t j1, size_t j2)

inline void schur_complement(size_t i, size_t j)

inline ColumnMatrix &row_scale(const std::vector<val_type> &coeff)

inline ColumnMatrix &col_inv_scale(const std::vector<val_type> &coeff)

inline size_t nnz() const

inline bool is_zero() const

inline bool is_upper() const

inline bool is_upper_invert() const

inline bool is_lower() const

inline bool is_reduced() const

inline bool is_pivot_matrix() const

inline bool is_EL() const

inline bool is_EU() const

inline bool is_ELhat() const

inline bool is_EUhat() const

inline void print_size() const

inline void print() const

inline void write(std::ostream &io) const

inline std::string str()

inline void save(std::string &fname) const

Public Static Functions

static inline ColumnMatrix identity(size_t n)

static inline ColumnMatrix random(size_t m, size_t n, double p, int maxval, std::default_random_engine &generator)

static inline ColumnMatrix random(size_t m, size_t n, double p, int maxval)

Friends

inline friend TC operator*(const TC &x, const ColumnMatrix &A)

multiplication x^T A

inline friend ColumnMatrix tensor_product(const ColumnMatrix &A, const ColumnMatrix &B)

inline friend ColumnMatrix direct_sum(const ColumnMatrix &A, const ColumnMatrix &B)