matpackII.h

Go to the documentation of this file.

/* Copyright (C) 2001-2016
   Stefan Buehler <sbuehler@ltu.se>
   Mattias Ekstroem <ekstrom@rss.chalmers.se>
   Simon Pfreundschuh <simonpf@chalmers.se>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */
 
#ifndef matpackII_h
#define matpackII_h
 
#include <iostream>
#include "Eigen/Core"
#include "Eigen/SparseCore"
#include "array.h"
#include "matpackI.h"
 
 
class Sparse {
 public:
  // Constructors:
  Sparse();
  Sparse(Index r, Index c);
 
  void split(Index offset, Index nrows);
 
  // Insert functions
  void insert_row(Index r, Vector v);
  void insert_elements(Index nnz,
                       const ArrayOfIndex& rowind,
                       const ArrayOfIndex& colind,
                       ConstVectorView data);
 
  // Resize function:
  void resize(Index r, Index c);
 
  // Member functions:
  bool empty() const;
  Index nrows() const;
  Index ncols() const;
  Index nnz() const;
 
  static Sparse diagonal(ConstVectorView v);
 
  Vector diagonal() const;
 
  // Index Operators:
  Numeric& rw(Index r, Index c);
  Numeric ro(Index r, Index c) const;
  Numeric operator()(Index r, Index c) const;
 
  // Arithmetic operators:
  Sparse& operator+=(const Sparse& x);
  Sparse& operator-=(const Sparse& x);
 
  // Scaling operators:
  Sparse& operator*=(Numeric x);
  Sparse& operator/=(Numeric x);
 
  // Conversion to Dense Matrix:
  explicit operator Matrix() const;
 
  // Matrix data access
  void list_elements(Vector& values,
                     ArrayOfIndex& row_indices,
                     ArrayOfIndex& column_indices) const;
 
  Numeric* get_element_pointer() { return matrix.valuePtr(); }
  int* get_column_index_pointer() { return matrix.innerIndexPtr(); }
  int* get_row_start_pointer() { return matrix.outerIndexPtr(); }
 
  // Friends:
  friend std::ostream& operator<<(std::ostream& os, const Sparse& v);
  friend void abs(Sparse& A, const Sparse& B);
  friend void mult(VectorView y, const Sparse& M, ConstVectorView x);
  friend void transpose_mult(VectorView y, const Sparse& M, ConstVectorView x);
  friend void mult(MatrixView A, const Sparse& B, const ConstMatrixView& C);
  friend void mult(MatrixView A, const ConstMatrixView& B, const Sparse& C);
  friend void mult(Sparse& A, const Sparse& B, const Sparse& C);
  friend void add(Sparse& A, const Sparse& B, const Sparse& C);
  friend void sub(Sparse& A, const Sparse& B, const Sparse& C);
  friend void transpose(Sparse& A, const Sparse& B);
  friend void id_mat(Sparse& A);
 
 private:
  Eigen::SparseMatrix<Numeric, Eigen::RowMajor> matrix;
};
 
// Functions for general matrix operations
void abs(Sparse& A, const Sparse& B);
 
void mult(VectorView y, const Sparse& M, ConstVectorView x);
 
void transpose_mult(VectorView y, const Sparse& M, ConstVectorView x);
 
void mult(MatrixView A, const Sparse& B, const ConstMatrixView& C);
 
void mult(MatrixView A, const ConstMatrixView& B, const Sparse& C);
 
void mult(Sparse& A, const Sparse& B, const Sparse& C);
 
void add(Sparse& A, const Sparse& B, const Sparse& C);
 
void sub(Sparse& A, const Sparse& B, const Sparse& C);
 
void transpose(Sparse& A, const Sparse& B);
 
void id_mat(Sparse& A);
 
#endif