]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
introduce ExcNumberNotFinite and test for inifinity in boundary projections
authorkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 14 Oct 2010 15:59:09 +0000 (15:59 +0000)
committerkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 14 Oct 2010 15:59:09 +0000 (15:59 +0000)
git-svn-id: https://svn.dealii.org/trunk@22344 0785d39b-7218-0410-832d-ea1e28bc413d

21 files changed:
deal.II/base/include/base/exceptions.h
deal.II/deal.II/include/multigrid/mg_smoother.h
deal.II/deal.II/include/numerics/vectors.templates.h
deal.II/deal.II/source/numerics/matrices.cc
deal.II/lac/include/lac/block_matrix_base.h
deal.II/lac/include/lac/block_sparse_matrix_ez.h
deal.II/lac/include/lac/block_vector.h
deal.II/lac/include/lac/block_vector_base.h
deal.II/lac/include/lac/chunk_sparse_matrix.h
deal.II/lac/include/lac/constraint_matrix.templates.h
deal.II/lac/include/lac/full_matrix.h
deal.II/lac/include/lac/full_matrix.templates.h
deal.II/lac/include/lac/petsc_matrix_base.h
deal.II/lac/include/lac/sparse_matrix.h
deal.II/lac/include/lac/sparse_matrix.templates.h
deal.II/lac/include/lac/sparse_matrix_ez.h
deal.II/lac/include/lac/trilinos_sparse_matrix.h
deal.II/lac/include/lac/trilinos_vector_base.h
deal.II/lac/include/lac/vector.h
deal.II/lac/include/lac/vector.templates.h
deal.II/lac/source/petsc_vector_base.cc

index 46f2ff52451cca8b048f83261ac1bbc63a7dcdb4..30356c8bd57b9ad895fb8a71758f72486270dfa0 100644 (file)
@@ -640,6 +640,19 @@ namespace StandardExceptions
                                    */
   DeclException0 (ExcDivideByZero);
 
+                                  /**
+                                   * Exception raised if a number is
+                                   * not finite.
+                                   *
+                                   * This exception should be used to
+                                   * catch infinite or not a number
+                                   * results of arithmetic operations
+                                   * that do not result from a
+                                   * division by zero (use
+                                   * ExcDivideByZero for those).
+                                   */
+  DeclException0 (ExcNumberNotFinite);
+  
                                   /**
                                    * Trying to allocate a new
                                    * object failed due to lack of
index 72a7fef192157e3b48ea20bb497973092bf72623..96d660ef49fb59cebc39c924527b8c6f096d3e0b 100644 (file)
@@ -806,6 +806,7 @@ namespace mg
       smoothers[i].initialize(m[i], data[i]);
   }
 
+  
   template <class RELAX, class VECTOR>
   inline void
   SmootherRelaxation<RELAX, VECTOR>::smooth(
index dc34cb5c06c1f9648e2fb68474e5377a9b326012..842b437a44820f8df232a383fa3b6e6c35705e76 100644 (file)
@@ -1945,6 +1945,9 @@ VectorTools::project_boundary_values (const Mapping<dim, spacedim>       &mappin
                                   // have support there. Let's
                                   // eliminate them here.
 
+                                  // The Bogner-Fox-Schmidt element
+                                  // is an example for those.
+
 //TODO: Maybe we should figure out if the element really needs this
 
   FilteredMatrix<Vector<double> > filtered_mass_matrix(mass_matrix, true);
@@ -1988,6 +1991,9 @@ VectorTools::project_boundary_values (const Mapping<dim, spacedim>       &mappin
   for (unsigned int i=0; i<dof_to_boundary_mapping.size(); ++i)
     if (dof_to_boundary_mapping[i] != DoFHandler<dim,spacedim>::invalid_dof_index
     && ! excluded_dofs[dof_to_boundary_mapping[i]])
+      {
+       Assert(numbers::is_finite(boundary_projection(dof_to_boundary_mapping[i])), ExcNumberNotFinite());
+       
                                       // this dof is on one of the
                                       // interesting boundary parts
                                       //
@@ -1995,7 +2001,8 @@ VectorTools::project_boundary_values (const Mapping<dim, spacedim>       &mappin
                                       // number, dof_to_boundary_mapping[i]
                                       // is the number on the boundary and
                                       // thus in the solution vector
-      boundary_values[i] = boundary_projection(dof_to_boundary_mapping[i]);
+       boundary_values[i] = boundary_projection(dof_to_boundary_mapping[i]);
+      }
 }
 
 #endif
@@ -4370,7 +4377,7 @@ namespace internal
             }
                                            // append result of this cell
                                            // to the end of the vector
-          Assert (numbers::is_finite(diff), ExcInternalError());
+          Assert (numbers::is_finite(diff), ExcNumberNotFinite());
           difference(index) = diff;
         }
     }
index 5993e9513e4aae3ec09f7244bb589294bc52bbb6..0c3b0e709c4e2464e61c3821768ffccf04a77099 100644 (file)
@@ -1164,10 +1164,13 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
                {
                  for (unsigned int j=0; j<dofs_per_cell; ++j)
                    if (dof_is_on_face[j] && dof_to_boundary_mapping[dofs[j]] != numbers::invalid_unsigned_int)
-                     matrix.add(dof_to_boundary_mapping[dofs[i]],
-                                dof_to_boundary_mapping[dofs[j]],
-                                cell_matrix(i,j));
-
+                     {
+                       Assert(numbers::is_finite(cell_matrix(i,j)), ExcNumberNotFinite());
+                       matrix.add(dof_to_boundary_mapping[dofs[i]],
+                                  dof_to_boundary_mapping[dofs[j]],
+                                  cell_matrix(i,j));
+                     }
+                 Assert(numbers::is_finite(cell_vector(i)), ExcNumberNotFinite());
                  rhs_vector(dof_to_boundary_mapping[dofs[i]]) += cell_vector(i);
                }
            }
index 963f0eaa15a2816393c5655eac680dc8c86b9fc1..bdda476633dc0743f6262d9bc0b925ba86700c25 100644 (file)
@@ -1814,8 +1814,7 @@ BlockMatrixBase<MatrixType>::set (const unsigned int i,
 {
   prepare_set_operation();
 
-  Assert (numbers::is_finite(value),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   const std::pair<unsigned int,unsigned int>
     row_index = row_block_indices.global_to_local (i),
@@ -1997,8 +1996,7 @@ BlockMatrixBase<MatrixType>::add (const unsigned int i,
                                   const value_type value)
 {
 
-  Assert (numbers::is_finite(value),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   prepare_add_operation();
 
index 66e32f39b2f3eaedc508fec64b58faae19b3b653..793c23de98ffa64a8cd958302cc82bad4990955c 100644 (file)
@@ -423,8 +423,7 @@ BlockSparseMatrixEZ<Number>::set (const unsigned int i,
                                  const Number value)
 {
 
-  Assert (numbers::is_finite(value), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   const std::pair<unsigned int,unsigned int>
     row_index = row_indices.global_to_local (i),
@@ -444,8 +443,7 @@ BlockSparseMatrixEZ<Number>::add (const unsigned int i,
                                  const Number value)
 {
 
-  Assert (numbers::is_finite(value), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   const std::pair<unsigned int,unsigned int>
     row_index = row_indices.global_to_local (i),
index 08cb7a44454cb307d4a1c504894e8009bb7e91c5..c6cc279f14395932ff1e367b679f3bf442001531 100644 (file)
@@ -482,8 +482,7 @@ BlockVector<Number> &
 BlockVector<Number>::operator = (const value_type s)
 {
 
-  Assert (numbers::is_finite(s), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(s), ExcNumberNotFinite());
  
   BaseClass::operator = (s);
   return *this;
@@ -531,8 +530,7 @@ template <typename Number>
 void BlockVector<Number>::scale (const value_type factor)
 {
 
-  Assert (numbers::is_finite(factor), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor), ExcNumberNotFinite());
 
   for (unsigned int i=0; i<this->n_blocks();++i)
     this->components[i].scale(factor);
index 4bd235721b803b9580fdd7c23149213ce95ffe11..ba33570fcd0141b9b7a41805dc36afcab8f4844b 100644 (file)
@@ -2019,8 +2019,7 @@ BlockVectorBase<VectorType>::add (const unsigned int  n_indices,
 template <class VectorType>
 void BlockVectorBase<VectorType>::add (const value_type a)
 {
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
   for (unsigned int i=0;i<n_blocks();++i)
     {
@@ -2049,8 +2048,7 @@ void BlockVectorBase<VectorType>::add (const value_type a,
                                        const BlockVectorBase<VectorType>& v)
 {
 
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2070,10 +2068,8 @@ void BlockVectorBase<VectorType>::add (const value_type a,
                                        const BlockVectorBase<VectorType>& w)
 {
 
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
+  Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2094,8 +2090,7 @@ void BlockVectorBase<VectorType>::sadd (const value_type x,
                                         const BlockVectorBase<VectorType>& v)
 {
 
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2113,10 +2108,8 @@ void BlockVectorBase<VectorType>::sadd (const value_type x, const value_type a,
                                         const BlockVectorBase<VectorType>& v)
 {
 
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x), ExcNumberNotFinite());
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2136,12 +2129,9 @@ void BlockVectorBase<VectorType>::sadd (const value_type x, const value_type a,
                                         const BlockVectorBase<VectorType>& w)
 {
 
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x), ExcNumberNotFinite());
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
+  Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2165,14 +2155,10 @@ void BlockVectorBase<VectorType>::sadd (const value_type x, const value_type a,
                                         const BlockVectorBase<VectorType>& y)
 {
 
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(c),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x), ExcNumberNotFinite());
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
+  Assert (numbers::is_finite(b), ExcNumberNotFinite());
+  Assert (numbers::is_finite(c), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2209,10 +2195,8 @@ void BlockVectorBase<VectorType>::equ (const value_type a,
                                        const BlockVectorBase<VectorType>& w)
 {
 
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
+  Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2245,8 +2229,7 @@ void BlockVectorBase<VectorType>::equ (const value_type    a,
                                        const BlockVector2 &v)
 {
 
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
   Assert (n_blocks() == v.n_blocks(),
          ExcDimensionMismatch(n_blocks(), v.n_blocks()));
@@ -2262,8 +2245,7 @@ BlockVectorBase<VectorType>&
 BlockVectorBase<VectorType>::operator = (const value_type s)
 {
 
-  Assert (numbers::is_finite(s),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
   for (unsigned int i=0;i<n_blocks();++i)
     components[i] = s;
@@ -2276,8 +2258,7 @@ template <class VectorType>
 BlockVectorBase<VectorType>&
 BlockVectorBase<VectorType>::operator = (const BlockVectorBase<VectorType>& v)
 {
-  Assert (n_blocks() == v.n_blocks(),
-         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+  AssertDimension(n_blocks(), v.n_blocks());
 
   for (unsigned int i=0;i<n_blocks();++i)
     components[i] = v.components[i];
@@ -2291,8 +2272,7 @@ template <class VectorType2>
 BlockVectorBase<VectorType>&
 BlockVectorBase<VectorType>::operator = (const BlockVectorBase<VectorType2> &v)
 {
-  Assert (n_blocks() == v.n_blocks(),
-         ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+  AssertDimension(n_blocks(), v.n_blocks());
 
   for (unsigned int i=0;i<n_blocks();++i)
     components[i] = v.components[i];
@@ -2326,8 +2306,7 @@ bool
 BlockVectorBase<VectorType>::
 operator == (const BlockVectorBase<VectorType2> &v) const
 {
-  Assert (block_indices == v.block_indices,
-          ExcDifferentBlockIndices());
+  Assert (block_indices == v.block_indices, ExcDifferentBlockIndices());
 
   for (unsigned int i=0;i<n_blocks();++i)
     if ( ! (components[i] == v.components[i]))
@@ -2344,8 +2323,7 @@ BlockVectorBase<VectorType> &
 BlockVectorBase<VectorType>::operator *= (const value_type factor)
 {
 
-  Assert (numbers::is_finite(factor),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor), ExcNumberNotFinite());
 
   for (unsigned int i=0;i<n_blocks();++i)
     components[i] *= factor;
@@ -2361,9 +2339,8 @@ BlockVectorBase<VectorType> &
 BlockVectorBase<VectorType>::operator /= (const value_type factor)
 {
 
-  Assert (numbers::is_finite(factor),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (factor > 0., ExcZero() );
+  Assert (numbers::is_finite(factor), ExcNumberNotFinite());
+  Assert (factor > 0., ExcDivideByZero() );
 
   for (unsigned int i=0;i<n_blocks();++i)
     components[i] /= factor;
index 1b9a49182e5dea2046a5ccec46bf472fa4024d48..cb86464fd68ecb00aea025f5de8b3264b3044624 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name:  $
 //
-//    Copyright (C) 2008, 2009 by the deal.II authors
+//    Copyright (C) 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -1249,8 +1249,7 @@ void ChunkSparseMatrix<number>::set (const unsigned int i,
                                     const number value)
 {
 
-  Assert (numbers::is_finite(value), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   Assert (cols != 0, ExcNotInitialized());
                                   // it is allowed to set elements of
@@ -1275,8 +1274,7 @@ void ChunkSparseMatrix<number>::add (const unsigned int i,
                                     const number value)
 {
 
-  Assert (numbers::is_finite(value), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   Assert (cols != 0, ExcNotInitialized());
 
index a6127d89430b3ed56914c95fe819a0d3e9fc9cd8..889938f542a01f86b00ba0e6795eadd3d1c3b430 100644 (file)
@@ -884,6 +884,7 @@ ConstraintMatrix::distribute (VectorType &vec) const
        new_value += (static_cast<typename VectorType::value_type>
                      (vec(next_constraint->entries[i].first)) *
                       next_constraint->entries[i].second);
+      Assert(numbers::is_finite(new_value), ExcNumberNotFinite());
       vec(next_constraint->line) = new_value;
     }
 }
index ed3e2c044e2a88f6a9c5a6adad95154b0f14e3db..42bcbe880b94ff7515d1cf2f04e32cdc336781a4 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by the deal.II authors
+//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -1454,8 +1454,7 @@ inline
 number
 FullMatrix<number>::Accessor::value() const
 {
-  Assert (numbers::is_finite( matrix->el(a_row, a_col) ), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite( matrix->el(a_row, a_col) ), ExcNumberNotFinite());
   return matrix->el(a_row, a_col);
 }
 
index a230d25674776afdc5a633129e1679ddeaed19d0..45c1267cf03c1f45b9056713738653d1ae5a6486 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by the deal.II authors
+//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -146,8 +146,7 @@ FullMatrix<number> &
 FullMatrix<number>::operator *= (const number factor)
 {
 
-  Assert (numbers::is_finite(factor), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor), ExcNumberNotFinite());
 
   number       *p = &(*this)(0,0);
   const number *e = &(*this)(0,0) + n()*m();
@@ -164,16 +163,14 @@ FullMatrix<number> &
 FullMatrix<number>::operator /= (const number factor)
 {
 
-  Assert (numbers::is_finite(factor), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor), ExcNumberNotFinite());
 
   number       *p = &(*this)(0,0);
   const number *e = &(*this)(0,0) + n()*m();
 
   const number factor_inv = number(1.)/factor;
 
-  Assert (numbers::is_finite(factor_inv), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor_inv), ExcNumberNotFinite());
  
   while (p != e)
     *p++ *= factor_inv;
index 45caef637c746e4288c41ca926496df107fb7f4e..8de24c42cc4526d6d932584eb5a97346b5e61c4c 100644 (file)
@@ -1424,9 +1424,7 @@ namespace PETScWrappers
                   const PetscScalar  value)
   {
 
-    Assert (numbers::is_finite(value),
-           ExcMessage("The given value is not finite but either "
-                      "infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
     set (i, 1, &j, &value, false);
   }
@@ -1529,9 +1527,7 @@ namespace PETScWrappers
        for (unsigned int j=0; j<n_cols; ++j)
          {
            const PetscScalar value = values[j];
-           Assert (numbers::is_finite(value),
-                   ExcMessage("The given value is not finite but either "
-                              "infinite or Not A Number (NaN)"));
+           Assert (numbers::is_finite(value), ExcNumberNotFinite());
            if (value != PetscScalar())
              {
                column_indices[n_columns] = col_indices[j];
@@ -1560,9 +1556,7 @@ namespace PETScWrappers
                   const PetscScalar  value)
   {
 
-    Assert (numbers::is_finite(value),
-           ExcMessage("The given value is not finite but either "
-                      "infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
     if (value == PetscScalar())
       {
@@ -1683,9 +1677,7 @@ namespace PETScWrappers
        for (unsigned int j=0; j<n_cols; ++j)
          {
            const PetscScalar value = values[j];
-           Assert (numbers::is_finite(value),
-                   ExcMessage("The given value is not finite but either "
-                              "infinite or Not A Number (NaN)"));
+           Assert (numbers::is_finite(value), ExcNumberNotFinite());
            if (value != PetscScalar())
              {
                column_indices[n_columns] = col_indices[j];
index e4cb94ee2a9322e75db11773da67abacdd17dbbb..e68b183c6fea16ede753b38c60dc747822796f81 100644 (file)
@@ -2151,9 +2151,7 @@ SparseMatrix<number>::set (const unsigned int i,
                           const unsigned int j,
                           const number       value)
 {
-  Assert (numbers::is_finite(value),
-         ExcMessage("The given value is not finite but either "
-                    "infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   const unsigned int index = cols->operator()(i, j);
 
@@ -2239,9 +2237,7 @@ SparseMatrix<number>::add (const unsigned int i,
                           const unsigned int j,
                           const number       value)
 {
-  Assert (numbers::is_finite(value),
-         ExcMessage("The given value is not finite but either "
-                    "infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   if (value == 0)
     return;
index c639ba0a78130d72419e99fe105d3671d0aac6b0..9d3f561727665fc7327b294761e824d72f8d17a1 100644 (file)
@@ -492,9 +492,7 @@ SparseMatrix<number>::add (const unsigned int  row,
   for (unsigned int j=0; j<n_cols; ++j)
     {
       const number value = values[j];
-      Assert (numbers::is_finite(value),
-             ExcMessage("The given value is not finite but either "
-                        "infinite or Not A Number (NaN)"));
+      Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
 #ifdef DEBUG
       if (elide_zero_values==true && value == 0)
@@ -555,9 +553,7 @@ SparseMatrix<number>::set (const unsigned int  row,
       for (unsigned int j=0; j<n_cols; ++j)
        {
          const number value = values[j];
-         Assert (numbers::is_finite(value),
-                 ExcMessage("The given value is not finite but either "
-                            "infinite or Not A Number (NaN)"));
+         Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
          if (value == 0)
            continue;
@@ -593,9 +589,7 @@ SparseMatrix<number>::set (const unsigned int  row,
       for (unsigned int j=0; j<n_cols; ++j)
        {
          const number value = values[j];
-         Assert (numbers::is_finite(value),
-                 ExcMessage("The given value is not finite but either "
-                            "infinite or Not A Number (NaN)"));
+         Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
          if (index != next_row_index && my_cols[index] == col_indices[j])
            goto set_value_checked;
index 4cbe439b23333ff11581b8cf63fb223016586c0f..df53a78310ce9824934b67aea5bcb2260f727c8a 100644 (file)
@@ -1392,8 +1392,7 @@ void SparseMatrixEZ<number>::set (const unsigned int i,
                                  const number value)
 {
 
-  Assert (numbers::is_finite(value), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   Assert (i<m(), ExcIndexRange(i,0,m()));
   Assert (j<n(), ExcIndexRange(j,0,n()));
@@ -1420,8 +1419,7 @@ void SparseMatrixEZ<number>::add (const unsigned int i,
                                  const number value)
 {
 
-  Assert (numbers::is_finite(value), 
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
   Assert (i<m(), ExcIndexRange(i,0,m()));
   Assert (j<n(), ExcIndexRange(j,0,n()));
index d5ce7da4336643358f86f9f4c3066446a4e53ede..b5428cae27353707dbd62f425e6fea38ba85ccee 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2008, 2009 by the deal.II authors
+//    Copyright (C) 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -2597,9 +2597,7 @@ namespace TrilinosWrappers
                     const TrilinosScalar value)
   {
 
-    Assert (numbers::is_finite(value),
-           ExcMessage("The given value is not finite but either "
-                      "infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
     set (i, 1, &j, &value, false);
   }
@@ -2704,9 +2702,7 @@ namespace TrilinosWrappers
        for (unsigned int j=0; j<n_cols; ++j)
          {
            const double value = values[j];
-           Assert (numbers::is_finite(value),
-                   ExcMessage("The given value is not finite but either "
-                              "infinite or Not A Number (NaN)"));
+           Assert (numbers::is_finite(value), ExcNumberNotFinite());
            if (value != 0)
              {
                column_indices[n_columns] = col_indices[j];
@@ -2800,9 +2796,7 @@ namespace TrilinosWrappers
                     const TrilinosScalar value)
   {
 
-    Assert (numbers::is_finite(value),
-           ExcMessage("The given value is not finite but either "
-                      "infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(value), ExcNumberNotFinite());
 
     if (value == 0)
       {
@@ -2935,9 +2929,7 @@ namespace TrilinosWrappers
        for (unsigned int j=0; j<n_cols; ++j)
          {
            const double value = values[j];
-           Assert (numbers::is_finite(value),
-                   ExcMessage("The given value is not finite but either "
-                              "infinite or Not A Number (NaN)"));
+           Assert (numbers::is_finite(value), ExcNumberNotFinite());
            if (value != 0)
              {
                column_indices[n_columns] = col_indices[j];
index c68738255885c08b5ce17dab90e025e5e47f68fa..4d7c62a0a04fa0ee18bb3fc312a9391bd8866215 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2008, 2009 by the deal.II authors
+//    Copyright (C) 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -1140,9 +1140,7 @@ namespace TrilinosWrappers
   VectorBase::operator = (const TrilinosScalar s)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either "
-                      "infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
     const int ierr = vector->PutScalar(s);
 
@@ -1423,9 +1421,7 @@ namespace TrilinosWrappers
   VectorBase::operator *= (const TrilinosScalar a)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
     const int ierr = vector->Scale(a);
     AssertThrow (ierr == 0, ExcTrilinosError(ierr));
@@ -1440,15 +1436,11 @@ namespace TrilinosWrappers
   VectorBase::operator /= (const TrilinosScalar a)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
     const TrilinosScalar factor = 1./a;
 
-    Assert (numbers::is_finite(factor),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(factor), ExcNumberNotFinite());
 
     const int ierr = vector->Scale(factor);
     AssertThrow (ierr == 0, ExcTrilinosError(ierr));
@@ -1493,9 +1485,7 @@ namespace TrilinosWrappers
   VectorBase::add (const TrilinosScalar s)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
     unsigned int n_local = local_size();
     for (unsigned int i=0; i<n_local; i++)
@@ -1512,9 +1502,7 @@ namespace TrilinosWrappers
     Assert (size() == v.size(),
            ExcDimensionMismatch(size(), v.size()));
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
     const int ierr = vector->Update(a, *(v.vector), 1.);
     AssertThrow (ierr == 0, ExcTrilinosError(ierr));
@@ -1534,12 +1522,8 @@ namespace TrilinosWrappers
     Assert (size() == w.size(),
            ExcDimensionMismatch(size(), w.size()));
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
     const int ierr = vector->Update(a, *(v.vector), b, *(w.vector), 1.);
 
@@ -1556,9 +1540,7 @@ namespace TrilinosWrappers
     Assert (size() == v.size(),
            ExcDimensionMismatch(size(), v.size()));
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
     const int ierr = vector->Update(1., *(v.vector), s);
 
@@ -1576,12 +1558,8 @@ namespace TrilinosWrappers
     Assert (size() == v.size(),
            ExcDimensionMismatch(size(), v.size()));
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
     const int ierr = vector->Update(a, *(v.vector), s);
 
@@ -1604,15 +1582,9 @@ namespace TrilinosWrappers
            ExcDimensionMismatch(size(), w.size()));
 
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
     const int ierr = vector->Update(a, *(v.vector), b, *(w.vector), s);
 
@@ -1638,18 +1610,10 @@ namespace TrilinosWrappers
     Assert (size() == x.size(),
            ExcDimensionMismatch(size(), x.size()));
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(c),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
+    Assert (numbers::is_finite(c), ExcNumberNotFinite());
 
                                         // Update member can only
                                        // input two other vectors so
@@ -1682,9 +1646,7 @@ namespace TrilinosWrappers
                   const VectorBase     &v)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
                                   // If we don't have the same map, copy.
     if (local_range() != v.local_range())
@@ -1726,12 +1688,8 @@ namespace TrilinosWrappers
     Assert (v.size() == w.size(),
            ExcDimensionMismatch (v.size(), w.size()));
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but "
-                      "either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
                                   // If we don't have the same map, copy.
     if (local_range() != v.local_range())
index dddf85158be286353787a8cea26403298c8b6ce4..f21cb7b5cfcbfe2747335bd2d05ed78a926a6465 100644 (file)
@@ -1103,10 +1103,7 @@ template <typename Number>
 inline
 Vector<Number> & Vector<Number>::operator = (const Number s)
 {
-  Assert (numbers::is_finite(s),
-          ExcMessage("The given value is not finite but either infinite or "
-                    "Not A Number (NaN)"));
-
+  Assert (numbers::is_finite(s), ExcNumberNotFinite());
   if (s != Number())
     Assert (vec_size!=0, ExcEmptyObject());
   if (vec_size>internal::Vector::minimum_parallel_grain_size)
@@ -1129,10 +1126,7 @@ inline
 Vector<std::complex<float> > &
 Vector<std::complex<float> >::operator = (const std::complex<float> s)
 {
-  Assert (numbers::is_finite(s),
-          ExcMessage("The given value is not finite but either infinite or "
-                    "Not A Number (NaN)"));
-
+  Assert (numbers::is_finite(s), ExcNumberNotFinite());
   if (s != std::complex<float>())
     Assert (vec_size!=0, ExcEmptyObject());
   if (vec_size!=0)
@@ -1263,8 +1257,7 @@ inline
 Vector<Number> & Vector<Number>::operator *= (const Number factor)
 {
 
-  Assert (numbers::is_finite(factor),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor),ExcNumberNotFinite());
 
   scale (factor);
   return *this;
@@ -1277,8 +1270,7 @@ inline
 Vector<Number> &
 Vector<Number>::operator /= (const Number factor)
 {
-  Assert (numbers::is_finite(factor),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor),ExcNumberNotFinite());
   Assert (factor != Number(0.), ExcZero() );
 
   this->operator *= (Number(1.)/factor);
@@ -1292,8 +1284,7 @@ inline
 void
 Vector<Number>::scale (const Number factor)
 {
-  Assert (numbers::is_finite(factor),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(factor),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
 
@@ -1360,8 +1351,7 @@ void
 Vector<Number>::add (const Number a,
                     const Vector<Number>& v)
 {
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
   Assert (vec_size == v.vec_size, ExcDimensionMismatch(vec_size, v.vec_size));
@@ -1383,10 +1373,8 @@ Vector<Number>::sadd (const Number x,
                      const Number a,
                      const Vector<Number>& v)
 {
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x),ExcNumberNotFinite());
+  Assert (numbers::is_finite(a),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
   Assert (vec_size == v.vec_size, ExcDimensionMismatch(vec_size, v.vec_size));
index 773acec024f68484df528888cf7c1a54b13fd956..80819f7d55f846baf3e2b2f82cf7304c7188a05b 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by the deal.II authors
+//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -735,10 +735,8 @@ template <typename Number>
 void Vector<Number>::add (const Number a, const Vector<Number>& v,
                          const Number b, const Vector<Number>& w)
 {
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a),ExcNumberNotFinite());
+  Assert (numbers::is_finite(b),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
   Assert (vec_size == v.vec_size, ExcDimensionMismatch(vec_size, v.vec_size));
@@ -762,8 +760,7 @@ template <typename Number>
 void Vector<Number>::sadd (const Number x,
                           const Vector<Number>& v)
 {
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
   Assert (vec_size == v.vec_size, ExcDimensionMismatch(vec_size, v.vec_size));
@@ -787,12 +784,9 @@ void Vector<Number>::sadd (const Number x, const Number a,
                           const Vector<Number>& v, const Number b,
                            const Vector<Number>& w)
 {
-  Assert (numbers::is_finite(x),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(x),ExcNumberNotFinite());
+  Assert (numbers::is_finite(a),ExcNumberNotFinite());
+  Assert (numbers::is_finite(b),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
   Assert (vec_size == v.vec_size, ExcDimensionMismatch(vec_size, v.vec_size));
@@ -907,10 +901,8 @@ template <typename Number>
 void Vector<Number>::equ (const Number a, const Vector<Number>& u,
                          const Number b, const Vector<Number>& v)
 {
-  Assert (numbers::is_finite(a),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-  Assert (numbers::is_finite(b),
-          ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+  Assert (numbers::is_finite(a),ExcNumberNotFinite());
+  Assert (numbers::is_finite(b),ExcNumberNotFinite());
 
   Assert (vec_size!=0, ExcEmptyObject());
   Assert (vec_size == u.vec_size, ExcDimensionMismatch(vec_size, u.vec_size));
index 53c1df3e70c547b7838ea5b0d2309003f251b00f..c958951b514e6364a0c680ea0161818fc7980f5a 100644 (file)
@@ -208,8 +208,7 @@ namespace PETScWrappers
   VectorBase::operator = (const PetscScalar s)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
                                      // flush previously cached elements. this
                                      // seems to be necessary since petsc
@@ -684,8 +683,7 @@ namespace PETScWrappers
   VectorBase::operator *= (const PetscScalar a)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
 #if DEAL_II_PETSC_VERSION_LT(2,3,0)
     const int ierr = VecScale (&a, vector);
@@ -704,13 +702,11 @@ namespace PETScWrappers
   VectorBase::operator /= (const PetscScalar a)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
     const PetscScalar factor = 1./a;
 
-    Assert (numbers::is_finite(factor),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(factor), ExcNumberNotFinite());
 
 #if DEAL_II_PETSC_VERSION_LT(2,3,0)
     const int ierr = VecScale (&factor, vector);
@@ -763,8 +759,7 @@ namespace PETScWrappers
   VectorBase::add (const PetscScalar s)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
 #if DEAL_II_PETSC_VERSION_LT(2,3,0)
     const int ierr = VecShift (&s, vector);
@@ -790,8 +785,7 @@ namespace PETScWrappers
                    const VectorBase     &v)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
 #if DEAL_II_PETSC_VERSION_LT(2,3,0)
     const int ierr = VecAXPY (&a, v, vector);
@@ -811,10 +805,8 @@ namespace PETScWrappers
                    const VectorBase &w)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
     const PetscScalar weights[2] = {a,b};
     Vec               addends[2] = {v.vector, w.vector};
@@ -835,8 +827,7 @@ namespace PETScWrappers
                     const VectorBase &v)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
 
 #if DEAL_II_PETSC_VERSION_LT(2,3,0)
     const int ierr = VecAYPX (&s, v, vector);
@@ -855,10 +846,8 @@ namespace PETScWrappers
                     const VectorBase     &v)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
                                      // there is nothing like a AXPAY
                                      // operation in Petsc, so do it in two
@@ -877,12 +866,9 @@ namespace PETScWrappers
                     const VectorBase     &w)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
                                      // there is no operation like MAXPAY, so
                                      // do it in two steps
@@ -912,14 +898,10 @@ namespace PETScWrappers
                     const VectorBase     &x)
   {
 
-    Assert (numbers::is_finite(s),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(c),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(s), ExcNumberNotFinite());
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
+    Assert (numbers::is_finite(c), ExcNumberNotFinite());
 
                                      // there is no operation like MAXPAY, so
                                      // do it in two steps
@@ -954,8 +936,7 @@ namespace PETScWrappers
                    const VectorBase &v)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
 
     Assert (size() == v.size(),
             ExcDimensionMismatch (size(), v.size()));
@@ -978,10 +959,8 @@ namespace PETScWrappers
                    const VectorBase &w)
   {
 
-    Assert (numbers::is_finite(a),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
-    Assert (numbers::is_finite(b),
-           ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
+    Assert (numbers::is_finite(a), ExcNumberNotFinite());
+    Assert (numbers::is_finite(b), ExcNumberNotFinite());
 
     Assert (size() == v.size(),
             ExcDimensionMismatch (size(), v.size()));

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.