tridiagonal_matrix.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, 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 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_tridiagonal_matrix_h
#define dealii_tridiagonal_matrix_h

#include <deal.II/base/config.h>

#include <deal.II/base/subscriptor.h>

#include <deal.II/lac/lapack_support.h>

#include <iomanip>
#include <vector>

DEAL_II_NAMESPACE_OPEN

// forward declarations
template <typename number>
class Vector;


template <typename number>
class TridiagonalMatrix
{
public:


  using size_type = types::global_dof_index;

  TridiagonalMatrix(size_type n = 0, bool symmetric = false);

  void
  reinit(size_type n, bool symmetric = false);





  size_type
  m() const;

  size_type
  n() const;

  bool
  all_zero() const;




  number
  operator()(size_type i, size_type j) const;

  number &
  operator()(size_type i, size_type j);




  void
  vmult(Vector<number> &      w,
        const Vector<number> &v,
        const bool            adding = false) const;

  void
  vmult_add(Vector<number> &w, const Vector<number> &v) const;

  void
  Tvmult(Vector<number> &      w,
         const Vector<number> &v,
         const bool            adding = false) const;

  void
  Tvmult_add(Vector<number> &w, const Vector<number> &v) const;

  number
  matrix_scalar_product(const Vector<number> &u, const Vector<number> &v) const;

  number
  matrix_norm_square(const Vector<number> &v) const;




  void
  compute_eigenvalues();
  number
  eigenvalue(const size_type i) const;



  template <class OutputStream>
  void
  print(OutputStream &     s,
        const unsigned int width     = 5,
        const unsigned int precision = 2) const;

private:
  std::vector<number> diagonal;
  std::vector<number> left;
  std::vector<number> right;

  bool is_symmetric;

  LAPACKSupport::State state;
};

//---------------------------------------------------------------------------
#ifndef DOXYGEN

template <typename number>
types::global_dof_index
TridiagonalMatrix<number>::m() const
{
  return diagonal.size();
}



template <typename number>
types::global_dof_index
TridiagonalMatrix<number>::n() const
{
  return diagonal.size();
}


template <typename number>
inline number
TridiagonalMatrix<number>::operator()(size_type i, size_type j) const
{
  Assert(i < n(), ExcIndexRange(i, 0, n()));
  Assert(j < n(), ExcIndexRange(j, 0, n()));
  Assert(i <= j + 1, ExcIndexRange(i, j - 1, j + 2));
  Assert(j <= i + 1, ExcIndexRange(j, i - 1, i + 2));

  if (j == i)
    return diagonal[i];
  if (j == i - 1)
    {
      if (is_symmetric)
        return right[i - 1];
      else
        return left[i];
    }

  if (j == i + 1)
    return right[i];

  Assert(false, ExcInternalError());
  return 0;
}


template <typename number>
inline number &
TridiagonalMatrix<number>::operator()(size_type i, size_type j)
{
  Assert(i < n(), ExcIndexRange(i, 0, n()));
  Assert(j < n(), ExcIndexRange(j, 0, n()));
  Assert(i <= j + 1, ExcIndexRange(i, j - 1, j + 2));
  Assert(j <= i + 1, ExcIndexRange(j, i - 1, i + 2));

  if (j == i)
    return diagonal[i];
  if (j == i - 1)
    {
      if (is_symmetric)
        return right[i - 1];
      else
        return left[i];
    }

  if (j == i + 1)
    return right[i];

  Assert(false, ExcInternalError());
  return diagonal[0];
}


template <typename number>
template <class OutputStream>
void
TridiagonalMatrix<number>::print(OutputStream &     s,
                                 const unsigned int width,
                                 const unsigned int) const
{
  for (size_type i = 0; i < n(); ++i)
    {
      if (i > 0)
        s << std::setw(width) << (*this)(i, i - 1);
      else
        s << std::setw(width) << "";

      s << ' ' << (*this)(i, i) << ' ';

      if (i < n() - 1)
        s << std::setw(width) << (*this)(i, i + 1);

      s << std::endl;
    }
}


#endif // DOXYGEN

DEAL_II_NAMESPACE_CLOSE

#endif