Reference documentation for deal.II version 8.1.0
pointer_matrix.h
1 // ---------------------------------------------------------------------
2 // @f$Id: pointer_matrix.h 31847 2013-12-03 04:36:55Z bangerth @f$
3 //
4 // Copyright (C) 2002 - 2013 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // The deal.II library is free software; you can use it, redistribute
9 // it, and/or modify it under the terms of the GNU Lesser General
10 // Public License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
12 // The full text of the license can be found in the file LICENSE at
13 // the top level of the deal.II distribution.
14 //
15 // ---------------------------------------------------------------------
16 
17 #ifndef __deal2__pointer_matrix_h
18 #define __deal2__pointer_matrix_h
19 
20 #include <deal.II/base/subscriptor.h>
21 #include <deal.II/base/smartpointer.h>
22 #include <deal.II/lac/vector.h>
23 #include <deal.II/lac/vector_memory.h>
24 
26 
27 template<class VECTOR> class VectorMemory;
28 
29 class IdentityMatrix;
30 template <typename number> class FullMatrix;
31 template <typename number> class LAPACKFullMatrix;
32 template <typename number> class SparseMatrix;
33 template <typename number> class BlockSparseMatrix;
34 template <typename number> class SparseMatrixEZ;
35 template <typename number> class BlockSparseMatrixEZ;
36 template <typename number> class BlockMatrixArray;
37 template <typename number> class TridiagonalMatrix;
38 
39 
52 template<class VECTOR>
54 {
55 public:
70  typedef typename VECTOR::value_type value_type;
71 
78  virtual ~PointerMatrixBase ();
79 
84  virtual void clear () = 0;
85 
90  bool operator == (const PointerMatrixBase<VECTOR> &) const;
91 
96  bool operator != (const PointerMatrixBase<VECTOR> &) const;
97 
102  bool operator < (const PointerMatrixBase<VECTOR> &) const;
103 
108  bool operator <= (const PointerMatrixBase<VECTOR> &) const;
109 
114  bool operator > (const PointerMatrixBase<VECTOR> &) const;
115 
120  bool operator >= (const PointerMatrixBase<VECTOR> &) const;
121 
122 
126  virtual void vmult (VECTOR &dst,
127  const VECTOR &src) const = 0;
128 
132  virtual void Tvmult (VECTOR &dst,
133  const VECTOR &src) const = 0;
134 
139  virtual void vmult_add (VECTOR &dst,
140  const VECTOR &src) const = 0;
141 
146  virtual void Tvmult_add (VECTOR &dst,
147  const VECTOR &src) const = 0;
148 
149 private:
153  virtual const void *get() const = 0;
154 };
155 
166 template<class MATRIX, class VECTOR>
167 class PointerMatrix : public PointerMatrixBase<VECTOR>
168 {
169 public:
180  PointerMatrix (const MATRIX *M=0);
181 
187  PointerMatrix(const char *name);
188 
198  PointerMatrix(const MATRIX *M,
199  const char *name);
200 
201  // Use doc from base class
202  virtual void clear();
203 
208  bool empty () const;
209 
216  const PointerMatrix &operator= (const MATRIX *M);
217 
221  virtual void vmult (VECTOR &dst,
222  const VECTOR &src) const;
223 
227  virtual void Tvmult (VECTOR &dst,
228  const VECTOR &src) const;
229 
234  virtual void vmult_add (VECTOR &dst,
235  const VECTOR &src) const;
236 
241  virtual void Tvmult_add (VECTOR &dst,
242  const VECTOR &src) const;
243 
244 private:
249  virtual const void *get() const;
250 
255 };
256 
257 
273 template<class MATRIX, class VECTOR>
274 class PointerMatrixAux : public PointerMatrixBase<VECTOR>
275 {
276 public:
292  const MATRIX *M=0);
293 
301  const char *name);
302 
313  const MATRIX *M,
314  const char *name);
315 
316  // Use doc from base class
317  virtual void clear();
318 
323  bool empty () const;
324 
330  void set_memory(VectorMemory<VECTOR> *mem);
331 
338  const PointerMatrixAux &operator= (const MATRIX *M);
339 
343  virtual void vmult (VECTOR &dst,
344  const VECTOR &src) const;
345 
349  virtual void Tvmult (VECTOR &dst,
350  const VECTOR &src) const;
351 
356  virtual void vmult_add (VECTOR &dst,
357  const VECTOR &src) const;
358 
363  virtual void Tvmult_add (VECTOR &dst,
364  const VECTOR &src) const;
365 
366 private:
371  virtual const void *get() const;
372 
377 
383 
388 };
389 
390 
391 
403 template <typename number>
404 class PointerMatrixVector : public PointerMatrixBase<Vector<number> >
405 {
406 public:
417  PointerMatrixVector (const Vector<number> *M=0);
418 
424  PointerMatrixVector (const char *name);
425 
436  const char *name);
437 
438  // Use doc from base class
439  virtual void clear();
440 
445  bool empty () const;
446 
454 
467  virtual void vmult (Vector<number> &dst,
468  const Vector<number> &src) const;
469 
483  virtual void Tvmult (Vector<number> &dst,
484  const Vector<number> &src) const;
485 
496  virtual void vmult_add (Vector<number> &dst,
497  const Vector<number> &src) const;
498 
509  virtual void Tvmult_add (Vector<number> &dst,
510  const Vector<number> &src) const;
511 
512 private:
517  virtual const void *get() const;
518 
523 };
524 
525 
526 
546 template <class VECTOR, class MATRIX>
547 inline
549 new_pointer_matrix_base(MATRIX &matrix, const VECTOR &, const char *name = "PointerMatrixAux")
550 {
551  return new PointerMatrixAux<MATRIX, VECTOR>(0, &matrix, name);
552 }
553 
560 template <typename numberv>
562 new_pointer_matrix_base(const IdentityMatrix &matrix, const Vector<numberv> &, const char *name = "PointerMatrix")
563 {
564  return new PointerMatrix<IdentityMatrix, Vector<numberv> >(&matrix, name);
565 }
566 
567 
574 template <typename numberv, typename numberm>
576 new_pointer_matrix_base(const FullMatrix<numberm> &matrix, const Vector<numberv> &, const char *name = "PointerMatrix")
577 {
578  return new PointerMatrix<FullMatrix<numberm>, Vector<numberv> >(&matrix, name);
579 }
580 
581 
588 template <typename numberv, typename numberm>
590 new_pointer_matrix_base(const LAPACKFullMatrix<numberm> &matrix, const Vector<numberv> &, const char *name = "PointerMatrix")
591 {
592  return new PointerMatrix<LAPACKFullMatrix<numberm>, Vector<numberv> >(&matrix, name);
593 }
594 
595 
602 template <typename numberv, typename numberm>
604 new_pointer_matrix_base(const SparseMatrix<numberm> &matrix, const Vector<numberv> &, const char *name = "PointerMatrix")
605 {
606  return new PointerMatrix<SparseMatrix<numberm>, Vector<numberv> >(&matrix, name);
607 }
608 
609 
616 template <class VECTOR, typename numberm>
618 new_pointer_matrix_base(const BlockSparseMatrix<numberm> &matrix, const VECTOR &, const char *name = "PointerMatrix")
619 {
620  return new PointerMatrix<BlockSparseMatrix<numberm>, VECTOR>(&matrix, name);
621 }
622 
623 
630 template <typename numberv, typename numberm>
632 new_pointer_matrix_base(const SparseMatrixEZ<numberm> &matrix, const Vector<numberv> &, const char *name = "PointerMatrix")
633 {
634  return new PointerMatrix<SparseMatrixEZ<numberm>, Vector<numberv> >(&matrix, name);
635 }
636 
637 
644 template <class VECTOR, typename numberm>
646 new_pointer_matrix_base(const BlockSparseMatrixEZ<numberm> &matrix, const VECTOR &, const char *name = "PointerMatrix")
647 {
648  return new PointerMatrix<BlockSparseMatrixEZ<numberm>, VECTOR>(&matrix, name);
649 }
650 
651 
658 template <typename numberv, typename numberm>
660 new_pointer_matrix_base(const BlockMatrixArray<numberm> &matrix, const BlockVector<numberv> &, const char *name = "PointerMatrix")
661 {
663 }
664 
665 
672 template <typename numberv, typename numberm>
674 new_pointer_matrix_base(const TridiagonalMatrix<numberm> &matrix, const Vector<numberv> &, const char *name = "PointerMatrix")
675 {
676  return new PointerMatrix<TridiagonalMatrix<numberm>, Vector<numberv> >(&matrix, name);
677 }
678 
679 
680 
682 //---------------------------------------------------------------------------
683 
684 template<class VECTOR>
685 inline
687 {}
688 
689 
690 
691 template<class VECTOR>
692 inline
693 bool
695 {
696  return (get() == other.get());
697 }
698 
699 
700 
701 template<class VECTOR>
702 inline
703 bool
705 {
706  return (get() != other.get());
707 }
708 
709 
710 
711 template<class VECTOR>
712 inline
713 bool
715 {
716  return (get() < other.get());
717 }
718 
719 
720 
721 template<class VECTOR>
722 inline
723 bool
725 {
726  return (get() <= other.get());
727 }
728 
729 
730 
731 template<class VECTOR>
732 inline
733 bool
735 {
736  return (get() > other.get());
737 }
738 
739 
740 
741 template<class VECTOR>
742 inline
743 bool
745 {
746  return (get() >= other.get());
747 }
748 
749 
750 //----------------------------------------------------------------------//
751 
752 
753 template<class MATRIX, class VECTOR>
755  : m(M, typeid(*this).name())
756 {}
757 
758 
759 template<class MATRIX, class VECTOR>
761  : m(0, name)
762 {}
763 
764 
765 template<class MATRIX, class VECTOR>
767  const MATRIX *M,
768  const char *name)
769  : m(M, name)
770 {}
771 
772 
773 template<class MATRIX, class VECTOR>
774 inline void
776 {
777  m = 0;
778 }
779 
780 
781 template<class MATRIX, class VECTOR>
782 inline const PointerMatrix<MATRIX, VECTOR> &
784 {
785  m = M;
786  return *this;
787 }
788 
789 
790 template<class MATRIX, class VECTOR>
791 inline bool
793 {
794  if (m == 0)
795  return true;
796  return m->empty();
797 }
798 
799 template<class MATRIX, class VECTOR>
800 inline void
802  const VECTOR &src) const
803 {
804  Assert (m != 0, ExcNotInitialized());
805  m->vmult (dst, src);
806 }
807 
808 
809 template<class MATRIX, class VECTOR>
810 inline void
812  const VECTOR &src) const
813 {
814  Assert (m != 0, ExcNotInitialized());
815  m->Tvmult (dst, src);
816 }
817 
818 
819 template<class MATRIX, class VECTOR>
820 inline void
822  const VECTOR &src) const
823 {
824  Assert (m != 0, ExcNotInitialized());
825  m->vmult_add (dst, src);
826 }
827 
828 
829 template<class MATRIX, class VECTOR>
830 inline void
832  const VECTOR &src) const
833 {
834  Assert (m != 0, ExcNotInitialized());
835  m->Tvmult_add (dst, src);
836 }
837 
838 
839 template<class MATRIX, class VECTOR>
840 inline const void *
842 {
843  return m;
844 }
845 
846 
847 //----------------------------------------------------------------------//
848 
849 
850 template<class MATRIX, class VECTOR>
853  const MATRIX *M)
854  : mem(mem, typeid(*this).name()),
855  m(M, typeid(*this).name())
856 {
857  if (mem == 0) mem = &my_memory;
858 }
859 
860 
861 template<class MATRIX, class VECTOR>
864  const char *name)
865  : mem(mem, name),
866  m(0, name)
867 {
868  if (mem == 0) mem = &my_memory;
869 }
870 
871 
872 template<class MATRIX, class VECTOR>
875  const MATRIX *M,
876  const char *name)
877  : mem(mem, name),
878  m(M, name)
879 {
880  if (mem == 0) mem = &my_memory;
881 }
882 
883 
884 template<class MATRIX, class VECTOR>
885 inline void
887 {
888  m = 0;
889 }
890 
891 
892 template<class MATRIX, class VECTOR>
895 {
896  m = M;
897  return *this;
898 }
899 
900 
901 template<class MATRIX, class VECTOR>
902 inline void
904 {
905  mem = M;
906  if (mem == 0)
907  mem = &my_memory;
908 }
909 
910 
911 template<class MATRIX, class VECTOR>
912 inline bool
914 {
915  if (m == 0)
916  return true;
917  return m->empty();
918 }
919 
920 template<class MATRIX, class VECTOR>
921 inline void
923  const VECTOR &src) const
924 {
925  if (mem == 0)
926  mem = &my_memory;
927  Assert (mem != 0, ExcNotInitialized());
928  Assert (m != 0, ExcNotInitialized());
929  m->vmult (dst, src);
930 }
931 
932 
933 template<class MATRIX, class VECTOR>
934 inline void
936  const VECTOR &src) const
937 {
938  if (mem == 0)
939  mem = &my_memory;
940  Assert (mem != 0, ExcNotInitialized());
941  Assert (m != 0, ExcNotInitialized());
942  m->Tvmult (dst, src);
943 }
944 
945 
946 template<class MATRIX, class VECTOR>
947 inline void
949  const VECTOR &src) const
950 {
951  if (mem == 0)
952  mem = &my_memory;
953  Assert (mem != 0, ExcNotInitialized());
954  Assert (m != 0, ExcNotInitialized());
955  VECTOR *v = mem->alloc();
956  v->reinit(dst);
957  m->vmult (*v, src);
958  dst += *v;
959  mem->free(v);
960 }
961 
962 
963 template<class MATRIX, class VECTOR>
964 inline void
966  const VECTOR &src) const
967 {
968  if (mem == 0)
969  mem = &my_memory;
970  Assert (mem != 0, ExcNotInitialized());
971  Assert (m != 0, ExcNotInitialized());
972  VECTOR *v = mem->alloc();
973  v->reinit(dst);
974  m->Tvmult (*v, src);
975  dst += *v;
976  mem->free(v);
977 }
978 
979 
980 template<class MATRIX, class VECTOR>
981 inline const void *
983 {
984  return m;
985 }
986 
987 
988 //----------------------------------------------------------------------//
989 
990 
991 template<typename number>
993  : m(M, typeid(*this).name())
994 {}
995 
996 
997 template<typename number>
999  : m(0, name)
1000 {}
1001 
1002 
1003 template<typename number>
1005  const Vector<number> *M,
1006  const char *name)
1007  : m(M, name)
1008 {}
1009 
1010 
1011 template<typename number>
1012 inline void
1014 {
1015  m = 0;
1016 }
1017 
1018 
1019 template<typename number>
1020 inline const PointerMatrixVector<number> &
1022 {
1023  m = M;
1024  return *this;
1025 }
1026 
1027 
1028 template<typename number>
1029 inline bool
1031 {
1032  if (m == 0)
1033  return true;
1034  return m->empty();
1035 }
1036 
1037 template<typename number>
1038 inline void
1040  Vector<number> &dst,
1041  const Vector<number> &src) const
1042 {
1043  Assert (m != 0, ExcNotInitialized());
1044  Assert (dst.size() == 1, ExcDimensionMismatch(dst.size(), 1));
1045 
1046  dst(0) = *m * src;
1047 }
1048 
1049 
1050 template<typename number>
1051 inline void
1053  Vector<number> &dst,
1054  const Vector<number> &src) const
1055 {
1056  Assert (m != 0, ExcNotInitialized());
1057  Assert(src.size() == 1, ExcDimensionMismatch(src.size(), 1));
1058 
1059  dst.equ (src(0), *m);
1060 }
1061 
1062 
1063 template<typename number>
1064 inline void
1066  Vector<number> &dst,
1067  const Vector<number> &src) const
1068 {
1069  Assert (m != 0, ExcNotInitialized());
1070  Assert (dst.size() == 1, ExcDimensionMismatch(dst.size(), 1));
1071 
1072  dst(0) += *m * src;
1073 }
1074 
1075 
1076 template<typename number>
1077 inline void
1079  Vector<number> &dst,
1080  const Vector<number> &src) const
1081 {
1082  Assert (m != 0, ExcNotInitialized());
1083  Assert(src.size() == 1, ExcDimensionMismatch(src.size(), 1));
1084 
1085  dst.add (src(0), *m);
1086 }
1087 
1088 
1089 template<typename number>
1090 inline const void *
1092 {
1093  return m;
1094 }
1095 
1096 
1097 
1098 DEAL_II_NAMESPACE_CLOSE
1099 
1100 #endif
SmartPointer< const Vector< number >, PointerMatrixVector< number > > m
virtual void vmult(Vector< number > &dst, const Vector< number > &src) const
virtual void clear()
PointerMatrixBase< VECTOR > * new_pointer_matrix_base(const BlockSparseMatrixEZ< numberm > &matrix, const VECTOR &, const char *name="PointerMatrix")
PointerMatrixBase< VECTOR > * new_pointer_matrix_base(MATRIX &matrix, const VECTOR &, const char *name="PointerMatrixAux")
void Tvmult(VECTOR &u, const VECTOR &v) const
virtual const void * get() const =0
PointerMatrixBase< BlockVector< numberv > > * new_pointer_matrix_base(const BlockMatrixArray< numberm > &matrix, const BlockVector< numberv > &, const char *name="PointerMatrix")
const PointerMatrixAux & operator=(const MATRIX *M)
virtual const void * get() const
void vmult(VECTOR &u, const VECTOR &v) const
PointerMatrixAux(VectorMemory< VECTOR > *mem=0, const MATRIX *M=0)
PointerMatrixBase< Vector< numberv > > * new_pointer_matrix_base(const FullMatrix< numberm > &matrix, const Vector< numberv > &, const char *name="PointerMatrix")
bool operator!=(const PointerMatrixBase< VECTOR > &) const
Subscriptor & operator=(const Subscriptor &)
PointerMatrixBase< Vector< numberv > > * new_pointer_matrix_base(const IdentityMatrix &matrix, const Vector< numberv > &, const char *name="PointerMatrix")
void equ(const Number a, const Vector< Number > &u)
VECTOR::value_type value_type
virtual void Tvmult(Vector< number > &dst, const Vector< number > &src) const
virtual const void * get() const
bool operator>(const PointerMatrixBase< VECTOR > &) const
PointerMatrixVector(const Vector< number > *M=0)
PointerMatrixBase< Vector< numberv > > * new_pointer_matrix_base(const SparseMatrixEZ< numberm > &matrix, const Vector< numberv > &, const char *name="PointerMatrix")
bool empty() const
virtual void Tvmult_add(VECTOR &dst, const VECTOR &src) const
void set_memory(VectorMemory< VECTOR > *mem)
void add(const std::vector< size_type > &indices, const std::vector< OtherNumber > &values)
virtual const void * get() const
virtual ~PointerMatrixBase()
#define Assert(cond, exc)
Definition: exceptions.h:299
bool operator<=(const PointerMatrixBase< VECTOR > &) const
const PointerMatrix & operator=(const MATRIX *M)
virtual void vmult(VECTOR &dst, const VECTOR &src) const
std::size_t size() const
PointerMatrix(const MATRIX *M=0)
virtual void vmult_add(VECTOR &dst, const VECTOR &src) const
virtual void vmult_add(VECTOR &dst, const VECTOR &src) const
void Tvmult_add(VECTOR &u, const VECTOR &v) const
virtual void vmult(VECTOR &dst, const VECTOR &src) const =0
virtual void vmult_add(Vector< number > &dst, const Vector< number > &src) const
virtual void clear()
virtual void clear()
PointerMatrixBase< Vector< numberv > > * new_pointer_matrix_base(const LAPACKFullMatrix< numberm > &matrix, const Vector< numberv > &, const char *name="PointerMatrix")
virtual void Tvmult_add(Vector< number > &dst, const Vector< number > &src) const
virtual void clear()=0
SmartPointer< VectorMemory< VECTOR >, PointerMatrixAux< MATRIX, VECTOR > > mem
virtual void Tvmult(VECTOR &dst, const VECTOR &src) const
const PointerMatrixVector & operator=(const Vector< number > *M)
void vmult_add(VECTOR &u, const VECTOR &v) const
SmartPointer< const MATRIX, PointerMatrix< MATRIX, VECTOR > > m
PointerMatrixBase< Vector< numberv > > * new_pointer_matrix_base(const SparseMatrix< numberm > &matrix, const Vector< numberv > &, const char *name="PointerMatrix")
bool operator==(const PointerMatrixBase< VECTOR > &) const
virtual void vmult_add(VECTOR &dst, const VECTOR &src) const =0
virtual void vmult(VECTOR &dst, const VECTOR &src) const
virtual void Tvmult(VECTOR &dst, const VECTOR &src) const =0
::ExceptionBase & ExcNotInitialized()
::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
PointerMatrixBase< Vector< numberv > > * new_pointer_matrix_base(const TridiagonalMatrix< numberm > &matrix, const Vector< numberv > &, const char *name="PointerMatrix")
GrowingVectorMemory< VECTOR > my_memory
bool operator<(const PointerMatrixBase< VECTOR > &) const
virtual void Tvmult_add(VECTOR &dst, const VECTOR &src) const
virtual void Tvmult(VECTOR &dst, const VECTOR &src) const
PointerMatrixBase< VECTOR > * new_pointer_matrix_base(const BlockSparseMatrix< numberm > &matrix, const VECTOR &, const char *name="PointerMatrix")
virtual void Tvmult_add(VECTOR &dst, const VECTOR &src) const =0
bool empty() const
bool operator>=(const PointerMatrixBase< VECTOR > &) const
SmartPointer< const MATRIX, PointerMatrixAux< MATRIX, VECTOR > > m