tridiagonal_matrix.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2020 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
#ifndef DOXYGEN
template <typename number>
class Vector;
#endif
 
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
{
  AssertIndexRange(i, n());
  AssertIndexRange(j, 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)
{
  AssertIndexRange(i, n());
  AssertIndexRange(j, 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