Convert a bunch of bare 'unsigned's into 'unsigned int's to make the replacement...

git-svn-id: https://svn.dealii.org/trunk@25859 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/deal.II/include/deal.II/base/table.h b/deal.II/include/deal.II/base/table.h
index 7d1f7d4658ba0ca194df88df6e900d2895e69ed2..531226662a74db98e89ac38b702e4a6870dd55de 100644 (file)
--- a/deal.II/include/deal.II/base/table.h
+++ b/deal.II/include/deal.II/base/table.h
@@ -2055,7 +2055,7 @@ inline
 unsigned int
 TableBase<N,T>::n_elements () const
 {
-  unsigned s = 1;
+  unsigned int s = 1;
   for (unsigned int n=0; n<N; ++n)
     s *= table_size[n];
   return s;

diff --git a/deal.II/include/deal.II/base/table_indices.h b/deal.II/include/deal.II/base/table_indices.h
index a5b99fc594d24d1e83b1b0dac510f78c3d423fc9..52d30af82aa394821e1cdefeb05a1ce4109220e2 100644 (file)
--- a/deal.II/include/deal.II/base/table_indices.h
+++ b/deal.II/include/deal.II/base/table_indices.h
@@ -79,7 +79,7 @@ class TableIndicesBase
                                      /**
                                       * Store the indices in an array.
                                       */
-    unsigned indices[N];
+    unsigned int indices[N];
 };
 
 

diff --git a/deal.II/include/deal.II/base/tensor.h b/deal.II/include/deal.II/base/tensor.h
index c5a5bf12166e28cf62882ddb8c2330e855c51461..e95edccfbff6a2110daba6134c3b93dd0e0142bf 100644 (file)
--- a/deal.II/include/deal.II/base/tensor.h
+++ b/deal.II/include/deal.II/base/tensor.h
@@ -555,7 +555,7 @@ Tensor<rank_, dim, Number>::unroll (Vector<Number2> &result) const
 {
   AssertDimension (result.size(),(Utilities::fixed_power<rank_, unsigned int>(dim)));
 
-  unsigned index = 0;
+  unsigned int index = 0;
   unroll_recursion (result, index);
 }
 
@@ -568,7 +568,7 @@ void
 Tensor<rank_, dim, Number>::unroll_recursion (Vector<Number2> &result,
                                               unsigned int    &index) const
 {
-  for (unsigned i=0; i<dim; ++i)
+  for (unsigned int i=0; i<dim; ++i)
     {
       operator[](i).unroll_recursion(result, index);
     }
@@ -696,7 +696,7 @@ operator * (const Tensor<1,dim,Number> &src1,
  * inner product <tt> sum<sub>i,j</sub> src1[i][j]*src2[i][j]</tt>.
  *
  * @relates Tensor
- * @author Guido Kanschat, 2000 
+ * @author Guido Kanschat, 2000
  */
 template <int dim, typename Number>
 inline
@@ -706,7 +706,7 @@ Number double_contract (const Tensor<2, dim, Number> &src1,
   Number res = 0.;
   for (unsigned int i=0; i<dim; ++i)
     res += contract(src1[i],src2[i]);
-  
+
   return res;
 }
 

diff --git a/deal.II/include/deal.II/base/tensor_base.h b/deal.II/include/deal.II/base/tensor_base.h
index cdf9ddf3bb27e27fedfaa62f36588572332d2dd8..7c4f7390e33f52cbbd84d2c0fc4226169c14f51d 100644 (file)
--- a/deal.II/include/deal.II/base/tensor_base.h
+++ b/deal.II/include/deal.II/base/tensor_base.h
@@ -1198,7 +1198,7 @@ Tensor<1,dim,Number>::unroll (Vector<Number2> &result) const
   Assert (result.size()==dim,
           ExcDimensionMismatch(dim, result.size()));
 
-  unsigned index = 0;
+  unsigned int index = 0;
   unroll_recursion (result,index);
 }
 
@@ -1211,7 +1211,7 @@ void
 Tensor<1,dim,Number>::unroll_recursion (Vector<Number2> &result,
                                         unsigned int    &index) const
 {
-  for (unsigned i=0; i<dim; ++i)
+  for (unsigned int i=0; i<dim; ++i)
     result(index++) = operator[](i);
 }
 

diff --git a/deal.II/include/deal.II/integrators/divergence.h b/deal.II/include/deal.II/integrators/divergence.h
index f618520acc6054756be0dc8d9292ded0d89b24ae..665fd73caf666bd57ccd72838e72d3c0ebe42b8b 100644 (file)
--- a/deal.II/include/deal.II/integrators/divergence.h
+++ b/deal.II/include/deal.II/integrators/divergence.h
@@ -87,14 +87,14 @@ namespace LocalIntegrators
       AssertDimension(M.m(), t_dofs);
       AssertDimension(M.n(), n_dofs);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = fe.JxW(k) * factor;
-          for (unsigned i=0;i<t_dofs;++i)
+          for (unsigned int i=0;i<t_dofs;++i)
             {
               const double vv = fetest.shape_value(i,k);
               for (unsigned int d=0;d<dim;++d)
-                for (unsigned j=0;j<n_dofs;++j)
+                for (unsigned int j=0;j<n_dofs;++j)
                   {
                     const double du = fe.shape_grad_component(j,k,d)[d];
                     M(i,j) += dx * du * vv;
@@ -127,11 +127,11 @@ namespace LocalIntegrators
        const unsigned int t_dofs = fetest.dofs_per_cell;
        Assert (result.size() == t_dofs, ExcDimensionMismatch(result.size(), t_dofs));
 
-       for (unsigned k=0;k<fetest.n_quadrature_points;++k)
+       for (unsigned int k=0;k<fetest.n_quadrature_points;++k)
            {
              const double dx = factor * fetest.JxW(k);
 
-             for (unsigned i=0;i<t_dofs;++i)
+             for (unsigned int i=0;i<t_dofs;++i)
                for (unsigned int d=0;d<dim;++d)
                  result(i) += dx * input[d][k][d] * fetest.shape_value(i,k);
            }
@@ -162,14 +162,14 @@ namespace LocalIntegrators
       AssertDimension(M.m(), t_dofs);
       AssertDimension(M.n(), n_dofs);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = fe.JxW(k) * factor;
           for (unsigned int d=0;d<dim;++d)
-            for (unsigned i=0;i<t_dofs;++i)
+            for (unsigned int i=0;i<t_dofs;++i)
               {
                 const double vv = fetest.shape_value_component(i,k,d);
-                for (unsigned j=0;j<n_dofs;++j)
+                for (unsigned int j=0;j<n_dofs;++j)
                   {
                     const Tensor<1,dim>& Du = fe.shape_grad(j,k);
                     M(i,j) += dx * vv * Du[d];
@@ -201,11 +201,11 @@ namespace LocalIntegrators
                const unsigned int t_dofs = fetest.dofs_per_cell;
                Assert (result.size() == t_dofs, ExcDimensionMismatch(result.size(), t_dofs));
 
-               for (unsigned k=0;k<fetest.n_quadrature_points;++k)
+               for (unsigned int k=0;k<fetest.n_quadrature_points;++k)
                    {
                      const double dx = factor * fetest.JxW(k);
 
-                     for (unsigned i=0;i<t_dofs;++i)
+                     for (unsigned int i=0;i<t_dofs;++i)
                        for (unsigned int d=0;d<dim;++d)
                          result(i) += dx * input[k][d] * fetest.shape_value_component(i,k,d);
                    }
@@ -234,11 +234,11 @@ namespace LocalIntegrators
       AssertDimension(M.m(), t_dofs);
       AssertDimension(M.n(), n_dofs);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const Tensor<1,dim> ndx = factor * fe.JxW(k) * fe.normal_vector(k);
-          for (unsigned i=0;i<t_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<t_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<dim;++d)
                 M(i,j) += ndx[d] * fe.shape_value_component(j,k,d)
                           * fetest.shape_value(i,k);
@@ -272,11 +272,11 @@ namespace LocalIntegrators
       AssertDimension(result.size(), t_dofs);
       AssertVectorVectorDimension (data, dim, fe.n_quadrature_points);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const Tensor<1,dim> ndx = factor * fe.normal_vector(k) * fe.JxW(k);
 
-          for (unsigned i=0;i<t_dofs;++i)
+          for (unsigned int i=0;i<t_dofs;++i)
             for (unsigned int d=0;d<dim;++d)
               result(i) += ndx[d] * fetest.shape_value(i,k) * data[d][k];
         }
@@ -321,11 +321,11 @@ namespace LocalIntegrators
       AssertDimension(M22.m(), t_dofs);
       AssertDimension(M22.n(), n_dofs);
 
-      for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
         {
           const double dx = factor * fe1.JxW(k);
-          for (unsigned i=0;i<t_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<t_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<dim;++d)
                 {
                   const double un1 = fe1.shape_value_component(j,k,d) * fe1.normal_vector(k)[d];
@@ -359,11 +359,11 @@ namespace LocalIntegrators
       AssertDimension(M.m(), n_dofs);
       AssertDimension(M.n(), n_dofs);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = factor * fe.JxW(k);
-          for (unsigned i=0;i<n_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<n_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               {
                 double dv = 0.;
                 double du = 0.;
@@ -411,11 +411,11 @@ namespace LocalIntegrators
       AssertDimension(M22.m(), n_dofs);
       AssertDimension(M22.n(), n_dofs);
 
-      for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
         {
           const double dx = factor * fe1.JxW(k);
-          for (unsigned i=0;i<n_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<n_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<dim;++d)
                 {
                   const double un1 = fe1.shape_value_component(j,k,d) * fe1.normal_vector(k)[d];
@@ -441,7 +441,7 @@ namespace LocalIntegrators
       AssertVectorVectorDimension (Du, dim, fe.n_quadrature_points);
 
       double result = 0;
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           double div = Du[0][k][0];
           for (unsigned int d=1;d<dim;++d)

diff --git a/deal.II/include/deal.II/integrators/elasticity.h b/deal.II/include/deal.II/integrators/elasticity.h
index 69783504b6807ff1f40a2f2d7e1c4df9d1140f19..406a23117ede17a2fc1cab42283f2a958914f159 100644 (file)
--- a/deal.II/include/deal.II/integrators/elasticity.h
+++ b/deal.II/include/deal.II/integrators/elasticity.h
@@ -53,11 +53,11 @@ namespace LocalIntegrators
       AssertDimension(M.m(), n_dofs);
       AssertDimension(M.n(), n_dofs);
       
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
        {
          const double dx = factor * fe.JxW(k);
-         for (unsigned i=0;i<n_dofs;++i)
-           for (unsigned j=0;j<n_dofs;++j)
+         for (unsigned int i=0;i<n_dofs;++i)
+           for (unsigned int j=0;j<n_dofs;++j)
              for (unsigned int d1=0;d1<dim;++d1)
                for (unsigned int d2=0;d2<dim;++d2)
                  M(i,j) += dx * .25 *
@@ -85,12 +85,12 @@ namespace LocalIntegrators
       AssertDimension(M.m(), n_dofs);
       AssertDimension(M.n(), n_dofs);
       
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
        {
          const double dx = factor * fe.JxW(k);
          const Point<dim>& n = fe.normal_vector(k);
-         for (unsigned i=0;i<n_dofs;++i)
-           for (unsigned j=0;j<n_dofs;++j)
+         for (unsigned int i=0;i<n_dofs;++i)
+           for (unsigned int j=0;j<n_dofs;++j)
              for (unsigned int d1=0;d1<dim;++d1)
                {
                  const double u = fe.shape_value_component(j,k,d1);
@@ -144,12 +144,12 @@ namespace LocalIntegrators
       const double nu2 = (ext_factor < 0) ? int_factor : ext_factor;
       const double penalty = .5 * pen * (nu1 + nu2);
        
-      for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
        {
          const double dx = fe1.JxW(k);
          const Point<dim>& n = fe1.normal_vector(k);
-         for (unsigned i=0;i<n_dofs;++i)
-           for (unsigned j=0;j<n_dofs;++j)
+         for (unsigned int i=0;i<n_dofs;++i)
+           for (unsigned int j=0;j<n_dofs;++j)
              for (unsigned int d1=0;d1<dim;++d1)
                {
                  const double u1 = fe1.shape_value_component(j,k,d1);

diff --git a/deal.II/include/deal.II/integrators/l2.h b/deal.II/include/deal.II/integrators/l2.h
index 6255b02d047a82c7a4eb246a4dff90f771cbdb35..92369feeb83ea4f9c642d9521cad3da85f69833d 100644 (file)
--- a/deal.II/include/deal.II/integrators/l2.h
+++ b/deal.II/include/deal.II/integrators/l2.h
@@ -58,12 +58,12 @@ namespace LocalIntegrators
       const unsigned int n_dofs = fe.dofs_per_cell;
       const unsigned int n_components = fe.get_fe().n_components();
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = fe.JxW(k) * factor;
 
-          for (unsigned i=0;i<n_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<n_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<n_components;++d)
                 M(i,j) += dx
                           * fe.shape_value_component(j,k,d)
@@ -90,8 +90,8 @@ namespace LocalIntegrators
       AssertDimension(fe.get_fe().n_components(), 1);
       AssertDimension(input.size(), fe.n_quadrature_points);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
-        for (unsigned i=0;i<n_dofs;++i)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
+        for (unsigned int i=0;i<n_dofs;++i)
           result(i) += fe.JxW(k) * factor * input[k] * fe.shape_value(i,k);
     }
 
@@ -122,8 +122,8 @@ namespace LocalIntegrators
       AssertDimension(result.size(), n_dofs);
       AssertDimension(input.size(), fe_components);
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
-        for (unsigned i=0;i<n_dofs;++i)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
+        for (unsigned int i=0;i<n_dofs;++i)
           for (unsigned int d=0;d<n_components;++d)
             result(i) += fe.JxW(k) * factor * fe.shape_value_component(i,k,d) * input[d][k];
     }
@@ -171,12 +171,12 @@ namespace LocalIntegrators
       AssertDimension(M21.n(), n1_dofs);
       AssertDimension(M22.n(), n2_dofs);
 
-      for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
         {
           const double dx = fe1.JxW(k);
 
-          for (unsigned i=0;i<n1_dofs;++i)
-            for (unsigned j=0;j<n1_dofs;++j)
+          for (unsigned int i=0;i<n1_dofs;++i)
+            for (unsigned int j=0;j<n1_dofs;++j)
               for (unsigned int d=0;d<n_components;++d)
                 {
                   const double u1 = factor1*fe1.shape_value_component(j,k,d);

diff --git a/deal.II/include/deal.II/integrators/laplace.h b/deal.II/include/deal.II/integrators/laplace.h
index 802943abfa23bdbf33a177d5557799c9dd30a371..a713d37ca6279beeea808515b5bc4e9b91e39b63 100644 (file)
--- a/deal.II/include/deal.II/integrators/laplace.h
+++ b/deal.II/include/deal.II/integrators/laplace.h
@@ -57,12 +57,12 @@ namespace LocalIntegrators
       const unsigned int n_dofs = fe.dofs_per_cell;
       const unsigned int n_components = fe.get_fe().n_components();
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = fe.JxW(k) * factor;
-          for (unsigned i=0;i<n_dofs;++i)
+          for (unsigned int i=0;i<n_dofs;++i)
             {
-              for (unsigned j=0;j<n_dofs;++j)
+              for (unsigned int j=0;j<n_dofs;++j)
                 for (unsigned int d=0;d<n_components;++d)
                   M(i,j) += dx *
                             (fe.shape_grad_component(j,k,d) * fe.shape_grad_component(i,k,d));
@@ -90,10 +90,10 @@ namespace LocalIntegrators
       Assert(input.size() == nq, ExcDimensionMismatch(input.size(), nq));
       Assert(result.size() == n_dofs, ExcDimensionMismatch(result.size(), n_dofs));
       
-      for (unsigned k=0;k<nq;++k)
+      for (unsigned int k=0;k<nq;++k)
        {
          const double dx = factor * fe.JxW(k);       
-         for (unsigned i=0;i<n_dofs;++i)
+         for (unsigned int i=0;i<n_dofs;++i)
            result(i) += dx * (input[k] * fe.shape_grad(i,k));
        }
     }
@@ -121,10 +121,10 @@ namespace LocalIntegrators
       AssertVectorVectorDimension(input, n_comp, fe.n_quadrature_points);
       Assert(result.size() == n_dofs, ExcDimensionMismatch(result.size(), n_dofs));
       
-      for (unsigned k=0;k<nq;++k)
+      for (unsigned int k=0;k<nq;++k)
        {
          const double dx = factor * fe.JxW(k);
-         for (unsigned i=0;i<n_dofs;++i)
+         for (unsigned int i=0;i<n_dofs;++i)
            for (unsigned int d=0;d<n_comp;++d)
              {
                
@@ -160,12 +160,12 @@ namespace LocalIntegrators
       Assert (M.m() == n_dofs, ExcDimensionMismatch(M.m(), n_dofs));
       Assert (M.n() == n_dofs, ExcDimensionMismatch(M.n(), n_dofs));
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = fe.JxW(k) * factor;
           const Point<dim>& n = fe.normal_vector(k);
-          for (unsigned i=0;i<n_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<n_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<n_comp;++d)
                 M(i,j) += dx *
                           (2. * fe.shape_value_component(i,k,d) * penalty * fe.shape_value_component(j,k,d)
@@ -206,11 +206,11 @@ namespace LocalIntegrators
         AssertDimension(Dinput.size(), fe.n_quadrature_points);
         AssertDimension(data.size(), fe.n_quadrature_points);
 
-        for (unsigned k=0;k<fe.n_quadrature_points;++k)
+        for (unsigned int k=0;k<fe.n_quadrature_points;++k)
           {
             const double dx = factor * fe.JxW(k);
             const Point<dim>& n = fe.normal_vector(k);
-            for (unsigned i=0;i<n_dofs;++i)
+            for (unsigned int i=0;i<n_dofs;++i)
               {
                 const double dnv = fe.shape_grad(i,k) * n;
                 const double dnu = Dinput[k] * n;
@@ -257,11 +257,11 @@ namespace LocalIntegrators
         AssertVectorVectorDimension(Dinput, n_comp, fe.n_quadrature_points);
         AssertVectorVectorDimension(data, n_comp, fe.n_quadrature_points);
 
-        for (unsigned k=0;k<fe.n_quadrature_points;++k)
+        for (unsigned int k=0;k<fe.n_quadrature_points;++k)
           {
             const double dx = factor * fe.JxW(k);
             const Point<dim>& n = fe.normal_vector(k);
-            for (unsigned i=0;i<n_dofs;++i)
+            for (unsigned int i=0;i<n_dofs;++i)
               for (unsigned int d=0;d<n_comp;++d)
                 {
                   const double dnv = fe.shape_grad_component(i,k,d) * n;
@@ -320,15 +320,15 @@ namespace LocalIntegrators
       const double nui = factor1;
       const double nue = (factor2 < 0) ? factor1 : factor2;
 
-      for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
        {
          const double dx = fe1.JxW(k);
          const Point<dim>& n = fe1.normal_vector(k);
          for (unsigned int d=0;d<fe1.get_fe().n_components();++d)
            {
-             for (unsigned i=0;i<n_dofs;++i)
+             for (unsigned int i=0;i<n_dofs;++i)
                {
-                 for (unsigned j=0;j<n_dofs;++j)
+                 for (unsigned int j=0;j<n_dofs;++j)
                    {
                      const double vi = fe1.shape_value_component(i,k,d);
                      const double dnvi = n * fe1.shape_grad_component(i,k,d);
@@ -381,12 +381,12 @@ namespace LocalIntegrators
   
   const unsigned int n_dofs = fe1.dofs_per_cell;
   
-  for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+  for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
     {
       const double dx = fe1.JxW(k);
       const Point<dim>& n = fe1.normal_vector(k);
       
-      for (unsigned i=0;i<n_dofs;++i)
+      for (unsigned int i=0;i<n_dofs;++i)
        {
          const double vi = fe1.shape_value(i,k);
          const Tensor<1,dim>& Dvi = fe1.shape_grad(i,k);
@@ -446,12 +446,12 @@ namespace LocalIntegrators
       const double penalty = .5 * pen * (nui + nue);
       
   
-      for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
        {
          const double dx = fe1.JxW(k);
          const Point<dim>& n = fe1.normal_vector(k);
          
-         for (unsigned i=0;i<n1;++i)
+         for (unsigned int i=0;i<n1;++i)
            for (unsigned int d=0;d<n_comp;++d)
              {
                const double vi = fe1.shape_value_component(i,k,d);

diff --git a/deal.II/include/deal.II/integrators/maxwell.h b/deal.II/include/deal.II/integrators/maxwell.h
index 4c9d61efe837e5bbb14a8b60aa169e5e34a5fd2b..077690306e995a4f1358fc058c744c56ade1d080 100644 (file)
--- a/deal.II/include/deal.II/integrators/maxwell.h
+++ b/deal.II/include/deal.II/integrators/maxwell.h
@@ -184,11 +184,11 @@ namespace LocalIntegrators
                                        // all dimensions
       const unsigned int d_max = (dim==2) ? 1 : dim;
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = factor * fe.JxW(k);
-          for (unsigned i=0;i<n_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<n_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<d_max;++d)
                 {
                   const unsigned int d1 = (d+1)%dim;
@@ -232,11 +232,11 @@ namespace LocalIntegrators
 
       const unsigned int d_max = (dim==2) ? 1 : dim;
 
-      for (unsigned k=0;k<fe.n_quadrature_points;++k)
+      for (unsigned int k=0;k<fe.n_quadrature_points;++k)
         {
           const double dx = fe.JxW(k) * factor;
-          for (unsigned i=0;i<t_dofs;++i)
-            for (unsigned j=0;j<n_dofs;++j)
+          for (unsigned int i=0;i<t_dofs;++i)
+            for (unsigned int j=0;j<n_dofs;++j)
               for (unsigned int d=0;d<d_max;++d)
                 {
                   const unsigned int d1 = (d+1)%dim;
@@ -292,12 +292,12 @@ namespace LocalIntegrators
                                          // over all dimensions
         const unsigned int d_max = (dim==2) ? 1 : dim;
 
-        for (unsigned k=0;k<fe.n_quadrature_points;++k)
+        for (unsigned int k=0;k<fe.n_quadrature_points;++k)
           {
             const double dx = factor * fe.JxW(k);
             const Point<dim>& n = fe.normal_vector(k);
-            for (unsigned i=0;i<n_dofs;++i)
-              for (unsigned j=0;j<n_dofs;++j)
+            for (unsigned int i=0;i<n_dofs;++i)
+              for (unsigned int j=0;j<n_dofs;++j)
                 for (unsigned int d=0;d<d_max;++d)
                   {
                     const unsigned int d1 = (d+1)%dim;
@@ -347,12 +347,12 @@ namespace LocalIntegrators
                                          // over all dimensions
         const unsigned int d_max = (dim==2) ? 1 : dim;
 
-        for (unsigned k=0;k<fe.n_quadrature_points;++k)
+        for (unsigned int k=0;k<fe.n_quadrature_points;++k)
           {
             const double dx = factor * fe.JxW(k);
             const Point<dim>& n = fe.normal_vector(k);
-            for (unsigned i=0;i<n_dofs;++i)
-              for (unsigned j=0;j<n_dofs;++j)
+            for (unsigned int i=0;i<n_dofs;++i)
+              for (unsigned int j=0;j<n_dofs;++j)
                 for (unsigned int d=0;d<d_max;++d)
                   {
                     const unsigned int d1 = (d+1)%dim;
@@ -423,13 +423,13 @@ namespace LocalIntegrators
                                          // over all dimensions
         const unsigned int d_max = (dim==2) ? 1 : dim;
 
-        for (unsigned k=0;k<fe1.n_quadrature_points;++k)
+        for (unsigned int k=0;k<fe1.n_quadrature_points;++k)
           {
             const double dx = fe1.JxW(k);
             const Point<dim>& n = fe1.normal_vector(k);
-            for (unsigned i=0;i<n_dofs;++i)
-              for (unsigned j=0;j<n_dofs;++j)
-                for (unsigned d=0;d<d_max;++d)
+            for (unsigned int i=0;i<n_dofs;++i)
+              for (unsigned int j=0;j<n_dofs;++j)
+                for (unsigned int d=0;d<d_max;++d)
                   {
                     const unsigned int d1 = (d+1)%dim;
                     const unsigned int d2 = (d+2)%dim;

diff --git a/deal.II/include/deal.II/lac/block_list.h b/deal.II/include/deal.II/lac/block_list.h
index 1504f9de1332d64c7d3a8b4e540bbe35b215c60f..9b323d7972932d6aa1f1d0224514235dea7a0026 100644 (file)
--- a/deal.II/include/deal.II/lac/block_list.h
+++ b/deal.II/include/deal.II/lac/block_list.h
@@ -641,7 +641,7 @@ BlockList::local_index(unsigned int block, unsigned int index) const
 {
   AssertIndexRange(block, index_sets.size());
   const block_container& b = index_sets[block];
-  for (unsigned i=0;i<b.size();++i)
+  for (unsigned int i=0; i<b.size(); ++i)
     if (b[i] == index)
       return i;
   return numbers::invalid_unsigned_int;

diff --git a/deal.II/include/deal.II/lac/block_vector_base.h b/deal.II/include/deal.II/lac/block_vector_base.h
index 88c9e0e18384de54e1d3467562938ef77a62cf1e..f984a739a29d4e7a6a45614ec905f91368daf46f 100644 (file)
--- a/deal.II/include/deal.II/lac/block_vector_base.h
+++ b/deal.II/include/deal.II/lac/block_vector_base.h
@@ -1633,8 +1633,8 @@ namespace internal
 
     template <class BlockVectorType, bool constness>
     Iterator<BlockVectorType,constness>::
-    Iterator (BlockVector    &parent,
-              const unsigned  global_index)
+    Iterator (BlockVector       &parent,
+              const unsigned int global_index)
                     :
                     parent (&parent),
                     global_index (global_index)

diff --git a/deal.II/include/deal.II/lac/full_matrix.templates.h b/deal.II/include/deal.II/lac/full_matrix.templates.h
index 6ec578dd756df7d7620334366505a90f1698f3fc..77b7b2672e4d3b22e3dc8628cb5afc126699b583 100644 (file)
--- a/deal.II/include/deal.II/lac/full_matrix.templates.h
+++ b/deal.II/include/deal.II/lac/full_matrix.templates.h
@@ -397,7 +397,7 @@ void FullMatrix<number>::add_row (const unsigned int i,
   Assert (!this->empty(), ExcEmptyMatrix());
 
   const unsigned int size_m = m();
-  for (unsigned l=0; l<size_m; ++l)
+  for (unsigned int l=0; l<size_m; ++l)
     (*this)(i,l) += s*(*this)(j,l) + t*(*this)(k,l);
 }
 

diff --git a/deal.II/include/deal.II/lac/tridiagonal_matrix.h b/deal.II/include/deal.II/lac/tridiagonal_matrix.h
index b512c5517cf65e165140b70e912dad40c9c09fb9..857ef2027a3efa75284c66f76cd16d10c577dbf8 100644 (file)
--- a/deal.II/include/deal.II/lac/tridiagonal_matrix.h
+++ b/deal.II/include/deal.II/lac/tridiagonal_matrix.h
@@ -294,7 +294,7 @@ class TridiagonalMatrix
                                       * compute_eigenvalues(), you can
                                       * access each eigenvalue here.
                                       */
-    number eigenvalue(const unsigned i) const;
+    number eigenvalue(const unsigned int i) const;
 //@}
 ///@name Miscellanea
 //@{

diff --git a/deal.II/include/deal.II/matrix_free/fe_evaluation.h b/deal.II/include/deal.II/matrix_free/fe_evaluation.h
index f68e429ea4bcf16af3453b17015438ae0bb48871..6da19f1c8b79e9c9c82939e1390e3171fa6c5e65 100644 (file)
--- a/deal.II/include/deal.II/matrix_free/fe_evaluation.h
+++ b/deal.II/include/deal.II/matrix_free/fe_evaluation.h
@@ -3084,7 +3084,7 @@ FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
             {
               grad_out[comp][d] = (jac[d][0] *
                                    this->gradients_quad[comp][0][q_point]);
-              for (unsigned e=1; e<dim; ++e)
+              for (unsigned int e=1; e<dim; ++e)
                 grad_out[comp][d] += (jac[d][e] *
                                       this->gradients_quad[comp][e][q_point]);
             }
@@ -3457,7 +3457,7 @@ FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
         for (unsigned int d=0; d<dim; ++d)
           {
             VectorizedArray<Number> new_val = jac[0][d] * grad_in[comp][0];
-            for (unsigned e=1; e<dim; ++e)
+            for (unsigned int e=1; e<dim; ++e)
               new_val += (jac[e][d] * grad_in[comp][e]);
             this->gradients_quad[comp][d][q_point] = new_val * JxW;
           }
@@ -3581,7 +3581,7 @@ FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,1,Number>
       for (unsigned int d=0; d<dim; ++d)
         {
           grad_out[d] = (jac[d][0] * this->gradients_quad[0][0][q_point]);
-          for (unsigned e=1; e<dim; ++e)
+          for (unsigned int e=1; e<dim; ++e)
             grad_out[d] += (jac[d][e] * this->gradients_quad[0][e][q_point]);
         }
     }
@@ -3697,7 +3697,7 @@ FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,1,Number>
       for (unsigned int d=0; d<dim; ++d)
         {
           VectorizedArray<Number> new_val = jac[0][d] * grad_in[0];
-          for (unsigned e=1; e<dim; ++e)
+          for (unsigned int e=1; e<dim; ++e)
             new_val += jac[e][d] * grad_in[e];
           this->gradients_quad[0][d][q_point] = new_val * JxW;
         }
@@ -3773,10 +3773,10 @@ FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,dim,Number>
         this->cell_type == internal::MatrixFreeFunctions::general ?
         this->jacobian[q_point] : this->jacobian[0];
       divergence = (jac[0][0] * this->gradients_quad[0][0][q_point]);
-      for (unsigned e=1; e<dim; ++e)
+      for (unsigned int e=1; e<dim; ++e)
         divergence += (jac[0][e] * this->gradients_quad[0][e][q_point]);
       for (unsigned int d=1; d<dim; ++d)
-        for (unsigned e=0; e<dim; ++e)
+        for (unsigned int e=0; e<dim; ++e)
           divergence += (jac[d][e] * this->gradients_quad[d][e][q_point]);
     }
   return divergence;
@@ -3944,7 +3944,7 @@ FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,dim,Number>
          this->quadrature_weights[q_point]) * div_in;
       for (unsigned int d=0; d<dim; ++d)
         {
-          for (unsigned e=0; e<dim; ++e)
+          for (unsigned int e=0; e<dim; ++e)
             this->gradients_quad[d][e][q_point] = jac[d][e] * fac;
         }
     }
@@ -4010,7 +4010,7 @@ FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,dim,Number>
         for (unsigned int d=0; d<dim; ++d)
           {
             VectorizedArray<Number> new_val = jac[0][d] * weighted[comp][0];
-            for (unsigned e=1; e<dim; ++e)
+            for (unsigned int e=1; e<dim; ++e)
               new_val += jac[e][d] * weighted[comp][e];
             this->gradients_quad[comp][d][q_point] = new_val;
           }

diff --git a/deal.II/include/deal.II/numerics/vector_tools.templates.h b/deal.II/include/deal.II/numerics/vector_tools.templates.h
index ec5501d5fb9162e1121ab51845f5a3d431badae8..190b8866e729277e07a4c5777ad8ece7212a2320 100644 (file)
--- a/deal.II/include/deal.II/numerics/vector_tools.templates.h
+++ b/deal.II/include/deal.II/numerics/vector_tools.templates.h
@@ -336,7 +336,7 @@ namespace VectorTools
                                        // left-most and right-most
                                        // vertex and query its vertex
                                        // dof indices. that's easy :-)
-      for (unsigned direction=0; direction<2; ++direction)
+      for (unsigned int direction=0; direction<2; ++direction)
         {
           dealii::DoFHandler<1>::cell_iterator
             cell = dof_handler.begin(0);
@@ -359,7 +359,7 @@ namespace VectorTools
                                        // left-most and right-most
                                        // vertex and query its vertex
                                        // dof indices. that's easy :-)
-      for (unsigned direction=0; direction<2; ++direction)
+      for (unsigned int direction=0; direction<2; ++direction)
         {
           dealii::DoFHandler<1,2>::cell_iterator
             cell = dof_handler.begin(0);

diff --git a/deal.II/source/base/auto_derivative_function.cc b/deal.II/source/base/auto_derivative_function.cc
index 9e44a3c50def70bee47431d90b273239db0bcba3..f86853b6cd091396e68ae9688d254db1af199bb7 100644 (file)
--- a/deal.II/source/base/auto_derivative_function.cc
+++ b/deal.II/source/base/auto_derivative_function.cc
@@ -204,7 +204,7 @@ gradient_list (const std::vector<Point<dim> > &points,
       case UpwindEuler:
       {
         Point<dim> q1;
-        for (unsigned p=0; p<points.size(); ++p)
+        for (unsigned int p=0; p<points.size(); ++p)
           for (unsigned int i=0; i<dim; ++i)
             {
               q1=points[p]-ht[i];
@@ -216,7 +216,7 @@ gradient_list (const std::vector<Point<dim> > &points,
       case Euler:
       {
         Point<dim> q1, q2;
-        for (unsigned p=0; p<points.size(); ++p)
+        for (unsigned int p=0; p<points.size(); ++p)
           for (unsigned int i=0; i<dim; ++i)
             {
               q1=points[p]+ht[i];
@@ -229,7 +229,7 @@ gradient_list (const std::vector<Point<dim> > &points,
       case FourthOrder:
       {
         Point<dim> q1, q2, q3, q4;
-        for (unsigned p=0; p<points.size(); ++p)
+        for (unsigned int p=0; p<points.size(); ++p)
           for (unsigned int i=0; i<dim; ++i)
             {
               q2=points[p]+ht[i];
@@ -259,7 +259,7 @@ vector_gradient_list (const std::vector<Point<dim> >            &points,
 {
   Assert (gradients.size() == points.size(),
           ExcDimensionMismatch(gradients.size(), points.size()));
-  for (unsigned p=0; p<points.size(); ++p)
+  for (unsigned int p=0; p<points.size(); ++p)
     Assert (gradients[p].size() == this->n_components,
             ExcDimensionMismatch(gradients.size(), this->n_components));
 
@@ -268,7 +268,7 @@ vector_gradient_list (const std::vector<Point<dim> >            &points,
       case UpwindEuler:
       {
         Point<dim> q1;
-        for (unsigned p=0; p<points.size(); ++p)
+        for (unsigned int p=0; p<points.size(); ++p)
           for (unsigned int i=0; i<dim; ++i)
             {
               q1=points[p]-ht[i];
@@ -281,7 +281,7 @@ vector_gradient_list (const std::vector<Point<dim> >            &points,
       case Euler:
       {
         Point<dim> q1, q2;
-        for (unsigned p=0; p<points.size(); ++p)
+        for (unsigned int p=0; p<points.size(); ++p)
           for (unsigned int i=0; i<dim; ++i)
             {
               q1=points[p]+ht[i];
@@ -296,7 +296,7 @@ vector_gradient_list (const std::vector<Point<dim> >            &points,
       case FourthOrder:
       {
         Point<dim> q1, q2, q3, q4;
-        for (unsigned p=0; p<points.size(); ++p)
+        for (unsigned int p=0; p<points.size(); ++p)
           for (unsigned int i=0; i<dim; ++i)
             {
               q2=points[p]+ht[i];

diff --git a/deal.II/source/base/geometry_info.cc b/deal.II/source/base/geometry_info.cc
index d941c7416d7111f04e4a7b5eaeaf7b534bc70a3c..366731bc615ed9fbe015a2b72e8e26c116dae096 100644 (file)
--- a/deal.II/source/base/geometry_info.cc
+++ b/deal.II/source/base/geometry_info.cc
@@ -1410,7 +1410,7 @@ Point<dim>
 GeometryInfo<dim>::project_to_unit_cell (const Point<dim> &q)
 {
   Point<dim> p = q;
-  for(unsigned i=0; i<dim; i++)
+  for(unsigned int i=0; i<dim; i++)
     if      (p[i] < 0.)  p[i] = 0.;
     else if (p[i] > 1.)  p[i] = 1.;
 
@@ -1425,7 +1425,7 @@ GeometryInfo<dim>::distance_to_unit_cell (const Point<dim> &p)
 {
    double result = 0.0;
 
-   for(unsigned i=0; i<dim; i++)
+   for(unsigned int i=0; i<dim; i++)
       if ((-p[i]) > result)
          result = -p[i];
       else if ((p[i]-1.) > result)

diff --git a/deal.II/source/dofs/dof_renumbering.cc b/deal.II/source/dofs/dof_renumbering.cc
index 9e3b71a732c2168ecb15626116322b6a10f52b19..b65bdb052c0af85316ca0d4c1077a2c8592e62b4 100644 (file)
--- a/deal.II/source/dofs/dof_renumbering.cc
+++ b/deal.II/source/dofs/dof_renumbering.cc
@@ -1781,7 +1781,7 @@ namespace DoFRenumbering
     Assert(new_indices.size() == n_dofs,
            ExcDimensionMismatch(new_indices.size(), n_dofs));
 
-    for (unsigned i=0; i<n_dofs; ++i)
+    for (unsigned int i=0; i<n_dofs; ++i)
       new_indices[i] = i;
 
     std::random_shuffle (new_indices.begin(), new_indices.end());

diff --git a/deal.II/source/fe/fe_q.cc b/deal.II/source/fe/fe_q.cc
index 7a931ae2643fb71e18eb392cab71e40921c4ddf9..e1ee4ce1b5861825084e1c1fd2cf6fc685ee55fc 100644 (file)
--- a/deal.II/source/fe/fe_q.cc
+++ b/deal.II/source/fe/fe_q.cc
@@ -281,7 +281,7 @@ struct FE_Q<xdim,xspacedim>::Implementation
           .TableBase<2,double>::reinit (fe.interface_constraints_size());
 
         for (unsigned int i=0; i<constraint_points.size(); ++i)
-          for (unsigned j=0; j<fe.degree+1; ++j)
+          for (unsigned int j=0; j<fe.degree+1; ++j)
             {
               fe.interface_constraints(i,j) =
                 polynomials[fe.face_index_map[j]].value (constraint_points[i](0));
@@ -484,7 +484,7 @@ struct FE_Q<xdim,xspacedim>::Implementation
                   constraint_point(k) = 1.0 - constraint_point(k);
               }
 
-            for (unsigned j=0; j<pnts; ++j)
+            for (unsigned int j=0; j<pnts; ++j)
               {
                 unsigned int indices[2]
                   = { fe.face_index_map[j] % (fe.degree + 1),

diff --git a/deal.II/source/fe/fe_system.cc b/deal.II/source/fe/fe_system.cc
index a4eac7d0e58b48f60d980dfe7b3f47fbe6b51f82..89c81f762b8efe23bcb332fdd00292ef4b036f6f 100644 (file)
--- a/deal.II/source/fe/fe_system.cc
+++ b/deal.II/source/fe/fe_system.cc
@@ -343,7 +343,7 @@ FESystem<dim,spacedim>::~FESystem ()
 {
                                    // delete base elements created in
                                    // the constructor
-  for (unsigned i=0; i<base_elements.size(); ++i)
+  for (unsigned int i=0; i<base_elements.size(); ++i)
     {
       base_elements[i].first->unsubscribe(typeid(*this).name());
       delete base_elements[i].first;
@@ -1513,7 +1513,7 @@ FESystem<dim,spacedim>::build_face_tables()
       {
         unsigned comp_start = 0;
         for(unsigned base = 0; base < this->n_base_elements(); ++base)
-          for (unsigned m=0; m<this->element_multiplicity(base);
+          for (unsigned int m=0; m<this->element_multiplicity(base);
                ++m, comp_start += base_element(base).n_components())
             for (unsigned local_index = 0;
                  local_index < base_element(base).dofs_per_line;
@@ -1559,7 +1559,7 @@ FESystem<dim,spacedim>::build_face_tables()
       {
         unsigned comp_start = 0;
         for(unsigned base=0; base<this->n_base_elements(); ++base)
-          for (unsigned m=0; m<this->element_multiplicity(base);
+          for (unsigned int m=0; m<this->element_multiplicity(base);
                ++m, comp_start += base_element(base).n_components())
             for (unsigned local_index = 0;
                  local_index < base_element(base).dofs_per_quad;

diff --git a/deal.II/source/fe/fe_values.cc b/deal.II/source/fe/fe_values.cc
index a839d72159e169ad77faea960d4ae8ca0bd976d0..36e75525795988b3d5f3fbff3a1bebc0c8cad16e 100644 (file)
--- a/deal.II/source/fe/fe_values.cc
+++ b/deal.II/source/fe/fe_values.cc
@@ -1967,7 +1967,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
                                    // Assert that we can write all
                                    // components into the result
                                    // vectors
-  for (unsigned i=0;i<values.size();++i)
+  for (unsigned int i=0;i<values.size();++i)
     Assert (values[i].size() == n_components,
             ExcDimensionMismatch(values[i].size(), n_components));
 
@@ -1981,7 +1981,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
   present_cell->get_interpolated_dof_values(fe_function, dof_values);
 
                                    // initialize with zero
-  for (unsigned i=0;i<values.size();++i)
+  for (unsigned int i=0;i<values.size();++i)
     std::fill_n (values[i].begin(), values[i].size(), 0);
 
                                    // add up contributions of trial
@@ -2087,7 +2087,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
                                    // finite element
   const unsigned int result_components = indices.size() * n_components / dofs_per_cell;
 
-  for (unsigned i=0;i<values.size();++i)
+  for (unsigned int i=0;i<values.size();++i)
     Assert (values[i].size() == result_components,
             ExcDimensionMismatch(values[i].size(), result_components));
 
@@ -2100,7 +2100,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
   Assert (this->update_flags & update_values, ExcAccessToUninitializedField());
 
                                    // initialize with zero
-  for (unsigned i=0;i<values.size();++i)
+  for (unsigned int i=0;i<values.size();++i)
     std::fill_n (values[i].begin(), values[i].size(), 0);
 
                                    // add up contributions of trial
@@ -2182,7 +2182,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
     {
       Assert (values.size() == result_components,
               ExcDimensionMismatch(values.size(), result_components));
-      for (unsigned i=0;i<values.size();++i)
+      for (unsigned int i=0;i<values.size();++i)
         Assert (values[i].size() == n_quadrature_points,
                 ExcDimensionMismatch(values[i].size(), n_quadrature_points));
     }
@@ -2190,7 +2190,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
     {
       Assert(values.size() == n_quadrature_points,
              ExcDimensionMismatch(values.size(), n_quadrature_points));
-      for (unsigned i=0;i<values.size();++i)
+      for (unsigned int i=0;i<values.size();++i)
         Assert (values[i].size() == result_components,
                 ExcDimensionMismatch(values[i].size(), result_components));
     }
@@ -2204,7 +2204,7 @@ void FEValuesBase<dim,spacedim>::get_function_values (
   Assert (this->update_flags & update_values, ExcAccessToUninitializedField());
 
                                    // initialize with zero
-  for (unsigned i=0;i<values.size();++i)
+  for (unsigned int i=0;i<values.size();++i)
     std::fill_n (values[i].begin(), values[i].size(), 0);
 
                                    // add up contributions of trial
@@ -2401,7 +2401,7 @@ FEValuesBase<dim,spacedim>::get_function_gradients (
           ExcDimensionMismatch(gradients.size(), n_quadrature_points));
 
   const unsigned int n_components = fe->n_components();
-  for (unsigned i=0; i<gradients.size(); ++i)
+  for (unsigned int i=0; i<gradients.size(); ++i)
     Assert (gradients[i].size() == n_components,
             ExcDimensionMismatch(gradients[i].size(), n_components));
 
@@ -2418,7 +2418,7 @@ FEValuesBase<dim,spacedim>::get_function_gradients (
   present_cell->get_interpolated_dof_values(fe_function, dof_values);
 
                                    // initialize with zero
-  for (unsigned i=0;i<gradients.size();++i)
+  for (unsigned int i=0;i<gradients.size();++i)
     std::fill_n (gradients[i].begin(), gradients[i].size(), Tensor<1,spacedim>());
 
                                    // add up contributions of trial
@@ -2498,7 +2498,7 @@ void FEValuesBase<dim,spacedim>::get_function_gradients (
     {
       Assert (gradients.size() == result_components,
               ExcDimensionMismatch(gradients.size(), result_components));
-      for (unsigned i=0;i<gradients.size();++i)
+      for (unsigned int i=0;i<gradients.size();++i)
         Assert (gradients[i].size() == n_quadrature_points,
                 ExcDimensionMismatch(gradients[i].size(), n_quadrature_points));
     }
@@ -2506,7 +2506,7 @@ void FEValuesBase<dim,spacedim>::get_function_gradients (
     {
       Assert(gradients.size() == n_quadrature_points,
              ExcDimensionMismatch(gradients.size(), n_quadrature_points));
-      for (unsigned i=0;i<gradients.size();++i)
+      for (unsigned int i=0;i<gradients.size();++i)
         Assert (gradients[i].size() == result_components,
                 ExcDimensionMismatch(gradients[i].size(), result_components));
     }
@@ -2520,7 +2520,7 @@ void FEValuesBase<dim,spacedim>::get_function_gradients (
   Assert (this->update_flags & update_gradients, ExcAccessToUninitializedField());
 
                                    // initialize with zero
-  for (unsigned i=0;i<gradients.size();++i)
+  for (unsigned int i=0;i<gradients.size();++i)
     std::fill_n (gradients[i].begin(), gradients[i].size(), Tensor<1,spacedim>());
 
                                    // add up contributions of trial
@@ -2686,7 +2686,7 @@ get_function_hessians (const InputVector                         &fe_function,
           ExcDimensionMismatch(hessians.size(), n_quadrature_points));
 
   const unsigned int n_components = fe->n_components();
-  for (unsigned i=0;i<hessians.size();++i)
+  for (unsigned int i=0;i<hessians.size();++i)
     Assert (hessians[i].size() == n_components,
             ExcDimensionMismatch(hessians[i].size(), n_components));
 
@@ -2703,7 +2703,7 @@ get_function_hessians (const InputVector                         &fe_function,
   present_cell->get_interpolated_dof_values(fe_function, dof_values);
 
                                    // initialize with zero
-  for (unsigned i=0;i<hessians.size();++i)
+  for (unsigned int i=0;i<hessians.size();++i)
     std::fill_n (hessians[i].begin(), hessians[i].size(), Tensor<2,spacedim>());
 
                                    // add up contributions of trial
@@ -2791,7 +2791,7 @@ void FEValuesBase<dim, spacedim>::get_function_hessians (
     {
       Assert (hessians.size() == result_components,
               ExcDimensionMismatch(hessians.size(), result_components));
-      for (unsigned i=0;i<hessians.size();++i)
+      for (unsigned int i=0;i<hessians.size();++i)
         Assert (hessians[i].size() == n_quadrature_points,
                 ExcDimensionMismatch(hessians[i].size(), n_quadrature_points));
     }
@@ -2799,7 +2799,7 @@ void FEValuesBase<dim, spacedim>::get_function_hessians (
     {
       Assert(hessians.size() == n_quadrature_points,
              ExcDimensionMismatch(hessians.size(), n_quadrature_points));
-      for (unsigned i=0;i<hessians.size();++i)
+      for (unsigned int i=0;i<hessians.size();++i)
         Assert (hessians[i].size() == result_components,
                 ExcDimensionMismatch(hessians[i].size(), result_components));
     }
@@ -2811,7 +2811,7 @@ void FEValuesBase<dim, spacedim>::get_function_hessians (
   const unsigned int component_multiple = result_components / n_components;
 
                                    // initialize with zero
-  for (unsigned i=0;i<hessians.size();++i)
+  for (unsigned int i=0;i<hessians.size();++i)
     std::fill_n (hessians[i].begin(), hessians[i].size(), Tensor<2,spacedim>());
 
                                    // add up contributions of trial
@@ -2992,7 +2992,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
                                    // Assert that we can write all
                                    // components into the result
                                    // vectors
-  for (unsigned i=0;i<laplacians.size();++i)
+  for (unsigned int i=0;i<laplacians.size();++i)
     Assert (laplacians[i].size() == n_components,
             ExcDimensionMismatch(laplacians[i].size(), n_components));
 
@@ -3006,7 +3006,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
   present_cell->get_interpolated_dof_values(fe_function, dof_values);
 
                                    // initialize with zero
-  for (unsigned i=0;i<laplacians.size();++i)
+  for (unsigned int i=0;i<laplacians.size();++i)
     std::fill_n (laplacians[i].begin(), laplacians[i].size(), 0);
 
                                    // add up contributions of trial
@@ -3084,7 +3084,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
                                    // finite element
   const unsigned int result_components = indices.size() * n_components / dofs_per_cell;
 
-  for (unsigned i=0;i<laplacians.size();++i)
+  for (unsigned int i=0;i<laplacians.size();++i)
     Assert (laplacians[i].size() == result_components,
             ExcDimensionMismatch(laplacians[i].size(), result_components));
 
@@ -3097,7 +3097,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
   Assert (this->update_flags & update_hessians, ExcAccessToUninitializedField());
 
                                    // initialize with zero
-  for (unsigned i=0;i<laplacians.size();++i)
+  for (unsigned int i=0;i<laplacians.size();++i)
     std::fill_n (laplacians[i].begin(), laplacians[i].size(), 0);
 
                                    // add up contributions of trial
@@ -3181,7 +3181,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
     {
       Assert (laplacians.size() == result_components,
               ExcDimensionMismatch(laplacians.size(), result_components));
-      for (unsigned i=0;i<laplacians.size();++i)
+      for (unsigned int i=0;i<laplacians.size();++i)
         Assert (laplacians[i].size() == n_quadrature_points,
                 ExcDimensionMismatch(laplacians[i].size(), n_quadrature_points));
     }
@@ -3189,7 +3189,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
     {
       Assert(laplacians.size() == n_quadrature_points,
              ExcDimensionMismatch(laplacians.size(), n_quadrature_points));
-      for (unsigned i=0;i<laplacians.size();++i)
+      for (unsigned int i=0;i<laplacians.size();++i)
         Assert (laplacians[i].size() == result_components,
                 ExcDimensionMismatch(laplacians[i].size(), result_components));
     }
@@ -3203,7 +3203,7 @@ void FEValuesBase<dim,spacedim>::get_function_laplacians (
   Assert (this->update_flags & update_hessians, ExcAccessToUninitializedField());
 
                                    // initialize with zero
-  for (unsigned i=0;i<laplacians.size();++i)
+  for (unsigned int i=0;i<laplacians.size();++i)
     std::fill_n (laplacians[i].begin(), laplacians[i].size(), 0);
 
                                    // add up contributions of trial

diff --git a/deal.II/source/grid/grid_tools.cc b/deal.II/source/grid/grid_tools.cc
index eedaf0a5c65b85b30fe258e0e52118d819edccde..e8250f1d692b99d08c15eb8e5359fdc08b04ec81 100644 (file)
--- a/deal.II/source/grid/grid_tools.cc
+++ b/deal.II/source/grid/grid_tools.cc
@@ -745,7 +745,7 @@ namespace GridTools
         // in 3d also loop over the edges
         if (dim >= 3)
           {
-            for (unsigned e=0; e<GeometryInfo<dim>::lines_per_cell; ++e)
+            for (unsigned int e=0; e<GeometryInfo<dim>::lines_per_cell; ++e)
               if (cell->line(e)->has_children())
                 // the only place where this vertex could have been
                 // hiding is on the mid-edge point of the edge we

diff --git a/deal.II/source/grid/tria_boundary_lib.cc b/deal.II/source/grid/tria_boundary_lib.cc
index 8d442b3e890965e57f5fff8a96b4c6506d9f6757..6a48bb0c78d5392ea152ef2b0c14a9f96a357879 100644 (file)
--- a/deal.II/source/grid/tria_boundary_lib.cc
+++ b/deal.II/source/grid/tria_boundary_lib.cc
@@ -1344,7 +1344,7 @@ TorusBoundary<2,3>::get_new_point_on_line (const Triangulation<2,3>::line_iterat
                                    //Take care for periodic conditions,
                                    //For instance phi0= 0, phi1= 3/2*Pi  middle has to be 7/4*Pi not 3/4*Pi
                                    //This also works for -Pi/2 + Pi, middle is 5/4*Pi
-  for(unsigned i=0; i<2;i++)
+  for(unsigned int i=0; i<2;i++)
     if(std::abs(p0(i)-p1(i))> numbers::PI)
       middle(i)=2*numbers::PI;
 
@@ -1364,7 +1364,7 @@ TorusBoundary<2,3>::get_new_point_on_quad (const Triangulation<2,3>::quad_iterat
                                    //Just get the average
   Point<2> p[4];
 
-  for(unsigned i=0;i<4;i++)
+  for(unsigned int i=0;i<4;i++)
     p[i]=get_surf_coord(quad->vertex(i));
 
   Point<2>  middle(0,0);
@@ -1372,14 +1372,14 @@ TorusBoundary<2,3>::get_new_point_on_quad (const Triangulation<2,3>::quad_iterat
                                    //Take care for periodic conditions, see get_new_point_on_line() above
                                    //For instance phi0= 0, phi1= 3/2*Pi  middle has to be 7/4*Pi not 3/4*Pi
                                    //This also works for -Pi/2 + Pi + Pi- Pi/2, middle is 5/4*Pi
-  for(unsigned i=0;i<2;i++)
-    for(unsigned j=1;j<4;j++){
+  for(unsigned int i=0;i<2;i++)
+    for(unsigned int j=1;j<4;j++){
       if(std::abs(p[0](i)-p[j](i))> numbers::PI){
         middle(i)+=2*numbers::PI;
       }
     }
 
-  for(unsigned i=0;i<4;i++)
+  for(unsigned int i=0;i<4;i++)
     middle+=p[i];
 
   middle*= 0.25;
@@ -1434,7 +1434,7 @@ get_intermediate_points_on_line (const Triangulation<2, 3>::line_iterator &  lin
 
   Point<2> p[2];
 
-  for(unsigned i=0;i<2;i++)
+  for(unsigned int i=0;i<2;i++)
     p[i]=get_surf_coord(line->vertex(i));
 
   unsigned  offset[2];
@@ -1445,16 +1445,16 @@ get_intermediate_points_on_line (const Triangulation<2, 3>::line_iterator &  lin
                                    //see get_new_point_on_line() above
                                    //Because we dont have a symmetric interpolation (just the middle) we need to
                                    //add 2*Pi to each almost zero and negative angles.
-  for(unsigned i=0;i<2;i++)
-    for(unsigned j=1;j<2;j++){
+  for(unsigned int i=0;i<2;i++)
+    for(unsigned int j=1;j<2;j++){
       if(std::abs(p[0](i)-p[j](i))> numbers::PI){
         offset[i]++;
         break;
       }
     }
 
-  for(unsigned  i=0;i<2;i++)
-    for(unsigned  j=0;j<2;j++)
+  for(unsigned int i=0;i<2;i++)
+    for(unsigned int j=0;j<2;j++)
       if(p[j](i)<1.E-12 ) //Take care for periodic conditions & negative angles
         p[j](i)+=2*numbers::PI*offset[i];
 
@@ -1462,7 +1462,7 @@ get_intermediate_points_on_line (const Triangulation<2, 3>::line_iterator &  lin
   double dx=1.0/(npoints+1);
   double x=dx;
   Point<2>  target;
-  for(unsigned i=0; i<npoints;i++,x+=dx){
+  for(unsigned int i=0; i<npoints;i++,x+=dx){
     target=  (1-x)*p[0] + x*p[1];
     points[i]=get_real_coord(target);
   }
@@ -1487,7 +1487,7 @@ get_intermediate_points_on_quad (const Triangulation< 2, 3 >::quad_iterator &qua
 
   Point<2>  p[4];
 
-  for(unsigned  i=0;i<4;i++)
+  for(unsigned int i=0;i<4;i++)
     p[i]=get_surf_coord(quad->vertex(i));
 
   Point<2>  target;
@@ -1499,23 +1499,23 @@ get_intermediate_points_on_quad (const Triangulation< 2, 3 >::quad_iterator &qua
                                    //see get_new_point_on_line() above
                                    //Because we dont have a symmetric interpolation (just the middle) we need to
                                    //add 2*Pi to each almost zero and negative angles.
-  for(unsigned  i=0;i<2;i++)
-    for(unsigned  j=1;j<4;j++){
+  for(unsigned int i=0;i<2;i++)
+    for(unsigned int j=1;j<4;j++){
       if(std::abs(p[0](i)-p[j](i))> numbers::PI){
         offset[i]++;
         break;
       }
     }
 
-  for(unsigned  i=0;i<2;i++)
-    for(unsigned  j=0;j<4;j++)
+  for(unsigned int i=0;i<2;i++)
+    for(unsigned int j=0;j<4;j++)
       if(p[j](i)<1.E-12 ) //Take care for periodic conditions & negative angles
         p[j](i)+=2*numbers::PI*offset[i];
 
-  for (unsigned  i=0; i<m; ++i, y+=ds)
+  for (unsigned int i=0; i<m; ++i, y+=ds)
     {
       double x=ds;
-      for (unsigned  j=0; j<m; ++j, x+=ds){
+      for (unsigned int j=0; j<m; ++j, x+=ds){
         target=((1-x) * p[0] +
                 x     * p[1]) * (1-y) +
                ((1-x) * p[2] +
@@ -1534,7 +1534,7 @@ TorusBoundary<2,3>::
 get_normals_at_vertices (const Triangulation<2,3 >::face_iterator &face,
                          Boundary<2,3>::FaceVertexNormals &face_vertex_normals) const
 {
-  for(unsigned i=0; i<GeometryInfo<2>::vertices_per_face; i++)
+  for(unsigned int i=0; i<GeometryInfo<2>::vertices_per_face; i++)
     face_vertex_normals[i]=get_surf_norm(face->vertex(i));
 }
 

diff --git a/deal.II/source/numerics/matrix_tools.cc b/deal.II/source/numerics/matrix_tools.cc
index 0c5f3ce1518e523018babeed5752d335a2d696df..84bf26e84e8e58c2d9cbb6d1bd71f1c28e4fe893 100644 (file)
--- a/deal.II/source/numerics/matrix_tools.cc
+++ b/deal.II/source/numerics/matrix_tools.cc
@@ -2981,7 +2981,7 @@ namespace MatrixTools
           {
                                              // remove this row, except for the
                                              // diagonal element
-            for (unsigned j=0; j<n_local_dofs; ++j)
+            for (unsigned int j=0; j<n_local_dofs; ++j)
               if (i != j)
                 local_matrix(i,j) = 0;