]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Get rid of duplicate information.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 9 Jun 2004 18:09:12 +0000 (18:09 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 9 Jun 2004 18:09:12 +0000 (18:09 +0000)
git-svn-id: https://svn.dealii.org/trunk@9416 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/lac/include/lac/block_vector.templates.h
deal.II/lac/include/lac/block_vector_base.h
deal.II/lac/include/lac/petsc_block_vector.h
deal.II/lac/include/lac/petsc_parallel_block_vector.h
deal.II/lac/source/petsc_parallel_block_vector.cc

index 0f962dfd837a060f77e14648b1f655032111b066..51c252940f374100b1ed2db7d54540290d0fdb85 100644 (file)
@@ -42,11 +42,10 @@ BlockVector<Number>::BlockVector (const BlockVector<Number>& v)
                 :
                 BlockVectorBase<Vector<Number> > ()
 {
-  this->components.resize (v.num_blocks);
+  this->components.resize (v.n_blocks());
   this->block_indices = v.block_indices;
-  this->num_blocks = v.num_blocks;
   
-  for (unsigned int i=0; i<this->num_blocks; ++i)
+  for (unsigned int i=0; i<this->n_blocks(); ++i)
     this->components[i] = v.components[i];
 }
 
@@ -78,11 +77,10 @@ void BlockVector<Number>::reinit (const std::vector<unsigned int> &n,
                                  const bool                       fast)
 {
   this->block_indices.reinit (n);
-  this->num_blocks = n.size();
-  if (this->components.size() != this->num_blocks)
-    this->components.resize(this->num_blocks);
+  if (this->components.size() != this->n_blocks())
+    this->components.resize(this->n_blocks());
   
-  for (unsigned int i=0; i<this->num_blocks; ++i)
+  for (unsigned int i=0; i<this->n_blocks(); ++i)
     this->components[i].reinit(n[i], fast);
 }
 
@@ -93,11 +91,10 @@ void BlockVector<Number>::reinit (const BlockVector<Number2>& v,
                                   const bool fast)
 {
   this->block_indices = v.get_block_indices();
-  this->num_blocks = v.n_blocks();
-  if (this->components.size() != this->num_blocks)
-    this->components.resize(this->num_blocks);
+  if (this->components.size() != this->n_blocks())
+    this->components.resize(this->n_blocks());
   
-  for (unsigned int i=0;i<this->num_blocks;++i)
+  for (unsigned int i=0;i<this->n_blocks();++i)
     this->block(i).reinit(v.block(i), fast);
 }
 
@@ -111,10 +108,10 @@ BlockVector<Number>::~BlockVector ()
 template <typename Number>
 void BlockVector<Number>::swap (BlockVector<Number> &v)
 {
-  Assert (this->num_blocks == v.num_blocks,
-         ExcDimensionMismatch(this->num_blocks, v.num_blocks));
+  Assert (this->n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0; i<this->num_blocks; ++i)
+  for (unsigned int i=0; i<this->n_blocks(); ++i)
     ::swap (this->components[i], v.components[i]);
   ::swap (this->block_indices, v.block_indices);
 }
@@ -127,7 +124,7 @@ void BlockVector<Number>::print (std::ostream       &out,
                                 const bool          scientific,
                                 const bool          across) const
 {
-  for (unsigned int i=0;i<this->num_blocks;++i)
+  for (unsigned int i=0;i<this->n_blocks();++i)
     {
       if (across)
        out << 'C' << i << ':';
@@ -142,7 +139,7 @@ void BlockVector<Number>::print (std::ostream       &out,
 template <typename Number>
 void BlockVector<Number>::block_write (std::ostream &out) const
 {
-  for (unsigned int i=0;i<this->num_blocks;++i)
+  for (unsigned int i=0;i<this->n_blocks();++i)
     this->components[i].block_write(out);
 }
 
@@ -151,7 +148,7 @@ void BlockVector<Number>::block_write (std::ostream &out) const
 template <typename Number>
 void BlockVector<Number>::block_read (std::istream &in)
 {
-  for (unsigned int i=0;i<this->num_blocks;++i)
+  for (unsigned int i=0;i<this->n_blocks();++i)
     this->components[i].block_read(in);
 }
 
@@ -160,7 +157,7 @@ template <typename Number>
 unsigned int
 BlockVector<Number>::memory_consumption () const
 {
-  unsigned int mem = sizeof(this->num_blocks);
+  unsigned int mem = sizeof(this->n_blocks());
   for (unsigned int i=0; i<this->components.size(); ++i)
     mem += MemoryConsumption::memory_consumption (this->components[i]);
   mem += MemoryConsumption::memory_consumption (this->block_indices);
index 16b518b37c7c1beb2c0539e690cce2fdc835c976..c50253448d6f1356aa4c5766f71f9dc83711860e 100644 (file)
@@ -995,14 +995,6 @@ class BlockVectorBase
                                      * different blocks.
                                      */
     BlockIndices block_indices;
-    
-                                    /**
-                                     * The number of blocks. This
-                                     * number is redundant to
-                                     * <tt>components.size()</tt> and stored
-                                     * here for convenience.
-                                     */
-    unsigned int num_blocks;
 
                                     /**
                                      * Make the iterator class a
@@ -1616,7 +1608,7 @@ inline
 unsigned int
 BlockVectorBase<VectorType>::n_blocks () const
 {
-  return num_blocks;
+  return block_indices.size();
 }
 
 
@@ -1625,7 +1617,7 @@ inline
 typename BlockVectorBase<VectorType>::BlockType &
 BlockVectorBase<VectorType>::block (const unsigned int i)
 {
-  Assert(i<num_blocks, ExcIndexRange(i,0,num_blocks));
+  Assert(i<n_blocks(), ExcIndexRange(i,0,n_blocks()));
 
   return components[i];
 }
@@ -1637,7 +1629,7 @@ inline
 const typename BlockVectorBase<VectorType>::BlockType &
 BlockVectorBase<VectorType>::block (const unsigned int i) const
 {
-  Assert(i<num_blocks, ExcIndexRange(i,0,num_blocks));
+  Assert(i<n_blocks(), ExcIndexRange(i,0,n_blocks()));
 
   return components[i];
 }
@@ -1658,9 +1650,9 @@ inline
 void
 BlockVectorBase<VectorType>::collect_sizes ()
 {
-  std::vector<unsigned int> sizes (num_blocks);
+  std::vector<unsigned int> sizes (n_blocks());
 
-  for (unsigned int i=0; i<num_blocks; ++i)
+  for (unsigned int i=0; i<n_blocks(); ++i)
     sizes[i] = block(i).size();
 
   block_indices.reinit(sizes);
@@ -1684,7 +1676,7 @@ inline
 void
 BlockVectorBase<VectorType>::clear ()
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i].clear();
 }
 
@@ -1734,7 +1726,7 @@ template <class VectorType>
 bool
 BlockVectorBase<VectorType>::all_zero () const
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     if (components[i].all_zero() == false)
       return false;
 
@@ -1747,7 +1739,7 @@ template <class VectorType>
 bool
 BlockVectorBase<VectorType>::is_non_negative () const
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     if (components[i].is_non_negative() == false)
       return false;
 
@@ -1761,11 +1753,11 @@ typename BlockVectorBase<VectorType>::value_type
 BlockVectorBase<VectorType>::
 operator * (const BlockVectorBase<VectorType>& v) const
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
   value_type sum = 0.;
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     sum += components[i]*v.components[i];
     
   return sum;
@@ -1777,7 +1769,7 @@ typename BlockVectorBase<VectorType>::value_type
 BlockVectorBase<VectorType>::norm_sqr () const
 {
   value_type sum = 0.;
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     sum += components[i].norm_sqr();
     
   return sum;
@@ -1790,7 +1782,7 @@ typename BlockVectorBase<VectorType>::value_type
 BlockVectorBase<VectorType>::mean_value () const
 {
   value_type sum = 0.;
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     sum += components[i].mean_value() * components[i].size();
   
   return sum/size();
@@ -1803,7 +1795,7 @@ typename BlockVectorBase<VectorType>::value_type
 BlockVectorBase<VectorType>::l1_norm () const
 {
   value_type sum = 0.;
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     sum += components[i].l1_norm();
     
   return sum;
@@ -1825,7 +1817,7 @@ typename BlockVectorBase<VectorType>::value_type
 BlockVectorBase<VectorType>::linfty_norm () const
 {
   value_type sum = 0.;
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       value_type newval = components[i].linfty_norm();
       if (sum<newval)
@@ -1850,10 +1842,10 @@ template <class VectorType>
 BlockVectorBase<VectorType> &
 BlockVectorBase<VectorType>::operator -= (const BlockVectorBase<VectorType>& v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i] -= v.components[i];
     }
@@ -1865,7 +1857,7 @@ BlockVectorBase<VectorType>::operator -= (const BlockVectorBase<VectorType>& v)
 template <class VectorType>
 void BlockVectorBase<VectorType>::add (const value_type a)
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].add(a);
     }
@@ -1876,10 +1868,10 @@ void BlockVectorBase<VectorType>::add (const value_type a)
 template <class VectorType>
 void BlockVectorBase<VectorType>::add (const BlockVectorBase<VectorType>& v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].add(v.components[i]);
     }
@@ -1891,10 +1883,10 @@ template <class VectorType>
 void BlockVectorBase<VectorType>::add (const value_type a,
                                        const BlockVectorBase<VectorType>& v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].add(a, v.components[i]);
     }
@@ -1908,13 +1900,13 @@ void BlockVectorBase<VectorType>::add (const value_type a,
                                        const value_type b,
                                        const BlockVectorBase<VectorType>& w)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
-  Assert (num_blocks == w.num_blocks,
-         ExcDimensionMismatch(num_blocks, w.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+  Assert (n_blocks() == w.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), w.n_blocks()));
   
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].add(a, v.components[i], b, w.components[i]);
     }
@@ -1926,10 +1918,10 @@ template <class VectorType>
 void BlockVectorBase<VectorType>::sadd (const value_type x,
                                         const BlockVectorBase<VectorType>& v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].sadd(x, v.components[i]);
     }
@@ -1941,10 +1933,10 @@ template <class VectorType>
 void BlockVectorBase<VectorType>::sadd (const value_type x, const value_type a,
                                         const BlockVectorBase<VectorType>& v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].sadd(x, a, v.components[i]);
     }
@@ -1958,12 +1950,12 @@ void BlockVectorBase<VectorType>::sadd (const value_type x, const value_type a,
                                         const value_type b,
                                         const BlockVectorBase<VectorType>& w)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
-  Assert (num_blocks == w.num_blocks,
-         ExcDimensionMismatch(num_blocks, w.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+  Assert (n_blocks() == w.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), w.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].sadd(x, a, v.components[i], b, w.components[i]);
     }
@@ -1979,14 +1971,14 @@ void BlockVectorBase<VectorType>::sadd (const value_type x, const value_type a,
                                         const value_type c,
                                         const BlockVectorBase<VectorType>& y)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));  
-  Assert (num_blocks == w.num_blocks,
-         ExcDimensionMismatch(num_blocks, w.num_blocks));
-  Assert (num_blocks == y.num_blocks,
-         ExcDimensionMismatch(num_blocks, y.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));  
+  Assert (n_blocks() == w.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), w.n_blocks()));
+  Assert (n_blocks() == y.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), y.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].sadd(x, a, v.components[i],
                         b, w.components[i], c, y.components[i]);
@@ -1999,9 +1991,9 @@ template <class VectorType>
 template <class BlockVector2>
 void BlockVectorBase<VectorType>::scale (const BlockVector2 &v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
-  for (unsigned int i=0;i<num_blocks;++i)
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i].scale(v.block(i));
 }
 
@@ -2013,12 +2005,12 @@ void BlockVectorBase<VectorType>::equ (const value_type a,
                                        const value_type b,
                                        const BlockVectorBase<VectorType>& w)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
-  Assert (num_blocks == w.num_blocks,
-         ExcDimensionMismatch(num_blocks, w.num_blocks));  
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+  Assert (n_blocks() == w.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), w.n_blocks()));  
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i].equ( a, v.components[i], b, w.components[i]);
     }
@@ -2030,10 +2022,10 @@ template <class BlockVector2>
 void BlockVectorBase<VectorType>::equ (const value_type    a,
                                        const BlockVector2 &v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i].equ( a, v.components[i]);
 }
 
@@ -2042,7 +2034,7 @@ template <class VectorType>
 BlockVectorBase<VectorType>&
 BlockVectorBase<VectorType>::operator = (const value_type s)
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i] = s;
     
   return *this;
@@ -2053,10 +2045,10 @@ template <class VectorType>
 BlockVectorBase<VectorType>&
 BlockVectorBase<VectorType>::operator = (const BlockVectorBase<VectorType>& v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     {
       components[i] = v.components[i];
     }
@@ -2069,10 +2061,10 @@ template <class VectorType2>
 BlockVectorBase<VectorType>&
 BlockVectorBase<VectorType>::operator = (const BlockVectorBase<VectorType2> &v)
 {
-  Assert (num_blocks == v.num_blocks,
-         ExcDimensionMismatch(num_blocks, v.num_blocks));
+  Assert (n_blocks() == v.n_blocks(),
+         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i] = v.components[i];
   
   return *this;
@@ -2090,7 +2082,7 @@ operator == (const BlockVectorBase<VectorType2> &v) const
   Assert (block_indices == v.block_indices,
           ExcNotmatchingBlockSizes());
   
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     if ( ! (components[i] == v.components[i]))
       return false;
 
@@ -2104,7 +2096,7 @@ inline
 BlockVectorBase<VectorType> &
 BlockVectorBase<VectorType>::operator *= (const value_type factor)
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i] *= factor;
 
   return *this;
@@ -2117,7 +2109,7 @@ inline
 BlockVectorBase<VectorType> &
 BlockVectorBase<VectorType>::operator /= (const value_type factor)
 {
-  for (unsigned int i=0;i<num_blocks;++i)
+  for (unsigned int i=0;i<n_blocks();++i)
     components[i] /= factor;
 
   return *this;
index b1094f51c3bf4866b9c36bf73ac28abd124025b0..9c921609a8b3ad4a1f3e02981d06f1fd8edec395 100644 (file)
@@ -320,12 +320,11 @@ namespace PETScWrappers
                   :
                   BlockVectorBase<Vector > ()
   {
-    components.resize (v.num_blocks);
+    this->components.resize (v.n_blocks());
     block_indices = v.block_indices;
-    num_blocks = v.num_blocks;
   
-    for (unsigned int i=0; i<num_blocks; ++i)
-      components[i] = v.components[i];
+    for (unsigned int i=0; i<this->n_blocks(); ++i)
+      this->components[i] = v.components[i];
   }
 
 
@@ -335,12 +334,11 @@ namespace PETScWrappers
                   :
                   BlockVectorBase<Vector > ()
   {
-    components.resize (v.get_block_indices().size());
+    this->components.resize (v.get_block_indices().size());
     block_indices = v.get_block_indices();
-    num_blocks = block_indices.size();
   
-    for (unsigned int i=0; i<num_blocks; ++i)
-      components[i] = v.block(i);
+    for (unsigned int i=0; i<this->n_blocks(); ++i)
+      this->components[i] = v.block(i);
   }
 
   
@@ -421,12 +419,11 @@ namespace PETScWrappers
                        const bool                       fast)
   {
     block_indices.reinit (n);
-    num_blocks = n.size();
-    if (components.size() != num_blocks)
-      components.resize(num_blocks);
+    if (this->components.size() != this->n_blocks())
+      this->components.resize(this->n_blocks());
   
-    for (unsigned int i=0; i<num_blocks; ++i)
-      components[i].reinit(n[i], fast);
+    for (unsigned int i=0; i<this->n_blocks(); ++i)
+      this->components[i].reinit(n[i], fast);
   }
 
 
@@ -436,11 +433,10 @@ namespace PETScWrappers
                        const bool fast)
   {
     block_indices = v.get_block_indices();
-    num_blocks = v.n_blocks();
-    if (components.size() != num_blocks)
-      components.resize(num_blocks);
+    if (this->components.size() != this->n_blocks())
+      this->components.resize(this->n_blocks());
   
-    for (unsigned int i=0;i<num_blocks;++i)
+    for (unsigned int i=0;i<this->n_blocks();++i)
       block(i).reinit(v.block(i), fast);
   }
 
@@ -450,12 +446,12 @@ namespace PETScWrappers
   void
   BlockVector::swap (BlockVector &v)
   {
-    Assert (num_blocks == v.num_blocks,
-            ExcDimensionMismatch(num_blocks, v.num_blocks));
+    Assert (this->n_blocks() == v.n_blocks(),
+            ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
   
-    for (unsigned int i=0; i<num_blocks; ++i)
-      components[i].swap (v.components[i]);
-    ::swap (block_indices, v.block_indices);
+    for (unsigned int i=0; i<this->n_blocks(); ++i)
+      this->components[i].swap (v.components[i]);
+    ::swap (this->block_indices, v.block_indices);
   }
 
 
index 4fb6d077953a5546128402d2c5c06b6944d59f58..84834506b29a6eb826fa8e29ea9df0d591c15dbe 100644 (file)
@@ -346,12 +346,11 @@ namespace PETScWrappers
                     :
                     BlockVectorBase<Vector > ()
     {
-      components.resize (v.num_blocks);
-      block_indices = v.block_indices;
-      num_blocks = v.num_blocks;
+      this->components.resize (v.n_blocks());
+      this->block_indices = v.block_indices;
     
-      for (unsigned int i=0; i<num_blocks; ++i)
-        components[i] = v.components[i];
+      for (unsigned int i=0; i<this->n_blocks(); ++i)
+        this->components[i] = v.components[i];
     }
 
 
@@ -404,13 +403,12 @@ namespace PETScWrappers
                          const std::vector<unsigned int> &local_sizes,
                          const bool                       fast)
     {
-      block_indices.reinit (block_sizes);
-      num_blocks = block_sizes.size();
-      if (components.size() != num_blocks)
-        components.resize(num_blocks);
+      this->block_indices.reinit (block_sizes);
+      if (this->components.size() != this->n_blocks())
+        this->components.resize(this->n_blocks());
   
-      for (unsigned int i=0; i<num_blocks; ++i)
-        components[i].reinit(communicator, block_sizes[i],
+      for (unsigned int i=0; i<this->n_blocks(); ++i)
+        this->components[i].reinit(communicator, block_sizes[i],
                              local_sizes[i], fast);
     }
 
@@ -420,12 +418,11 @@ namespace PETScWrappers
     BlockVector::reinit (const BlockVector& v,
                          const bool fast)
     {
-      block_indices = v.get_block_indices();
-      num_blocks = v.n_blocks();
-      if (components.size() != num_blocks)
-        components.resize(num_blocks);
+      this->block_indices = v.get_block_indices();
+      if (this->components.size() != this->n_blocks())
+        this->components.resize(this->n_blocks());
   
-      for (unsigned int i=0;i<num_blocks;++i)
+      for (unsigned int i=0;i<this->n_blocks();++i)
         block(i).reinit(v.block(i), fast);
     }
 
@@ -444,12 +441,12 @@ namespace PETScWrappers
     void
     BlockVector::swap (BlockVector &v)
     {
-      Assert (num_blocks == v.num_blocks,
-              ExcDimensionMismatch(num_blocks, v.num_blocks));
+      Assert (this->n_blocks() == v.n_blocks(),
+              ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
   
-      for (unsigned int i=0; i<num_blocks; ++i)
-        components[i].swap (v.components[i]);
-      ::swap (block_indices, v.block_indices);
+      for (unsigned int i=0; i<this->n_blocks(); ++i)
+        this->components[i].swap (v.components[i]);
+      ::swap (this->block_indices, v.block_indices);
     }
 
   
index 8817d718b9f696ccd99dc3d8b6c325ff095b4639..7ff4e71dec5cfd9f1a1e138867fc4e236b8083ce 100644 (file)
@@ -29,8 +29,8 @@ namespace PETScWrappers
       Assert (v.get_block_indices() == this->get_block_indices(),
               ExcNonMatchingBlockVectors());
 
-      for (unsigned int i=0; i<num_blocks; ++i)
-        block(i) = v.block(i);
+      for (unsigned int i=0; i<this->n_blocks(); ++i)
+        this->block(i) = v.block(i);
       
       return *this;
     }

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.