From: Matthias Maier <tamiko@43-1.org>
Date: Sun, 25 Oct 2015 18:01:57 +0000 (-0500)
Subject: Partially revert pull request 1673
X-Git-Tag: v8.4.0-rc2~283^2
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=1b6a4bdc128e382e593621951244caf5e71d3606;p=dealii.git

Partially revert pull request 1673

This reverts all changes to iterative_inverse.h and pointer_matrix.h
introduced by pull request #1673.
---

diff --git a/include/deal.II/lac/iterative_inverse.h b/include/deal.II/lac/iterative_inverse.h
index 84375351cf..dbbf17ccfc 100644
--- a/include/deal.II/lac/iterative_inverse.h
+++ b/include/deal.II/lac/iterative_inverse.h
@@ -72,19 +72,13 @@ DEAL_II_NAMESPACE_OPEN
  * for further details.
  *
  * @ingroup Matrix2
- * @author Guido Kanschat; extension for full compatibility with
- * LinearOperator class: Jean-Paul Pelteret
- * @date 2010, 2015
+ * @author Guido Kanschat
+ * @date 2010
  */
 template <class VECTOR>
 class IterativeInverse : public Subscriptor
 {
 public:
-  /**
-   * Declare type for container size.
-   */
-  typedef typename PointerMatrixBase<VECTOR>::size_type size_type;
-
   /**
    * Initialization function. Provide a matrix and preconditioner for the
    * solve in vmult().
@@ -102,11 +96,6 @@ public:
    */
   void vmult (VECTOR &dst, const VECTOR &src) const;
 
-  /**
-   * Same as before, but uses the transpose of the matrix.
-   */
-  void Tvmult (VECTOR &dst, const VECTOR &src) const;
-
   /**
    * Solve for right hand side <tt>src</tt>, but allow for the fact that the
    * vectors given to this function have different type from the vectors used
@@ -115,24 +104,6 @@ public:
   template <class VECTOR2>
   void vmult (VECTOR2 &dst, const VECTOR2 &src) const;
 
-  /**
-   * Same as before, but uses the transpose of the matrix.
-   */
-  template <class VECTOR2>
-  void Tvmult (VECTOR2 &dst, const VECTOR2 &src) const;
-
-  /**
-   * Return the dimension of the codomain (or range) space. To remember: the
-   * matrix is of dimension $m \times n$.
-   */
-  size_type m () const;
-
-  /**
-   * Return the dimension of the domain space. To remember: the matrix is of
-   * dimension $m \times n$.
-   */
-  size_type n () const;
-
   /**
    * The solver, which allows selection of the actual solver as well as
    * adjustment of parameters.
@@ -186,14 +157,6 @@ IterativeInverse<VECTOR>::vmult (VECTOR &dst, const VECTOR &src) const
 }
 
 
-template <class VECTOR>
-inline void
-IterativeInverse<VECTOR>::Tvmult (VECTOR &dst, const VECTOR &src) const
-{
-  AssertThrow(false, ExcNotImplemented());
-}
-
-
 template <class VECTOR>
 template <class VECTOR2>
 inline void
@@ -211,32 +174,6 @@ IterativeInverse<VECTOR>::vmult (VECTOR2 &dst, const VECTOR2 &src) const
 }
 
 
-template <class VECTOR>
-template <class VECTOR2>
-inline void
-IterativeInverse<VECTOR>::Tvmult (VECTOR2 &dst, const VECTOR2 &src) const
-{
-  AssertThrow(false, ExcNotImplemented());
-}
-
-
-template <class VECTOR>
-inline typename IterativeInverse<VECTOR>::size_type
-IterativeInverse<VECTOR>::m () const
-{
-  Assert (matrix.get()!=0, ExcNotInitialized());
-  return matrix->m();
-}
-
-template <class VECTOR>
-inline typename IterativeInverse<VECTOR>::size_type
-IterativeInverse<VECTOR>::n () const
-{
-  Assert (matrix.get()!=0, ExcNotInitialized());
-  return matrix->n();
-}
-
-
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/lac/pointer_matrix.h b/include/deal.II/lac/pointer_matrix.h
index aad96c0253..708f595e1c 100644
--- a/include/deal.II/lac/pointer_matrix.h
+++ b/include/deal.II/lac/pointer_matrix.h
@@ -51,11 +51,6 @@ template<class VECTOR>
 class PointerMatrixBase : public Subscriptor
 {
 public:
-  /**
-   * Declare type for container size.
-   */
-  typedef types::global_dof_index size_type;
-
   /**
    * Value type of this matrix. since the matrix itself is unknown, we take
    * the value type of the vector. Therefore, matrix entries must be
@@ -101,18 +96,6 @@ public:
    */
   virtual void Tvmult_add (VECTOR &dst,
                            const VECTOR &src) const = 0;
-
-  /**
-   * Return the dimension of the codomain (or range) space. To remember: the
-   * matrix is of dimension $m \times n$.
-   */
-  virtual size_type m () const = 0;
-
-  /**
-   * Return the dimension of the domain space. To remember: the matrix is of
-   * dimension $m \times n$.
-   */
-  virtual size_type n () const  = 0;
 };
 
 
@@ -124,18 +107,12 @@ public:
  * only has a vector as template argument. Therefore, this interface provides
  * an abstract base class for matrices.
  *
- * @author Guido Kanschat 2000, 2001, 2002; extension for full compatibility
- * with LinearOperator class: Jean-Paul Pelteret, 2015
+ * @author Guido Kanschat 2000, 2001, 2002
  */
 template<class MATRIX, class VECTOR>
 class PointerMatrix : public PointerMatrixBase<VECTOR>
 {
 public:
-  /**
-   * Declare type for container size.
-   */
-  typedef typename PointerMatrixBase<VECTOR>::size_type size_type;
-
   /**
    * Constructor.  The pointer in the argument is stored in this class. As
    * usual, the lifetime of <tt>*M</tt> must be longer than the one of the
@@ -171,12 +148,6 @@ public:
   PointerMatrix(const MATRIX *M,
                 const char *name);
 
-  /**
-   * Destructor
-   */
-  virtual ~PointerMatrix ()
-  {}
-
   // Use doc from base class
   virtual void clear();
 
@@ -216,23 +187,11 @@ public:
   virtual void Tvmult_add (VECTOR &dst,
                            const VECTOR &src) const;
 
-  /**
-   * Return the dimension of the codomain (or range) space. To remember: the
-   * matrix is of dimension $m \times n$.
-   */
-  virtual size_type m () const;
-
-  /**
-   * Return the dimension of the domain space. To remember: the matrix is of
-   * dimension $m \times n$.
-   */
-  virtual size_type n () const;
-
 private:
   /**
    * The pointer to the actual matrix.
    */
-  SmartPointer<const MATRIX,PointerMatrix<MATRIX,VECTOR> > matrix;
+  SmartPointer<const MATRIX,PointerMatrix<MATRIX,VECTOR> > m;
 };
 
 
@@ -248,18 +207,12 @@ private:
  * and by the fact that it implements the functions vmult_add() and
  * Tvmult_add() only using vmult() and Tvmult() of the MATRIX.
  *
- * @author Guido Kanschat 2006; extension for full compatibility with
- * LinearOperator class: Jean-Paul Pelteret, 2015
+ * @author Guido Kanschat 2006
  */
 template<class MATRIX, class VECTOR>
 class PointerMatrixAux : public PointerMatrixBase<VECTOR>
 {
 public:
-  /**
-   * Declare type for container size.
-   */
-  typedef typename PointerMatrixBase<VECTOR>::size_type size_type;
-
   /**
    * Constructor.  The pointer in the argument is stored in this class. As
    * usual, the lifetime of <tt>*M</tt> must be longer than the one of the
@@ -300,12 +253,6 @@ public:
                    const MATRIX *M,
                    const char *name);
 
-  /**
-   * Destructor
-   */
-  virtual ~PointerMatrixAux ()
-  {}
-
   // Use doc from base class
   virtual void clear();
 
@@ -350,18 +297,6 @@ public:
   virtual void Tvmult_add (VECTOR &dst,
                            const VECTOR &src) const;
 
-  /**
-   * Return the dimension of the codomain (or range) space. To remember: the
-   * matrix is of dimension $m \times n$.
-   */
-  virtual size_type m () const;
-
-  /**
-   * Return the dimension of the domain space. To remember: the matrix is of
-   * dimension $m \times n$.
-   */
-  virtual size_type n () const;
-
 private:
   /**
    * The backup memory if none was provided.
@@ -376,7 +311,7 @@ private:
   /**
    * The pointer to the actual matrix.
    */
-  SmartPointer<const MATRIX,PointerMatrixAux<MATRIX,VECTOR> > matrix;
+  SmartPointer<const MATRIX,PointerMatrixAux<MATRIX,VECTOR> > m;
 };
 
 
@@ -389,18 +324,12 @@ private:
  * (#vmult()) and scalar multiplication (#Tvmult()) functions of the Vector
  * class.
  *
- * @author Guido Kanschat, 2006; extension for full compatibility with
- * LinearOperator class: Jean-Paul Pelteret, 2015
+ * @author Guido Kanschat, 2006
  */
 template <typename number>
 class PointerMatrixVector : public PointerMatrixBase<Vector<number> >
 {
 public:
-  /**
-   * Declare type for container size.
-   */
-  typedef typename PointerMatrixBase< Vector<number> >::size_type size_type;
-
   /**
    * Constructor.  The pointer in the argument is stored in this class. As
    * usual, the lifetime of <tt>*M</tt> must be longer than the one of the
@@ -436,12 +365,6 @@ public:
   PointerMatrixVector (const Vector<number> *M,
                        const char *name);
 
-  /**
-   * Destructor
-   */
-  virtual ~PointerMatrixVector ()
-  {}
-
   // Use doc from base class
   virtual void clear();
 
@@ -495,23 +418,11 @@ public:
   virtual void Tvmult_add (Vector<number> &dst,
                            const Vector<number> &src) const;
 
-  /**
-   * Return the dimension of the codomain (or range) space. To remember: the
-   * matrix is of dimension $m \times n$.
-   */
-  virtual size_type m () const;
-
-  /**
-   * Return the dimension of the domain space. To remember: the matrix is of
-   * dimension $m \times n$.
-   */
-  virtual size_type n () const;
-
 private:
   /**
    * The pointer to the actual matrix.
    */
-  SmartPointer<const Vector<number>,PointerMatrixVector<number> > matrix;
+  SmartPointer<const Vector<number>,PointerMatrixVector<number> > m;
 };
 
 
@@ -674,13 +585,13 @@ PointerMatrixBase<VECTOR>::~PointerMatrixBase ()
 
 template<class MATRIX, class VECTOR>
 PointerMatrix<MATRIX, VECTOR>::PointerMatrix (const MATRIX *M)
-  : matrix(M, typeid(*this).name())
+  : m(M, typeid(*this).name())
 {}
 
 
 template<class MATRIX, class VECTOR>
 PointerMatrix<MATRIX, VECTOR>::PointerMatrix (const char *name)
-  : matrix(0, name)
+  : m(0, name)
 {}
 
 
@@ -688,7 +599,7 @@ template<class MATRIX, class VECTOR>
 PointerMatrix<MATRIX, VECTOR>::PointerMatrix (
   const MATRIX *M,
   const char *name)
-  : matrix(M, name)
+  : m(M, name)
 {}
 
 
@@ -696,7 +607,7 @@ template<class MATRIX, class VECTOR>
 inline void
 PointerMatrix<MATRIX, VECTOR>::clear ()
 {
-  matrix = 0;
+  m = 0;
 }
 
 
@@ -704,7 +615,7 @@ template<class MATRIX, class VECTOR>
 inline const PointerMatrix<MATRIX, VECTOR> &
 PointerMatrix<MATRIX, VECTOR>::operator= (const MATRIX *M)
 {
-  matrix = M;
+  m = M;
   return *this;
 }
 
@@ -713,9 +624,9 @@ template<class MATRIX, class VECTOR>
 inline bool
 PointerMatrix<MATRIX, VECTOR>::empty () const
 {
-  if (matrix == 0)
+  if (m == 0)
     return true;
-  return matrix->empty();
+  return m->empty();
 }
 
 template<class MATRIX, class VECTOR>
@@ -723,8 +634,8 @@ inline void
 PointerMatrix<MATRIX, VECTOR>::vmult (VECTOR &dst,
                                       const VECTOR &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
-  matrix->vmult (dst, src);
+  Assert (m != 0, ExcNotInitialized());
+  m->vmult (dst, src);
 }
 
 
@@ -733,8 +644,8 @@ inline void
 PointerMatrix<MATRIX, VECTOR>::Tvmult (VECTOR &dst,
                                        const VECTOR &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
-  matrix->Tvmult (dst, src);
+  Assert (m != 0, ExcNotInitialized());
+  m->Tvmult (dst, src);
 }
 
 
@@ -743,8 +654,8 @@ inline void
 PointerMatrix<MATRIX, VECTOR>::vmult_add (VECTOR &dst,
                                           const VECTOR &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
-  matrix->vmult_add (dst, src);
+  Assert (m != 0, ExcNotInitialized());
+  m->vmult_add (dst, src);
 }
 
 
@@ -753,28 +664,11 @@ inline void
 PointerMatrix<MATRIX, VECTOR>::Tvmult_add (VECTOR &dst,
                                            const VECTOR &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
-  matrix->Tvmult_add (dst, src);
+  Assert (m != 0, ExcNotInitialized());
+  m->Tvmult_add (dst, src);
 }
 
 
-template<class MATRIX, class VECTOR>
-inline typename PointerMatrix<MATRIX, VECTOR>::size_type
-PointerMatrix<MATRIX, VECTOR>::m () const
-{
-  Assert (matrix != 0, ExcNotInitialized());
-  return matrix->m();
-}
-
-
-template<class MATRIX, class VECTOR>
-inline typename PointerMatrix<MATRIX, VECTOR>::size_type
-PointerMatrix<MATRIX, VECTOR>::n () const
-{
-  Assert (matrix != 0, ExcNotInitialized());
-  return matrix->n();
-}
-
 
 //----------------------------------------------------------------------//
 
@@ -784,7 +678,7 @@ PointerMatrixAux<MATRIX, VECTOR>::PointerMatrixAux (
   VectorMemory<VECTOR> *mem,
   const MATRIX *M)
   : mem(mem, typeid(*this).name()),
-    matrix(M, typeid(*this).name())
+    m(M, typeid(*this).name())
 {
   if (mem == 0) mem = &my_memory;
 }
@@ -795,7 +689,7 @@ PointerMatrixAux<MATRIX, VECTOR>::PointerMatrixAux (
   VectorMemory<VECTOR> *mem,
   const char *name)
   : mem(mem, name),
-    matrix(0, name)
+    m(0, name)
 {
   if (mem == 0) mem = &my_memory;
 }
@@ -807,7 +701,7 @@ PointerMatrixAux<MATRIX, VECTOR>::PointerMatrixAux (
   const MATRIX *M,
   const char *name)
   : mem(mem, name),
-    matrix(M, name)
+    m(M, name)
 {
   if (mem == 0) mem = &my_memory;
 }
@@ -817,7 +711,7 @@ template<class MATRIX, class VECTOR>
 inline void
 PointerMatrixAux<MATRIX, VECTOR>::clear ()
 {
-  matrix = 0;
+  m = 0;
 }
 
 
@@ -825,7 +719,7 @@ template<class MATRIX, class VECTOR>
 inline const PointerMatrixAux<MATRIX, VECTOR> &
 PointerMatrixAux<MATRIX, VECTOR>::operator= (const MATRIX *M)
 {
-  matrix = M;
+  m = M;
   return *this;
 }
 
@@ -844,9 +738,9 @@ template<class MATRIX, class VECTOR>
 inline bool
 PointerMatrixAux<MATRIX, VECTOR>::empty () const
 {
-  if (matrix == 0)
+  if (m == 0)
     return true;
-  return matrix->empty();
+  return m->empty();
 }
 
 template<class MATRIX, class VECTOR>
@@ -857,8 +751,8 @@ PointerMatrixAux<MATRIX, VECTOR>::vmult (VECTOR &dst,
   if (mem == 0)
     mem = &my_memory;
   Assert (mem != 0, ExcNotInitialized());
-  Assert (matrix != 0, ExcNotInitialized());
-  matrix->vmult (dst, src);
+  Assert (m != 0, ExcNotInitialized());
+  m->vmult (dst, src);
 }
 
 
@@ -870,8 +764,8 @@ PointerMatrixAux<MATRIX, VECTOR>::Tvmult (VECTOR &dst,
   if (mem == 0)
     mem = &my_memory;
   Assert (mem != 0, ExcNotInitialized());
-  Assert (matrix != 0, ExcNotInitialized());
-  matrix->Tvmult (dst, src);
+  Assert (m != 0, ExcNotInitialized());
+  m->Tvmult (dst, src);
 }
 
 
@@ -883,10 +777,10 @@ PointerMatrixAux<MATRIX, VECTOR>::vmult_add (VECTOR &dst,
   if (mem == 0)
     mem = &my_memory;
   Assert (mem != 0, ExcNotInitialized());
-  Assert (matrix != 0, ExcNotInitialized());
+  Assert (m != 0, ExcNotInitialized());
   VECTOR *v = mem->alloc();
   v->reinit(dst);
-  matrix->vmult (*v, src);
+  m->vmult (*v, src);
   dst += *v;
   mem->free(v);
 }
@@ -900,45 +794,27 @@ PointerMatrixAux<MATRIX, VECTOR>::Tvmult_add (VECTOR &dst,
   if (mem == 0)
     mem = &my_memory;
   Assert (mem != 0, ExcNotInitialized());
-  Assert (matrix != 0, ExcNotInitialized());
+  Assert (m != 0, ExcNotInitialized());
   VECTOR *v = mem->alloc();
   v->reinit(dst);
-  matrix->Tvmult (*v, src);
+  m->Tvmult (*v, src);
   dst += *v;
   mem->free(v);
 }
 
 
-template<class MATRIX, class VECTOR>
-inline typename PointerMatrixAux<MATRIX, VECTOR>::size_type
-PointerMatrixAux<MATRIX, VECTOR>::m () const
-{
-  Assert (matrix != 0, ExcNotInitialized());
-  return matrix->m();
-}
-
-
-template<class MATRIX, class VECTOR>
-inline typename PointerMatrixAux<MATRIX, VECTOR>::size_type
-PointerMatrixAux<MATRIX, VECTOR>::n () const
-{
-  Assert (matrix != 0, ExcNotInitialized());
-  return matrix->n();
-}
-
-
 //----------------------------------------------------------------------//
 
 
 template<typename number>
 PointerMatrixVector<number>::PointerMatrixVector (const Vector<number> *M)
-  : matrix(M, typeid(*this).name())
+  : m(M, typeid(*this).name())
 {}
 
 
 template<typename number>
 PointerMatrixVector<number>::PointerMatrixVector (const char *name)
-  : matrix(0, name)
+  : m(0, name)
 {}
 
 
@@ -946,7 +822,7 @@ template<typename number>
 PointerMatrixVector<number>::PointerMatrixVector (
   const Vector<number> *M,
   const char *name)
-  : matrix(M, name)
+  : m(M, name)
 {}
 
 
@@ -954,7 +830,7 @@ template<typename number>
 inline void
 PointerMatrixVector<number>::clear ()
 {
-  matrix = 0;
+  m = 0;
 }
 
 
@@ -962,7 +838,7 @@ template<typename number>
 inline const PointerMatrixVector<number> &
 PointerMatrixVector<number>::operator= (const Vector<number> *M)
 {
-  matrix = M;
+  m = M;
   return *this;
 }
 
@@ -971,9 +847,9 @@ template<typename number>
 inline bool
 PointerMatrixVector<number>::empty () const
 {
-  if (matrix == 0)
+  if (m == 0)
     return true;
-  return matrix->empty();
+  return m->empty();
 }
 
 template<typename number>
@@ -982,10 +858,10 @@ PointerMatrixVector<number>::vmult (
   Vector<number> &dst,
   const Vector<number> &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
+  Assert (m != 0, ExcNotInitialized());
   Assert (dst.size() == 1, ExcDimensionMismatch(dst.size(), 1));
 
-  dst(0) = *matrix * src;
+  dst(0) = *m * src;
 }
 
 
@@ -995,10 +871,10 @@ PointerMatrixVector<number>::Tvmult (
   Vector<number> &dst,
   const Vector<number> &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
+  Assert (m != 0, ExcNotInitialized());
   Assert(src.size() == 1, ExcDimensionMismatch(src.size(), 1));
 
-  dst.equ (src(0), *matrix);
+  dst.equ (src(0), *m);
 }
 
 
@@ -1008,10 +884,10 @@ PointerMatrixVector<number>::vmult_add (
   Vector<number> &dst,
   const Vector<number> &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
+  Assert (m != 0, ExcNotInitialized());
   Assert (dst.size() == 1, ExcDimensionMismatch(dst.size(), 1));
 
-  dst(0) += *matrix * src;
+  dst(0) += *m * src;
 }
 
 
@@ -1021,28 +897,10 @@ PointerMatrixVector<number>::Tvmult_add (
   Vector<number> &dst,
   const Vector<number> &src) const
 {
-  Assert (matrix != 0, ExcNotInitialized());
+  Assert (m != 0, ExcNotInitialized());
   Assert(src.size() == 1, ExcDimensionMismatch(src.size(), 1));
 
-  dst.add (src(0), *matrix);
-}
-
-
-template<typename number>
-inline typename PointerMatrixVector<number>::size_type
-PointerMatrixVector<number>::m () const
-{
-  Assert (matrix != 0, ExcNotInitialized());
-  return matrix->m();
-}
-
-
-template<typename number>
-inline typename PointerMatrixVector<number>::size_type
-PointerMatrixVector<number>::n () const
-{
-  Assert (matrix != 0, ExcNotInitialized());
-  return matrix->n();
+  dst.add (src(0), *m);
 }