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