]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Re-indent
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Sat, 3 Nov 2007 02:12:00 +0000 (02:12 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Sat, 3 Nov 2007 02:12:00 +0000 (02:12 +0000)
git-svn-id: https://svn.dealii.org/trunk@15431 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/base/include/base/numbers.h

index 6439644bf46d20b7ae5fd99cf6e4caf81bdffb3d..94af74c1e65691c78f0d2732ee1370b55ab7bc8a 100644 (file)
@@ -34,115 +34,116 @@ DEAL_II_NAMESPACE_OPEN
  * the library as a marker for an invalid index, an invalid size of an
  * array, and similar purposes.
  */
-namespace deal_II_numbers {
-                                             /**
-                                              * Representation of the
-                                              * largest number that
-                                              * can be put into an
-                                              * unsigned integer. This
-                                              * value is widely used
-                                              * throughout the library
-                                              * as a marker for an
-                                              * invalid unsigned
-                                              * integer value, such as
-                                              * an invalid array
-                                              * index, an invalid
-                                              * array size, and the
-                                              * like.
-                                              */
+namespace deal_II_numbers
+{
+                                  /**
+                                   * Representation of the
+                                   * largest number that
+                                   * can be put into an
+                                   * unsigned integer. This
+                                   * value is widely used
+                                   * throughout the library
+                                   * as a marker for an
+                                   * invalid unsigned
+                                   * integer value, such as
+                                   * an invalid array
+                                   * index, an invalid
+                                   * array size, and the
+                                   * like.
+                                   */
   static const unsigned int 
-    invalid_unsigned_int = static_cast<unsigned int> (-1);
+  invalid_unsigned_int = static_cast<unsigned int> (-1);
 
-                                             /**
-                                              * e
-                                              */
+                                  /**
+                                   * e
+                                   */
   static const double  E       = 2.7182818284590452354;
 
-                                             /**
-                                              * log_2 e
-                                              */
+                                  /**
+                                   * log_2 e
+                                   */
   static const double  LOG2E   = 1.4426950408889634074;
 
-                                             /**
-                                              * log_10 e
-                                              */
+                                  /**
+                                   * log_10 e
+                                   */
   static const double  LOG10E  = 0.43429448190325182765;
 
-                                             /**
-                                              * log_e 2
-                                              */
+                                  /**
+                                   * log_e 2
+                                   */
   static const double  LN2     = 0.69314718055994530942;
 
-                                             /**
-                                              * log_e 10
-                                              */
+                                  /**
+                                   * log_e 10
+                                   */
   static const double  LN10    = 2.30258509299404568402;
 
-                                             /**
-                                              * pi
-                                              */
+                                  /**
+                                   * pi
+                                   */
   static const double  PI      = 3.14159265358979323846;
 
-                                             /**
-                                              * pi/2
-                                              */
+                                  /**
+                                   * pi/2
+                                   */
   static const double  PI_2    = 1.57079632679489661923;
 
-                                             /**
-                                              * pi/4
-                                              */
+                                  /**
+                                   * pi/4
+                                   */
   static const double  PI_4    = 0.78539816339744830962;
 
-                                             /**
-                                              * sqrt(2)
-                                              */
+                                  /**
+                                   * sqrt(2)
+                                   */
   static const double  SQRT2   = 1.41421356237309504880;
 
-                                             /**
-                                              * 1/sqrt(2)
-                                              */
+                                  /**
+                                   * 1/sqrt(2)
+                                   */
   static const double  SQRT1_2 = 0.70710678118654752440;
 
-                                             /**
-                                             * Return @p true if the given
-                                             * value is a finite floating
-                                             * point number, i.e. is neither
-                                             * plus or minus infinity nor NaN
-                                             * (not a number).
-                                             *
-                                             * Note that the argument type of
-                                             * this function is
-                                             * <code>double</code>. In other
-                                             * words, if you give a very
-                                             * large number of type
-                                             * <code>long double</code>, this
-                                             * function may return
-                                             * <code>false</code> even if the
-                                             * number is finite with respect
-                                             * to type <code>long
-                                             * double</code>.
-                                             */
+                                  /**
+                                   * Return @p true if the given
+                                   * value is a finite floating
+                                   * point number, i.e. is neither
+                                   * plus or minus infinity nor NaN
+                                   * (not a number).
+                                   *
+                                   * Note that the argument type of
+                                   * this function is
+                                   * <code>double</code>. In other
+                                   * words, if you give a very
+                                   * large number of type
+                                   * <code>long double</code>, this
+                                   * function may return
+                                   * <code>false</code> even if the
+                                   * number is finite with respect
+                                   * to type <code>long
+                                   * double</code>.
+                                   */
   bool is_finite (const double x);
 
-                                             /**
-                                             * Return @p true if real and 
-                                             * imaginary parts of the given
-                                             * complex number are finite.
-                                             */
+                                  /**
+                                   * Return @p true if real and 
+                                   * imaginary parts of the given
+                                   * complex number are finite.
+                                   */
   bool is_finite (const std::complex<double> x);
 
-                                             /**
-                                             * Return @p true if real and 
-                                             * imaginary parts of the given
-                                             * complex number are finite.
-                                             *
-                                             * Again may not work correctly if
-                                             * real or imaginary parts are very        
-                                             * large numbers that are infinite in 
-                                             * terms of <code>double</code>, but 
-                                             * finite with respect to 
-                                             * <code>long double</code>.
-                                             */
+                                  /**
+                                   * Return @p true if real and 
+                                   * imaginary parts of the given
+                                   * complex number are finite.
+                                   *
+                                   * Again may not work correctly if
+                                   * real or imaginary parts are very  
+                                   * large numbers that are infinite in 
+                                   * terms of <code>double</code>, but 
+                                   * finite with respect to 
+                                   * <code>long double</code>.
+                                   */
   bool is_finite (const std::complex<long double> x);
 }
 

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.