oomph::DenseDoubleMatrix Class Reference

#include <matrices.h>

Inheritance diagram for oomph::DenseDoubleMatrix:

Public Member Functions
	DenseDoubleMatrix ()
	Constructor, set the default linear solver. More...
	DenseDoubleMatrix (const unsigned long &n)
	Constructor to build a square n by n matrix. More...
	DenseDoubleMatrix (const unsigned long &n, const unsigned long &m)
	Constructor to build a matrix with n rows and m columns. More...
	DenseDoubleMatrix (const unsigned long &n, const unsigned long &m, const double &initial_val)
	DenseDoubleMatrix (const DenseDoubleMatrix &matrix)=delete
	Broken copy constructor. More...
void	operator= (const DenseDoubleMatrix &)=delete
	Broken assignment operator. More...
unsigned long	nrow () const
	Return the number of rows of the matrix. More...
unsigned long	ncol () const
	Return the number of columns of the matrix. More...
double	operator() (const unsigned long &i, const unsigned long &j) const
double &	operator() (const unsigned long &i, const unsigned long &j)
virtual	~DenseDoubleMatrix ()
	Destructor. More...
virtual void	ludecompose ()
	LU decomposition using DenseLU (default linea solver) More...
virtual void	lubksub (DoubleVector &rhs)
	LU backsubstitution. More...
virtual void	lubksub (Vector< double > &rhs)
	LU backsubstitution. More...
void	eigenvalues_by_jacobi (Vector< double > &eigen_val, DenseMatrix< double > &eigen_vect) const
void	multiply (const DoubleVector &x, DoubleVector &soln) const
	Multiply the matrix by the vector x: soln=Ax. More...
void	multiply_transpose (const DoubleVector &x, DoubleVector &soln) const
	Multiply the transposed matrix by the vector x: soln=A^T x. More...
void	matrix_reduction (const double &alpha, DenseDoubleMatrix &reduced_matrix)
void	multiply (const DenseDoubleMatrix &matrix_in, DenseDoubleMatrix &result)
	Function to multiply this matrix by a DenseDoubleMatrix matrix_in. More...
Public Member Functions inherited from oomph::DoubleMatrixBase
	DoubleMatrixBase ()
	(Empty) constructor. More...
	DoubleMatrixBase (const DoubleMatrixBase &matrix)=delete
	Broken copy constructor. More...
void	operator= (const DoubleMatrixBase &)=delete
	Broken assignment operator. More...
virtual	~DoubleMatrixBase ()
	virtual (empty) destructor More...
LinearSolver *&	linear_solver_pt ()
	Return a pointer to the linear solver object. More...
LinearSolver *const &	linear_solver_pt () const
	Return a pointer to the linear solver object (const version) More...
void	solve (DoubleVector &rhs)
void	solve (const DoubleVector &rhs, DoubleVector &soln)
void	solve (Vector< double > &rhs)
void	solve (const Vector< double > &rhs, Vector< double > &soln)
virtual void	residual (const DoubleVector &x, const DoubleVector &b, DoubleVector &residual_)
	Find the residual, i.e. r=b-Ax the residual. More...
virtual double	max_residual (const DoubleVector &x, const DoubleVector &rhs)
Public Member Functions inherited from oomph::DenseMatrix< double >
	DenseMatrix ()
	Empty constructor, simply assign the lengths N and M to 0. More...
	DenseMatrix (const DenseMatrix &source_matrix)
	Copy constructor: Deep copy! More...
	DenseMatrix (const unsigned long &n)
	Constructor to build a square n by n matrix. More...
	DenseMatrix (const unsigned long &n, const unsigned long &m)
	Constructor to build a matrix with n rows and m columns. More...
	DenseMatrix (const unsigned long &n, const unsigned long &m, const double &initial_val)
DenseMatrix &	operator= (const DenseMatrix &source_matrix)
	Copy assignment. More...
double &	entry (const unsigned long &i, const unsigned long &j)
double	get_entry (const unsigned long &i, const unsigned long &j) const
virtual	~DenseMatrix ()
	Destructor, clean up the matrix data. More...
unsigned long	nrow () const
	Return the number of rows of the matrix. More...
unsigned long	ncol () const
	Return the number of columns of the matrix. More...
void	resize (const unsigned long &n)
void	resize (const unsigned long &n, const unsigned long &m)
void	resize (const unsigned long &n, const unsigned long &m, const double &initial_value)
void	initialise (const double &val)
	Initialize all values in the matrix to val. More...
void	output (std::ostream &outfile) const
	Output function to print a matrix row-by-row to the stream outfile. More...
void	output (std::string filename) const
	Output function to print a matrix row-by-row to a file. Specify filename. More...
void	indexed_output (std::ostream &outfile) const
	Indexed output as i,j,a(i,j) More...
void	indexed_output (std::string filename) const
void	output_bottom_right_zero_helper (std::ostream &outfile) const
void	sparse_indexed_output_helper (std::ostream &outfile) const
	Sparse indexed output as i,j,a(i,j) for a(i,j)!=0 only. More...
Public Member Functions inherited from oomph::Matrix< T, MATRIX_TYPE >
	Matrix ()
	(Empty) constructor More...
	Matrix (const Matrix &matrix)=delete
	Broken copy constructor. More...
void	operator= (const Matrix &)=delete
	Broken assignment operator. More...
virtual	~Matrix ()
	Virtual (empty) destructor. More...
T	operator() (const unsigned long &i, const unsigned long &j) const
T &	operator() (const unsigned long &i, const unsigned long &j)
void	sparse_indexed_output (std::ostream &outfile, const unsigned &precision=0, const bool &output_bottom_right_zero=false) const
void	sparse_indexed_output (std::string filename, const unsigned &precision=0, const bool &output_bottom_right_zero=false) const

Additional Inherited Members
Protected Member Functions inherited from oomph::Matrix< T, MATRIX_TYPE >
void	range_check (const unsigned long &i, const unsigned long &j) const
Protected Attributes inherited from oomph::DoubleMatrixBase
LinearSolver *	Linear_solver_pt
LinearSolver *	Default_linear_solver_pt
Protected Attributes inherited from oomph::DenseMatrix< double >
double *	Matrixdata
	Internal representation of matrix as a pointer to data. More...
unsigned long	N
	Number of rows. More...
unsigned long	M
	Number of columns. More...

Detailed Description

Class of matrices containing doubles, and stored as a DenseMatrix<double>, but with solving functionality inherited from the abstract DoubleMatrix class.

Constructor & Destructor Documentation

DenseDoubleMatrix() [1/5]

oomph::DenseDoubleMatrix::DenseDoubleMatrix

(

)

Constructor, set the default linear solver.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Constructor, set the default linear solver to be the DenseLU solver

                                       : DenseMatrix<double>()
  {
    Linear_solver_pt = Default_linear_solver_pt = new DenseLU;
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt, and oomph::DoubleMatrixBase::Linear_solver_pt.

DenseDoubleMatrix() [2/5]

oomph::DenseDoubleMatrix::DenseDoubleMatrix

(

const unsigned long &

n

)

Constructor to build a square n by n matrix.

Constructor to build a square n by n matrix. Set the default linear solver to be DenseLU

    : DenseMatrix<double>(n)
  {
    Linear_solver_pt = Default_linear_solver_pt = new DenseLU;
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt, and oomph::DoubleMatrixBase::Linear_solver_pt.

DenseDoubleMatrix() [3/5]

oomph::DenseDoubleMatrix::DenseDoubleMatrix	(	const unsigned long &	n,
		const unsigned long &	m
	)

Constructor to build a matrix with n rows and m columns.

Constructor to build a matrix with n rows and m columns. Set the default linear solver to be DenseLU

    : DenseMatrix<double>(n, m)
  {
    Linear_solver_pt = Default_linear_solver_pt = new DenseLU;
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt, and oomph::DoubleMatrixBase::Linear_solver_pt.

DenseDoubleMatrix() [4/5]

oomph::DenseDoubleMatrix::DenseDoubleMatrix	(	const unsigned long &	n,
		const unsigned long &	m,
		const double &	initial_val
	)

Constructor to build a matrix with n rows and m columns, with initial value initial_val

Constructor to build a matrix with n rows and m columns, with initial value initial_val Set the default linear solver to be DenseLU

    : DenseMatrix<double>(n, m, initial_val)
  {
    Linear_solver_pt = Default_linear_solver_pt = new DenseLU;
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt, and oomph::DoubleMatrixBase::Linear_solver_pt.

DenseDoubleMatrix() [5/5]

oomph::DenseDoubleMatrix::DenseDoubleMatrix ( const DenseDoubleMatrix &  matrix )

delete

Broken copy constructor.

~DenseDoubleMatrix()

oomph::DenseDoubleMatrix::~DenseDoubleMatrix ( )

virtual

Destructor.

Destructor delete the default linear solver.

  {
    // Delete the default linear solver
    delete Default_linear_solver_pt;
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt.

Member Function Documentation

eigenvalues_by_jacobi()

void oomph::DenseDoubleMatrix::eigenvalues_by_jacobi	(	Vector< double > &	eigen_vals,
		DenseMatrix< double > &	eigen_vect
	)		const

Determine eigenvalues and eigenvectors, using Jacobi rotations. Only for symmetric matrices. Nothing gets overwritten!

• eigen_vect(i,j) = j-th component of i-th eigenvector.
• eigen_val(i) is the i-th eigenvalue; same ordering as in eigenvectors

Determine eigenvalues and eigenvectors, using Jacobi rotations. Only for symmetric matrices. Nothing gets overwritten!

• eigen_vect(i,j) = j-th component of i-th eigenvector.
• eigen_val[i] is the i-th eigenvalue; same ordering as in eigenvectors

  {
#ifdef PARANOID
    // Check Matrix is square
    if (N != M)
    {
      throw OomphLibError(
        "This matrix is not square, the matrix MUST be square!",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
#endif
    // Make a copy of the matrix & check that it's symmetric
 
    // Check that the sizes of eigen_vals and eigen_vect are correct. If not
    // correct them.
    if (eigen_vals.size() != N)
    {
      eigen_vals.resize(N);
    }
    if (eigen_vect.ncol() != N || eigen_vect.nrow() != N)
    {
      eigen_vect.resize(N);
    }
 
    DenseDoubleMatrix working_matrix(N);
    for (unsigned long i = 0; i < N; i++)
    {
      for (unsigned long j = 0; j < M; j++)
      {
#ifdef PARANOID
        if (Matrixdata[M * i + j] != Matrixdata[M * j + i])
        {
          throw OomphLibError(
            "Matrix needs to be symmetric for eigenvalues_by_jacobi()",
            OOMPH_CURRENT_FUNCTION,
            OOMPH_EXCEPTION_LOCATION);
        }
#endif
        working_matrix(i, j) = (*this)(i, j);
      }
    }
 
    DenseDoubleMatrix aux_eigen_vect(N);
 
    throw OomphLibError("Sorry JacobiEigenSolver::jacobi() removed because of "
                        "licencing problems.",
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
 
    // // Call eigensolver
    // unsigned long nrot;
    // JacobiEigenSolver::jacobi(working_matrix, eigen_vals, aux_eigen_vect,
    //                           nrot);
 
    // Copy across (and transpose)
    for (unsigned long i = 0; i < N; i++)
    {
      for (unsigned long j = 0; j < M; j++)
      {
        eigen_vect(i, j) = aux_eigen_vect(j, i);
      }
    }
  }

References i, j, oomph::DenseMatrix< double >::M, oomph::DenseMatrix< double >::Matrixdata, oomph::DenseMatrix< double >::N, oomph::DenseMatrix< T >::ncol(), oomph::DenseMatrix< T >::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::DenseMatrix< T >::resize().

lubksub() [1/2]

void oomph::DenseDoubleMatrix::lubksub ( DoubleVector &  rhs )

virtual

LU backsubstitution.

Back substitute an LU decomposed matrix.

  {
    // Use the default (DenseLU) solver to perform the backsubstitution
    static_cast<DenseLU*>(Default_linear_solver_pt)->backsub(rhs, rhs);
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt.

Referenced by oomph::DGElement::get_inverse_mass_matrix_times_residuals(), oomph::Z2ErrorEstimator::get_recovered_flux_in_patch(), and oomph::VorticitySmoother< ELEMENT >::get_recovered_vorticity_in_patch().

lubksub() [2/2]

void oomph::DenseDoubleMatrix::lubksub ( Vector< double > &  rhs )

virtual

LU backsubstitution.

Back substitute an LU decomposed matrix.

  {
    // Use the default (DenseLU) solver to perform the backsubstitution
    static_cast<DenseLU*>(Default_linear_solver_pt)->backsub(rhs, rhs);
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt.

ludecompose()

void oomph::DenseDoubleMatrix::ludecompose ( )

virtual

LU decomposition using DenseLU (default linea solver)

LU decompose a matrix, by using the default linear solver (DenseLU)

  {
    // Use the default (DenseLU) solver to ludecompose the matrix
    static_cast<DenseLU*>(Default_linear_solver_pt)->factorise(this);
  }

References oomph::DoubleMatrixBase::Default_linear_solver_pt.

Referenced by oomph::DGElement::get_inverse_mass_matrix_times_residuals(), oomph::Z2ErrorEstimator::get_recovered_flux_in_patch(), oomph::VorticitySmoother< ELEMENT >::get_recovered_vorticity_in_patch(), and oomph::DGElement::pre_compute_mass_matrix().

matrix_reduction()

void oomph::DenseDoubleMatrix::matrix_reduction	(	const double &	alpha,
		DenseDoubleMatrix &	reduced_matrix
	)

For every row, find the maximum absolute value of the entries in this row. Set all values that are less than alpha times this maximum to zero and return the resulting matrix in reduced_matrix. Note: Diagonal entries are retained regardless of their size.

  {
    reduced_matrix.resize(N, M, 0.0);
    // maximum value in a row
    double max_row;
 
    // Loop over rows
    for (unsigned i = 0; i < N; i++)
    {
      // Initialise max value in row
      max_row = 0.0;
 
      // Loop over entries in columns
      for (unsigned long j = 0; j < M; j++)
      {
        // Find max. value in row
        if (std::fabs(Matrixdata[M * i + j]) > max_row)
        {
          max_row = std::fabs(Matrixdata[M * i + j]);
        }
      }
 
      // Decide if we need to retain the entries in the row
      for (unsigned long j = 0; j < M; j++)
      {
        // If we're on the diagonal or the value is sufficiently large: retain
        // i.e. copy across.
        if (i == j || std::fabs(Matrixdata[M * i + j]) > alpha * max_row)
        {
          reduced_matrix(i, j) = Matrixdata[M * i + j];
        }
      }
    }
  }

References alpha, boost::multiprecision::fabs(), i, j, oomph::DenseMatrix< double >::M, oomph::DenseMatrix< double >::Matrixdata, oomph::DenseMatrix< double >::N, and oomph::DenseMatrix< T >::resize().

multiply() [1/2]

void oomph::DenseDoubleMatrix::multiply	(	const DenseDoubleMatrix &	matrix_in,
		DenseDoubleMatrix &	result
	)

Function to multiply this matrix by a DenseDoubleMatrix matrix_in.

Function to multiply this matrix by the DenseDoubleMatrix matrix_in.

  {
#ifdef PARANOID
    // check matrix dimensions are compatable
    if (this->ncol() != matrix_in.nrow())
    {
      std::ostringstream error_message;
      error_message
        << "Matrix dimensions incompatable for matrix-matrix multiplication"
        << "ncol() for first matrix:" << this->ncol()
        << "nrow() for second matrix: " << matrix_in.nrow();
 
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // NB N is number of rows!
    unsigned long n_row = this->nrow();
    unsigned long m_col = matrix_in.ncol();
 
    // resize and intialize result
    result.resize(n_row, m_col, 0.0);
 
    // clock_t clock1 = clock();
 
    // do calculation
    unsigned long n_col = this->ncol();
    for (unsigned long k = 0; k < n_col; k++)
    {
      for (unsigned long i = 0; i < n_row; i++)
      {
        for (unsigned long j = 0; j < m_col; j++)
        {
          result(i, j) += Matrixdata[m_col * i + k] * matrix_in(k, j);
        }
      }
    }
  }

References i, j, k, oomph::DenseMatrix< double >::Matrixdata, ncol(), nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::DenseMatrix< T >::resize().

multiply() [2/2]

void oomph::DenseDoubleMatrix::multiply ( const DoubleVector &  x, DoubleVector &  soln  ) const

virtual

Multiply the matrix by the vector x: soln=Ax.

Implements oomph::DoubleMatrixBase.

  {
#ifdef PARANOID
    // Check to see if x.size() = ncol().
    if (x.nrow() != this->ncol())
    {
      std::ostringstream error_message_stream;
      error_message_stream << "The x vector is not the right size. It is "
                           << x.nrow() << ", it should be " << this->ncol()
                           << std::endl;
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
    // check that x is not distributed
    if (x.distributed())
    {
      std::ostringstream error_message_stream;
      error_message_stream
        << "The x vector cannot be distributed for DenseDoubleMatrix "
        << "matrix-vector multiply" << std::endl;
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
    // if soln is setup...
    if (soln.built())
    {
      // check that soln is not distributed
      if (soln.distributed())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The x vector cannot be distributed for DenseDoubleMatrix "
          << "matrix-vector multiply" << std::endl;
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (soln.nrow() != this->nrow())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The soln vector is setup and therefore must have the same "
          << "number of rows as the matrix";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (*x.distribution_pt()->communicator_pt() !=
          *soln.distribution_pt()->communicator_pt())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The soln vector and the x vector must have the same communicator"
          << std::endl;
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    // if soln is not setup then setup the distribution
    if (!soln.built())
    {
      LinearAlgebraDistribution dist(
        x.distribution_pt()->communicator_pt(), this->nrow(), false);
      soln.build(&dist, 0.0);
    }
 
    // Initialise the solution
    soln.initialise(0.0);
 
    // Multiply the matrix A, by the vector x
    const double* x_pt = x.values_pt();
    double* soln_pt = soln.values_pt();
    for (unsigned long i = 0; i < N; i++)
    {
      for (unsigned long j = 0; j < M; j++)
      {
        soln_pt[i] += Matrixdata[M * i + j] * x_pt[j];
      }
    }
  }

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DoubleVector::initialise(), j, oomph::DenseMatrix< double >::M, oomph::DenseMatrix< double >::Matrixdata, oomph::DenseMatrix< double >::N, ncol(), oomph::DistributableLinearAlgebraObject::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::DoubleVector::values_pt(), and plotDoE::x.

Referenced by main().

multiply_transpose()

void oomph::DenseDoubleMatrix::multiply_transpose ( const DoubleVector &  x, DoubleVector &  soln  ) const

virtual

Multiply the transposed matrix by the vector x: soln=A^T x.

Implements oomph::DoubleMatrixBase.

  {
#ifdef PARANOID
    // Check to see if x.size() = ncol().
    if (x.nrow() != this->nrow())
    {
      std::ostringstream error_message_stream;
      error_message_stream << "The x vector is not the right size. It is "
                           << x.nrow() << ", it should be " << this->nrow()
                           << std::endl;
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
    // check that x is not distributed
    if (x.distributed())
    {
      std::ostringstream error_message_stream;
      error_message_stream
        << "The x vector cannot be distributed for DenseDoubleMatrix "
        << "matrix-vector multiply" << std::endl;
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
    // if soln is setup...
    if (soln.built())
    {
      // check that soln is not distributed
      if (soln.distributed())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The x vector cannot be distributed for DenseDoubleMatrix "
          << "matrix-vector multiply" << std::endl;
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (soln.nrow() != this->ncol())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The soln vector is setup and therefore must have the same "
          << "number of columns as the matrix";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (*soln.distribution_pt()->communicator_pt() !=
          *x.distribution_pt()->communicator_pt())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The soln vector and the x vector must have the same communicator"
          << std::endl;
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    // if soln is not setup then setup the distribution
    if (!soln.built())
    {
      LinearAlgebraDistribution* dist_pt = new LinearAlgebraDistribution(
        x.distribution_pt()->communicator_pt(), this->ncol(), false);
      soln.build(dist_pt, 0.0);
      delete dist_pt;
    }
 
    // Initialise the solution
    soln.initialise(0.0);
 
    // Matrix vector product
    double* soln_pt = soln.values_pt();
    const double* x_pt = x.values_pt();
    for (unsigned long i = 0; i < N; i++)
    {
      for (unsigned long j = 0; j < M; j++)
      {
        soln_pt[j] += Matrixdata[N * i + j] * x_pt[i];
      }
    }
  }

References oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DoubleVector::initialise(), j, oomph::DenseMatrix< double >::M, oomph::DenseMatrix< double >::Matrixdata, oomph::DenseMatrix< double >::N, oomph::DistributableLinearAlgebraObject::nrow(), nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::DoubleVector::values_pt(), and plotDoE::x.

ncol()

unsigned long oomph::DenseDoubleMatrix::ncol ( ) const

inlinevirtual

Return the number of columns of the matrix.

Implements oomph::DoubleMatrixBase.

    {
      return DenseMatrix<double>::ncol();
    }

References oomph::DenseMatrix< T >::ncol().

Referenced by main(), and multiply().

nrow()

unsigned long oomph::DenseDoubleMatrix::nrow ( ) const

inlinevirtual

Return the number of rows of the matrix.

Implements oomph::DoubleMatrixBase.

    {
      return DenseMatrix<double>::nrow();
    }

References oomph::DenseMatrix< T >::nrow().

Referenced by main(), multiply(), and multiply_transpose().

operator()() [1/2]

double& oomph::DenseDoubleMatrix::operator() ( const unsigned long &  i, const unsigned long &  j  )

inline

Overload the non-const version of the round-bracket access operator for read-write access

    {
      return DenseMatrix<double>::entry(i, j);
    }

References oomph::DenseMatrix< T >::entry(), i, and j.

operator()() [2/2]

double oomph::DenseDoubleMatrix::operator() ( const unsigned long &  i, const unsigned long &  j  ) const

inlinevirtual

Overload the const version of the round-bracket access operator for read-only access.

Implements oomph::DoubleMatrixBase.

    {
      return DenseMatrix<double>::get_entry(i, j);
    }

References oomph::DenseMatrix< T >::get_entry(), i, and j.

operator=()

void oomph::DenseDoubleMatrix::operator= ( const DenseDoubleMatrix &  )

delete

Broken assignment operator.

---

The documentation for this class was generated from the following files:

• matrices.h
• matrices.cc