]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Fix many missing std:: which Compaq's cxx wants to have, mostly for two reasons:...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 2 Jul 2001 16:30:37 +0000 (16:30 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 2 Jul 2001 16:30:37 +0000 (16:30 +0000)
git-svn-id: https://svn.dealii.org/trunk@4795 0785d39b-7218-0410-832d-ea1e28bc413d

33 files changed:
deal.II/deal.II/source/dofs/dof_constraints.cc
deal.II/deal.II/source/dofs/dof_handler.cc
deal.II/deal.II/source/dofs/dof_renumbering.cc
deal.II/deal.II/source/fe/fe_values.cc
deal.II/deal.II/source/fe/mapping_c1.cc
deal.II/deal.II/source/fe/mapping_q.cc
deal.II/deal.II/source/fe/mapping_q1.cc
deal.II/deal.II/source/grid/grid_generator.cc
deal.II/deal.II/source/grid/grid_out.cc
deal.II/deal.II/source/grid/grid_refinement.cc
deal.II/deal.II/source/grid/grid_reordering.cc
deal.II/deal.II/source/grid/tria.cc
deal.II/deal.II/source/grid/tria_accessor.cc
deal.II/deal.II/source/grid/tria_boundary_lib.cc
deal.II/deal.II/source/multigrid/mg_smoother.cc
deal.II/deal.II/source/numerics/data_out.cc
deal.II/deal.II/source/numerics/data_out_rotation.cc
deal.II/deal.II/source/numerics/derivative_approximation.cc
deal.II/deal.II/source/numerics/error_estimator.cc
deal.II/deal.II/source/numerics/histogram.cc
deal.II/deal.II/source/numerics/matrices.cc
deal.II/deal.II/source/numerics/time_dependent.cc
deal.II/deal.II/source/numerics/vectors.cc
deal.II/lac/include/lac/block_vector.h
deal.II/lac/include/lac/block_vector.templates.h
deal.II/lac/include/lac/full_matrix.templates.h
deal.II/lac/include/lac/solver_cg.h
deal.II/lac/include/lac/sparse_ilu.templates.h
deal.II/lac/include/lac/swappable_vector.templates.h
deal.II/lac/include/lac/vector.h
deal.II/lac/include/lac/vector.templates.h
deal.II/lac/source/compressed_sparsity_pattern.cc
deal.II/lac/source/sparsity_pattern.cc

index 96884c75f5885e2a07d5158ae640defffc425e90..dc827038d91bcd804f10fcdefb5aa1b680e06232 100644 (file)
@@ -201,7 +201,7 @@ void ConstraintMatrix::close ()
     };
   
                                   // sort the lines
-  sort (lines.begin(), lines.end());
+  std::sort (lines.begin(), lines.end());
 
 #ifdef DEBUG
                                   // if in debug mode: check that no
@@ -218,9 +218,9 @@ void ConstraintMatrix::close ()
        ConstraintLine test_line;
        test_line.line = entry->first;
        const std::vector<ConstraintLine>::const_iterator
-         test_line_position = lower_bound (lines.begin(),
-                                           lines.end(),
-                                           test_line);
+         test_line_position = std::lower_bound (lines.begin(),
+                                                lines.end(),
+                                                test_line);
        Assert ((test_line_position == lines.end())
                ||
                (test_line_position->line != entry->first),
@@ -939,9 +939,9 @@ bool ConstraintMatrix::is_constrained (const unsigned int index) const
       ConstraintLine index_comparison;
       index_comparison.line = index;
       
-      return binary_search (lines.begin (),
-                           lines.end (),
-                           index_comparison);
+      return std::binary_search (lines.begin (),
+                                lines.end (),
+                                index_comparison);
     }
   else
     {
index 222b8a10ea72b117f5351d72408bdc0d823c9c83..04c6ddf2484709696d1fe95f0e5cca163f4d96a7 100644 (file)
@@ -1558,7 +1558,7 @@ void DoFHandler<2>::renumber_dofs (const std::vector<unsigned int> &new_numbers)
   if (true)
     {
       std::vector<unsigned int> tmp(new_numbers);
-      sort (tmp.begin(), tmp.end());
+      std::sort (tmp.begin(), tmp.end());
       std::vector<unsigned int>::const_iterator p = tmp.begin();
       unsigned int                         i = 0;
       for (; p!=tmp.end(); ++p, ++i)
index 0730d58b567c8d1d3f4ec53c88e1bb5501bf5343..6dfeda85d086d6b100d78da366f34fb9eeb38770 100644 (file)
@@ -169,11 +169,11 @@ void DoFRenumbering::Cuthill_McKee (DoFHandler<dim>                 &dof_handler
            next_round_dofs.push_back (sparsity.get_column_numbers()[j]);
       
                                       // sort dof numbers
-      sort (next_round_dofs.begin(), next_round_dofs.end());
+      std::sort (next_round_dofs.begin(), next_round_dofs.end());
 
                                       // delete multiple entries
       std::vector<unsigned int>::iterator end_sorted;
-      end_sorted = unique (next_round_dofs.begin(), next_round_dofs.end());
+      end_sorted = std::unique (next_round_dofs.begin(), next_round_dofs.end());
       next_round_dofs.erase (end_sorted, next_round_dofs.end());
 
                                       // eliminate dofs which are
@@ -243,7 +243,7 @@ void DoFRenumbering::Cuthill_McKee (DoFHandler<dim>                 &dof_handler
                                   // In any case, if not all DoFs
                                   // have been reached, renumbering
                                   // will not be possible
-  if (find (new_number.begin(), new_number.end(), DoFHandler<dim>::invalid_dof_index)
+  if (std::find (new_number.begin(), new_number.end(), DoFHandler<dim>::invalid_dof_index)
       !=
       new_number.end())
     Assert (false, ExcRenumberingIncomplete());
@@ -352,7 +352,7 @@ void DoFRenumbering::Cuthill_McKee (MGDoFHandler<dim>               &dof_handler
            next_round_dofs.push_back (sparsity.get_column_numbers()[j]);
       
                                       // sort dof numbers
-      sort (next_round_dofs.begin(), next_round_dofs.end());
+      std::sort (next_round_dofs.begin(), next_round_dofs.end());
 
                                       // delete multiple entries
       std::vector<unsigned int>::iterator end_sorted;
@@ -409,8 +409,8 @@ void DoFRenumbering::Cuthill_McKee (MGDoFHandler<dim>               &dof_handler
 
 #ifdef DEBUG
                                   //  test for all indices numbered
-  if (find (new_number.begin(), new_number.end(),
-           DoFHandler<dim>::invalid_dof_index)
+  if (std::find (new_number.begin(), new_number.end(),
+                DoFHandler<dim>::invalid_dof_index)
       !=
       new_number.end())
     Assert (false, ExcRenumberingIncomplete());
@@ -452,7 +452,7 @@ void DoFRenumbering::component_wise (DoFHandler<dim>                 &dof_handle
   Assert (component_order.size() == dof_handler.get_fe().n_components(),
          ExcInvalidComponentOrder());
   for (unsigned int i=0; i<dof_handler.get_fe().n_components(); ++i)
-    Assert (find (component_order.begin(), component_order.end(), i)
+    Assert (std::find (component_order.begin(), component_order.end(), i)
            != component_order.end(),
            ExcInvalidComponentOrder ());
 
@@ -498,10 +498,10 @@ void DoFRenumbering::component_wise (DoFHandler<dim>                 &dof_handle
                                   // entries
   for (unsigned int component=0; component<dof_handler.get_fe().n_components(); ++component)
     {
-      sort (component_to_dof_map[component].begin(),
-           component_to_dof_map[component].end());
-      component_to_dof_map[component].erase (unique (component_to_dof_map[component].begin(),
-                                                    component_to_dof_map[component].end()),
+      std::sort (component_to_dof_map[component].begin(),
+                component_to_dof_map[component].end());
+      component_to_dof_map[component].erase (std::unique (component_to_dof_map[component].begin(),
+                                                         component_to_dof_map[component].end()),
                                             component_to_dof_map[component].end());
     };
   
@@ -598,7 +598,7 @@ DoFRenumbering::cell_wise_dg (DoFHandler<dim>& dof,
   for(cell = cells.begin(); cell != cells.end(); ++cell)
     {
       (*cell)->get_dof_indices(cell_dofs);
-      sort(cell_dofs.begin(), cell_dofs.end());
+      std::sort(cell_dofs.begin(), cell_dofs.end());
 
       for (unsigned int i=0;i<n_cell_dofs;++i)
        {
@@ -654,7 +654,7 @@ DoFRenumbering::cell_wise_dg (MGDoFHandler<dim>& dof,
       Assert ((*cell)->level() == (int) level, ExcInternalError());
 
       (*cell)->get_mg_dof_indices(cell_dofs);
-      sort(cell_dofs.begin(), cell_dofs.end());
+      std::sort(cell_dofs.begin(), cell_dofs.end());
 
       for (unsigned int i=0;i<n_cell_dofs;++i)
        {
@@ -752,7 +752,7 @@ DoFRenumbering::random (DoFHandler<dim> &dof_handler)
   for (unsigned i=0; i<n_dofs; ++i)
     new_indices[i] = i;
   
-  random_shuffle (new_indices.begin(), new_indices.end());
+  std::random_shuffle (new_indices.begin(), new_indices.end());
   dof_handler.renumber_dofs(new_indices);  
 };
 
index bb2f61d398edfb309ed6b87f00e352286644aade..2014f91d776cc66bb6b8b5fd0fc5835554bf22d1 100644 (file)
@@ -141,7 +141,7 @@ void FEValuesBase<dim>::get_function_values (const InputVector            &fe_fu
     present_cell->get_interpolated_dof_values(fe_function, dof_values);
 
                                   // initialize with zero
-  fill_n (values.begin(), n_quadrature_points, 0);
+  std::fill_n (values.begin(), n_quadrature_points, 0);
 
                                   // add up contributions of trial
                                   // functions
@@ -265,7 +265,7 @@ get_function_grads (const InputVector                    &fe_function,
     present_cell->get_interpolated_dof_values(fe_function, dof_values);
 
                                   // initialize with zero
-  fill_n (gradients.begin(), n_quadrature_points, Tensor<1,dim>());
+  std::fill_n (gradients.begin(), n_quadrature_points, Tensor<1,dim>());
 
                                   // add up contributions of trial
                                   // functions
@@ -306,7 +306,7 @@ get_function_grads (const InputVector
 
                                   // initialize with zero
   for (unsigned i=0;i<gradients.size();++i)
-    fill_n (gradients[i].begin(), gradients[i].size(), Tensor<1,dim>());
+    std::fill_n (gradients[i].begin(), gradients[i].size(), Tensor<1,dim>());
 
                                   // add up contributions of trial
                                   // functions
@@ -387,7 +387,7 @@ get_function_2nd_derivatives (const InputVector
 
                                   // initialize with zero
   for (unsigned i=0;i<second_derivs.size();++i)
-    fill_n (second_derivs[i].begin(), second_derivs[i].size(), Tensor<2,dim>());
+    std::fill_n (second_derivs[i].begin(), second_derivs[i].size(), Tensor<2,dim>());
 
                                   // add up contributions of trial
                                   // functions
index cc20ddb6f3833e6d46fb323579cb6fa47d39e9aa..d33a1d906b0d67a1d8337743feb5e2afecd4585f 100644 (file)
@@ -142,14 +142,14 @@ MappingC1<2>::add_line_support_points (const Triangulation<2>::cell_iterator &ce
          coordinate_axis /= h;
 
          const double alpha = std::atan2(coordinate_axis[1], coordinate_axis[0]);
-         const double b = ((face_vertex_normals[0][1] * sin(alpha)
-                            +face_vertex_normals[0][0] * cos(alpha)) /
-                           (face_vertex_normals[0][1] * cos(alpha)
-                            -face_vertex_normals[0][0] * sin(alpha))),
-                      c = ((face_vertex_normals[1][1] * sin(alpha)
-                            +face_vertex_normals[1][0] * cos(alpha)) /
-                           (face_vertex_normals[1][1] * cos(alpha)
-                            -face_vertex_normals[1][0] * sin(alpha)));
+         const double b = ((face_vertex_normals[0][1] * std::sin(alpha)
+                            +face_vertex_normals[0][0] * std::cos(alpha)) /
+                           (face_vertex_normals[0][1] * std::cos(alpha)
+                            -face_vertex_normals[0][0] * std::sin(alpha))),
+                      c = ((face_vertex_normals[1][1] * std::sin(alpha)
+                            +face_vertex_normals[1][0] * std::cos(alpha)) /
+                           (face_vertex_normals[1][1] * std::cos(alpha)
+                            -face_vertex_normals[1][0] * std::sin(alpha)));
 
                                           // next evaluate the so
                                           // determined cubic
@@ -164,10 +164,10 @@ MappingC1<2>::add_line_support_points (const Triangulation<2>::cell_iterator &ce
                                           // scaling and shifting
          for (unsigned int i=0; i<2; ++i)
            {
-             Point<2> real_point (cos(alpha) * new_unit_points[i][0]
-                                  - sin(alpha) * new_unit_points[i][1],
-                                  sin(alpha) * new_unit_points[i][0]
-                                  + cos(alpha) * new_unit_points[i][1]);
+             Point<2> real_point (std::cos(alpha) * new_unit_points[i][0]
+                                  - std::sin(alpha) * new_unit_points[i][1],
+                                  std::sin(alpha) * new_unit_points[i][0]
+                                  + std::cos(alpha) * new_unit_points[i][1]);
              real_point *= h;
              real_point += line->vertex(0);
              a.push_back (real_point);
index d8a1c8321cb06abec0b488d6a91f1f40e2b49cbc..30ac922a5e4a099a678eec7644eef3e758919ba2 100644 (file)
@@ -104,7 +104,7 @@ MappingQ<dim>::MappingQ (const unsigned int p):
                                   // shape functions of the Qp
                                   // mapping.
   renumber.resize(n_shape_functions,0);
-  std::vector<unsigned int> dpo(dim+1, 1);
+  std::vector<unsigned int> dpo(dim+1, static_cast<unsigned int>(1));
   for (unsigned int i=1; i<dpo.size(); ++i)
     dpo[i] = dpo[i-1]*(degree-1);
   FiniteElementData<dim> fe_data(dpo, 1);
@@ -460,8 +460,8 @@ MappingQ<dim>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &loq
                                   // at the outer rim should be
                                   // one. check this
   for (unsigned int unit_point=0; unit_point<loqvs.size(); ++unit_point)
-    Assert(fabs(std::accumulate(loqvs[unit_point].begin(),
-                               loqvs[unit_point].end(),0.)-1)<1e-13,
+    Assert(std::fabs(std::accumulate(loqvs[unit_point].begin(),
+                                    loqvs[unit_point].end(),0.)-1)<1e-13,
           ExcInternalError());
   
                                   // TEST output
index e992094f51f464db652e66d1aa3a7d8d1b2c3108..3912a5212188db52472e89ce127a7502c6ee1c76 100644 (file)
@@ -409,9 +409,9 @@ MappingQ1<dim>::compute_face_data (const UpdateFlags update_flags,
          Tensor<1,dim> tangential;
          tangential[(nindex+1)%dim] = (normal_directions[i]%2) ? -1 : 1;
          data.unit_tangentials[i].resize(n_original_q_points);
-         fill (data.unit_tangentials[i].begin(),
-               data.unit_tangentials[i].end(),
-               tangential);
+         std::fill (data.unit_tangentials[i].begin(),
+                    data.unit_tangentials[i].end(),
+                    tangential);
          
          if (dim>2)
            {
@@ -479,9 +479,9 @@ MappingQ1<dim>::compute_fill (const typename DoFHandler<dim>::cell_iterator &cel
     {
       Assert (quadrature_points.size() == npts,
              ExcDimensionMismatch(quadrature_points.size(), npts));
-      fill(quadrature_points.begin(),
-          quadrature_points.end(),
-          Point<dim>());
+      std::fill(quadrature_points.begin(),
+               quadrature_points.end(),
+               Point<dim>());
     }
 
   if (update_flags & update_covariant_transformation)
@@ -494,9 +494,9 @@ MappingQ1<dim>::compute_fill (const typename DoFHandler<dim>::cell_iterator &cel
     {
       Assert (data.contravariant.size() == npts,
              ExcDimensionMismatch(data.contravariant.size(), npts));
-      fill(data.contravariant.begin(),
-          data.contravariant.end(),
-          Tensor<2,dim>());
+      std::fill(data.contravariant.begin(),
+               data.contravariant.end(),
+               Tensor<2,dim>());
     }
   
   if (update_flags & update_jacobian_grads)
@@ -679,8 +679,8 @@ MappingQ1<dim>::compute_fill_face (const typename DoFHandler<dim>::cell_iterator
                          | update_JxW_values))
        for (unsigned int i=0;i<boundary_forms.size();++i)
          {
-           double f = sqrt(contract(boundary_forms[i],
-                                    boundary_forms[i]));
+           double f = std::sqrt(contract(boundary_forms[i],
+                                         boundary_forms[i]));
            if (update_flags & update_JxW_values)
              {
                JxW_values[i] = f * weights[i];
index ef375359b7049a4b7eb3f484fbd283355406a7d0..264c18ca88abddafa111aab224e333f9d4c24089 100644 (file)
@@ -334,15 +334,15 @@ GridGenerator::hyper_ball (Triangulation<2> &tria,
                                   // equilibrate cell sizes at
                                   // transition from the inner part
                                   // to the radial cells
-  const double a = 1./(1+sqrt(2.0));
-  const Point<2> vertices[8] = { p+Point<2>(-1,-1)*(radius/sqrt(2.0)),
-                                  p+Point<2>(+1,-1)*(radius/sqrt(2.0)),
-                                  p+Point<2>(-1,-1)*(radius/sqrt(2.0)*a),
-                                  p+Point<2>(+1,-1)*(radius/sqrt(2.0)*a),
-                                  p+Point<2>(-1,+1)*(radius/sqrt(2.0)*a),
-                                  p+Point<2>(+1,+1)*(radius/sqrt(2.0)*a),
-                                  p+Point<2>(-1,+1)*(radius/sqrt(2.0)),
-                                  p+Point<2>(+1,+1)*(radius/sqrt(2.0)) };
+  const double a = 1./(1+std::sqrt(2.0));
+  const Point<2> vertices[8] = { p+Point<2>(-1,-1)*(radius/std::sqrt(2.0)),
+                                  p+Point<2>(+1,-1)*(radius/std::sqrt(2.0)),
+                                  p+Point<2>(-1,-1)*(radius/std::sqrt(2.0)*a),
+                                  p+Point<2>(+1,-1)*(radius/std::sqrt(2.0)*a),
+                                  p+Point<2>(-1,+1)*(radius/std::sqrt(2.0)*a),
+                                  p+Point<2>(+1,+1)*(radius/std::sqrt(2.0)*a),
+                                  p+Point<2>(-1,+1)*(radius/std::sqrt(2.0)),
+                                  p+Point<2>(+1,+1)*(radius/std::sqrt(2.0)) };
   
   const int cell_vertices[5][4] = {{0, 1, 3, 2},
                                   {0, 2, 4, 6},
@@ -389,8 +389,8 @@ void GridGenerator::hyper_shell (Triangulation<2>   &tria,
                                   // radii)
   const unsigned int N = (n_cells == 0 ?
                          static_cast<unsigned int>
-                         (ceil((2*pi* (outer_radius + inner_radius)/2) /
-                               (outer_radius - inner_radius))) :
+                         (std::ceil((2*pi* (outer_radius + inner_radius)/2) /
+                                    (outer_radius - inner_radius))) :
                          n_cells);
 
                                   // set up N vertices on the
@@ -402,8 +402,8 @@ void GridGenerator::hyper_shell (Triangulation<2>   &tria,
   std::vector<Point<2> > vertices(2*N);
   for (unsigned int i=0; i<N; ++i)
     {
-      vertices[i] = Point<2>( cos(2*pi * i/N),
-                             sin(2*pi * i/N)) * outer_radius;
+      vertices[i] = Point<2>( std::cos(2*pi * i/N),
+                             std::sin(2*pi * i/N)) * outer_radius;
       vertices[i+N] = vertices[i] * (inner_radius/outer_radius);
 
       vertices[i]   += center;
@@ -449,8 +449,8 @@ GridGenerator::half_hyper_shell (Triangulation<2>   &tria,
                                   // radii)
   const unsigned int N = (n_cells == 0 ?
                          static_cast<unsigned int>
-                         (ceil((pi* (outer_radius + inner_radius)/2) /
-                               (outer_radius - inner_radius))) :
+                         (std::ceil((pi* (outer_radius + inner_radius)/2) /
+                                    (outer_radius - inner_radius))) :
                          n_cells);
 
                                   // set up N+1 vertices on the
@@ -470,8 +470,8 @@ GridGenerator::half_hyper_shell (Triangulation<2>   &tria,
                                       // value of pi)
       vertices[i] =  Point<2>( ( (i==0) || (i==N) ?
                                 0 :
-                                cos(pi * i/N - pi/2) ),
-                              sin(pi * i/N - pi/2)) * outer_radius;
+                                std::cos(pi * i/N - pi/2) ),
+                              std::sin(pi * i/N - pi/2)) * outer_radius;
       vertices[i+N+1] = vertices[i] * (inner_radius/outer_radius);
 
       vertices[i]     += center;
index e95c010e8e1d2bd21598fda1411e650c2564bc9d..9b6a9aaf3325c7a16f40bd47b85bdfe83c3ef0b8 100644 (file)
@@ -69,8 +69,8 @@ void GridOut::write_ucd (const Triangulation<dim> &tria,
                                       // block this to have local
                                       // variables destroyed after
                                       // use
-      time_t  time1= time (0);
-      tm     *time = localtime(&time1); 
+      std::time_t  time1= std::time (0);
+      std::tm     *time = std::localtime(&time1); 
       out << "# This file was generated by the deal.II library." << std::endl
          << "# Date =  "
          << time->tm_year+1900 << "/"
@@ -682,9 +682,9 @@ void GridOut::write_eps (const Triangulation<dim> &tria,
        const double pi = 3.141592653589793238462;
        const double z_angle    = eps_flags_3.azimut_angle;
        const double turn_angle = eps_flags_3.turn_angle;
-       const Point<dim> view_direction(-sin(z_angle * 2.*pi / 360.) * sin(turn_angle * 2.*pi / 360.),
-                                       +sin(z_angle * 2.*pi / 360.) * cos(turn_angle * 2.*pi / 360.),
-                                       -cos(z_angle * 2.*pi / 360.));
+       const Point<dim> view_direction(-std::sin(z_angle * 2.*pi / 360.) * std::sin(turn_angle * 2.*pi / 360.),
+                                       +std::sin(z_angle * 2.*pi / 360.) * std::cos(turn_angle * 2.*pi / 360.),
+                                       -std::cos(z_angle * 2.*pi / 360.));
        
                                         // decide about the two unit vectors
                                         // in this plane. we chose the first one
@@ -692,7 +692,7 @@ void GridOut::write_eps (const Triangulation<dim> &tria,
                                         // to this plane
        const Point<dim> vector1
          = Point<dim>(0,0,1) - ((Point<dim>(0,0,1) * view_direction) * view_direction);
-       const Point<dim> unit_vector1 = vector1 / sqrt(vector1.square());
+       const Point<dim> unit_vector1 = vector1 / std::sqrt(vector1.square());
        
                                         // now the third vector is fixed. we
                                         // chose the projection of a more or
@@ -761,8 +761,8 @@ void GridOut::write_eps (const Triangulation<dim> &tria,
                                       // block this to have local
                                       // variables destroyed after
                                       // use
-      time_t  time1= time (0);
-      tm     *time = localtime(&time1); 
+      std::time_t  time1= std::time (0);
+      std::tm     *time = std::localtime(&time1); 
       out << "%!PS-Adobe-2.0 EPSF-1.2" << std::endl
          << "%%Title: deal.II Output" << std::endl
          << "%%Creator: the deal.II library" << std::endl
index 06668ad00f0b3ca841e9671717b89255c72b8775..269f87367ae32b2e035efcfd516c20e76325e14d 100644 (file)
@@ -95,7 +95,7 @@ void GridRefinement::refine (Triangulation<dim>   &tria,
   const unsigned int n_cells = criteria.size();
   
   for (unsigned int index=0; index<n_cells; ++cell, ++index)
-    if (fabs(criteria(index)) >= threshold)
+    if (std::fabs(criteria(index)) >= threshold)
       cell->set_refine_flag();
 };
 
@@ -115,7 +115,7 @@ void GridRefinement::coarsen (Triangulation<dim>   &tria,
   const unsigned int n_cells = criteria.size();
   
   for (unsigned int index=0; index<n_cells; ++cell, ++index)
-    if (fabs(criteria(index)) <= threshold)
+    if (std::fabs(criteria(index)) <= threshold)
       cell->set_coarsen_flag();
 };
 
index 70a31063ced1cb587cf9f42ccdc8ce795e53df49..65f397fa3e3727b98039c3190759b8c61e4d79e3 100644 (file)
@@ -1050,9 +1050,9 @@ void GridReordering<dim>::find_reordering (typename std::vector<Cell>
       const unsigned int
        new_cell_number = rotation_states.size()-1;
       const unsigned int
-       old_cell_number = find (new_cell_numbers.begin(),
-                               new_cell_numbers.end(),
-                               new_cell_number) - new_cell_numbers.begin();
+       old_cell_number = std::find (new_cell_numbers.begin(),
+                                    new_cell_numbers.end(),
+                                    new_cell_number) - new_cell_numbers.begin();
       Assert (old_cell_number < cells.size(), ExcInternalError());
 
       original_cells[old_cell_number].rotate (rotation_states.back());
@@ -1163,12 +1163,12 @@ GridReordering<dim>::presort_cells (typename std::vector<Cell>       &cells,
                                       // next_round_cells array,
                                       // which is needed for the next
                                       // loop iteration anyway
-      sort (new_next_round_cells.begin(), new_next_round_cells.end());
+      std::sort (new_next_round_cells.begin(), new_next_round_cells.end());
       next_round_cells.clear ();
       unique_copy (new_next_round_cells.begin(), new_next_round_cells.end(),
                   back_inserter(next_round_cells));
     };
-  Assert (find (new_cell_numbers.begin(), new_cell_numbers.end(), invalid_cell_number)
+  Assert (std::find (new_cell_numbers.begin(), new_cell_numbers.end(), invalid_cell_number)
          ==
          new_cell_numbers.end(),
          ExcInternalError());
index e7c5ce4d7f555e7142d9713d5b7f67e83c30757b..0bc0aa6885dcf315fe0c3afe07322f053dd6dc3c 100644 (file)
@@ -555,8 +555,8 @@ void Triangulation<2>::create_triangulation (const std::vector<Point<2> >    &v,
                                       // is at least two. if not so,
                                       // then clean triangulation and
                                       // exit with an exception
-      if ( ! (* (min_element(vertex_touch_count.begin(),
-                            vertex_touch_count.end())) >= 2))
+      if ( ! (* (std::min_element(vertex_touch_count.begin(),
+                                 vertex_touch_count.end())) >= 2))
        {
                                           // clear will only work if
                                           // there are no
@@ -1702,10 +1702,10 @@ void Triangulation<dim>::distort_random (const double factor,
       
                                       // first compute a random shift vector
       for (unsigned int d=0; d<dim; ++d)
-       shift_vector(d) = rand()*1.0/RAND_MAX;
+       shift_vector(d) = std::rand()*1.0/RAND_MAX;
 
       shift_vector *= factor * minimal_length[vertex] /
-                     sqrt(shift_vector.square());
+                     std::sqrt(shift_vector.square());
 
                                       // finally move the vertex
       vertices[vertex] += shift_vector;
index 91486a52ea0c085b48667d164d3bf967f6df8dc6..7137bee4c9d3088913a84472df5a6f49d04a6d02 100644 (file)
@@ -178,7 +178,7 @@ bool TriaObjectAccessor<1, dim>::at_boundary () const
 template <int dim>
 double TriaObjectAccessor<1, dim>::diameter () const
 {
-  return sqrt((vertex(1)-vertex(0)).square());
+  return std::sqrt((vertex(1)-vertex(0)).square());
 };
 
 
@@ -202,7 +202,7 @@ Point<dim> TriaObjectAccessor<1, dim>::barycenter () const
 template <int dim>
 double TriaObjectAccessor<1, dim>::measure () const
 {
-  return sqrt((vertex(1)-vertex(0)).square());
+  return std::sqrt((vertex(1)-vertex(0)).square());
 };
 
 
@@ -379,8 +379,8 @@ bool TriaObjectAccessor<2, dim>::at_boundary () const
 template <int dim>
 double TriaObjectAccessor<2, dim>::diameter () const
 {
-  return sqrt(std::max((vertex(2)-vertex(0)).square(),
-                      (vertex(3)-vertex(1)).square()));
+  return std::sqrt(std::max((vertex(2)-vertex(0)).square(),
+                           (vertex(3)-vertex(1)).square()));
 };
 
 
index 4e56c909e9d7a9892a822cf9efcde9069dac0c87..476c392464fc9ecb7f5ffb019d897adc610ae87b 100644 (file)
@@ -40,12 +40,12 @@ HyperBallBoundary<dim>::get_new_point_on_line (const typename Triangulation<dim>
   if (compute_radius_automatically)
     {
       const Point<dim> vertex_relative = line->vertex(0) - center;
-      r = sqrt(vertex_relative.square());
+      r = std::sqrt(vertex_relative.square());
     }
   else
     r=radius;
                                   // project to boundary
-  middle *= r / sqrt(middle.square());
+  middle *= r / std::sqrt(middle.square());
   
   middle += center;
   return middle;
@@ -81,12 +81,12 @@ get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) c
   if (compute_radius_automatically)
     {
       const Point<dim> vertex_relative = quad->vertex(0) - center;
-      r = sqrt(vertex_relative.square());
+      r = std::sqrt(vertex_relative.square());
     }
   else
     r=radius;
                                   // project to boundary
-  middle *= r / sqrt(middle.square());
+  middle *= r / std::sqrt(middle.square());
   
   middle += center;
   return middle;
@@ -131,7 +131,7 @@ HyperBallBoundary<dim>::get_intermediate_points_between_points (
 
   const Point<dim> v0=p0-center,
                   v1=p1-center;
-  const double length=sqrt((v1-v0).square());
+  const double length=std::sqrt((v1-v0).square());
   
   double eps=1e-14;
   double r=0;
@@ -143,14 +143,14 @@ HyperBallBoundary<dim>::get_intermediate_points_between_points (
   else
     r=radius;
 
-  Assert(fabs(v0.square()-r*r)<eps, ExcInternalError());
-  Assert(fabs(v1.square()-r*r)<eps, ExcInternalError());
+  Assert(std::fabs(v0.square()-r*r)<eps, ExcInternalError());
+  Assert(std::fabs(v1.square()-r*r)<eps, ExcInternalError());
   
-  const double alpha=acos((v0*v1)/sqrt(v0.square()*v1.square()));
+  const double alpha=std::acos((v0*v1)/sqrt(v0.square()*v1.square()));
   const double d_alpha=alpha/(n+1);
   const Point<dim> pm=0.5*(v0+v1);
   
-  const double h=sqrt(pm.square());
+  const double h=std::sqrt(pm.square());
   
   double beta=0;
   unsigned int left_index=0, right_index=0;
index ed80acf359963b8bf48327a3bfc528f46e0e681f..9fd6e980537fe1c0df7969f96189362db13d519b 100644 (file)
@@ -106,9 +106,9 @@ MGSmoother::MGSmoother (const MGDoFHandler<dim> &mg_dof, unsigned int steps)
 
                                       // now sort the list of interior boundary
                                       // dofs and eliminate duplicates
-      sort (boundary_dofs.begin(), boundary_dofs.end());
-      boundary_dofs.erase (unique (boundary_dofs.begin(),
-                                  boundary_dofs.end()),
+      std::sort (boundary_dofs.begin(), boundary_dofs.end());
+      boundary_dofs.erase (std::unique (boundary_dofs.begin(),
+                                       boundary_dofs.end()),
                           boundary_dofs.end());
 
                                       // now finally copy the result
index b2d889fbba7fae5ca1c61c70f364750f2b704b1b..ad2f58edd8972c55755039acd37b974fed835bc6 100644 (file)
@@ -315,7 +315,7 @@ void DataOut<dim>::build_some_patches (Data data)
   const unsigned int n_q_points = patch_points.n_quadrature_points;
   
   unsigned int cell_number = 0;
-  typename std::vector<DataOutBase::Patch<dim> >::iterator patch = patches.begin();
+  typename std::vector<typename DataOutBase::Patch<dim> >::iterator patch = patches.begin();
   typename DoFHandler<dim>::cell_iterator cell=first_cell();
 
                                   // get first cell in this thread
index 7d14c47f56579b754dbadcb658583365c7772fe5..877d5446196c14c9bc6adb9c261f4d3b31e88971 100644 (file)
@@ -72,8 +72,8 @@ void DataOutRotation<dim>::build_some_patches (Data data)
   std::vector<Point<dim+1> > angle_directions (n_patches_per_circle+1);
   for (unsigned int i=0; i<=n_patches_per_circle; ++i)
     {
-      angle_directions[i][0] = cos(2*pi*i/n_patches_per_circle);
-      angle_directions[i][1] = sin(2*pi*i/n_patches_per_circle);
+      angle_directions[i][0] = std::cos(2*pi*i/n_patches_per_circle);
+      angle_directions[i][1] = std::sin(2*pi*i/n_patches_per_circle);
     };
   
   
@@ -84,7 +84,7 @@ void DataOutRotation<dim>::build_some_patches (Data data)
                                   // get first cell in this thread
   for (unsigned int i=0; (i<data.this_thread)&&(cell != dofs->end()); ++i)
     {
-      advance (patch, n_patches_per_circle);
+      std::advance (patch, n_patches_per_circle);
       ++cell_number;
       cell=next_cell(cell);
     }
@@ -271,7 +271,7 @@ void DataOutRotation<dim>::build_some_patches (Data data)
                                       // belonging to this thread.
       const int skip_threads = static_cast<signed int>(data.n_threads)-1;
       for (int i=0; (i<skip_threads) && (cell != dofs->end()); ++i)
-       advance (patch, n_patches_per_circle);
+       std::advance (patch, n_patches_per_circle);
 
                                       // however, cell and cell
                                       // number have not yet been
index ee006ca738761facdd5e83b188b3e147033b6c5b..18c0595108c372f0a75fa2d222e177a64bc45f34 100644 (file)
@@ -78,7 +78,7 @@ DerivativeApproximation::Gradient<dim>::derivative_norm (const Derivative &d)
   double s = 0;
   for (unsigned int i=0; i<dim; ++i)
     s += d[i]*d[i];
-  return sqrt(s);
+  return std::sqrt(s);
 };
 
 
@@ -148,8 +148,8 @@ derivative_norm (const Derivative &d)
                                   // d_12=d_21=c
   const double radicand = ::sqr(d[0][0] - d[1][1]) + 4*::sqr(d[0][1]);
   const double eigenvalues[2]
-    = { 0.5*(d[0][0] + d[1][1] + sqrt(radicand)),
-       0.5*(d[0][0] + d[1][1] - sqrt(radicand))  };
+    = { 0.5*(d[0][0] + d[1][1] + std::sqrt(radicand)),
+       0.5*(d[0][0] + d[1][1] - std::sqrt(radicand))  };
   
   return std::max (std::fabs (eigenvalues[0]),
                   std::fabs (eigenvalues[1]));
@@ -646,7 +646,7 @@ DerivativeApproximation::approximate (const Mapping<dim>    &mapping,
                                           // the centers of two
                                           // cells
          Point<dim>   y        = neighbor_center - this_center;
-         const double distance = sqrt(y.square());
+         const double distance = std::sqrt(y.square());
                                           // normalize y
          y /= distance;
                                           // *** note that unlike in
index 087274c7d03282553acf57888655a3344f39f5c6..a1a9ff3cfc2fd7e6dba70100b31c01d9cead38f1 100644 (file)
@@ -666,7 +666,7 @@ void KellyErrorEstimator<dim>::estimate (const Mapping<dim>                  &ma
        };
 
       for (unsigned int n=0; n<n_solution_vectors; ++n)
-       (*errors[n])(present_cell) = sqrt((*errors[n])(present_cell));
+       (*errors[n])(present_cell) = std::sqrt((*errors[n])(present_cell));
     };
 };
 
index 510153d01bec55666540dcd7f7590a2dc4441832..294ce8ddb48ad28945d3968ba48a18120509ec25 100644 (file)
@@ -169,11 +169,11 @@ void Histogram::evaluate (const typename std::vector<Vector<number> > &values,
 
       case logarithmic:
       {
-       const float delta = (log(max_value)-log(min_value))/n_intervals;
+       const float delta = (std::log(max_value)-std::log(min_value))/n_intervals;
 
        for (unsigned int n=0; n<n_intervals; ++n)
-         intervals[0].push_back (Interval(exp(log(min_value)+n*delta),
-                                          exp(log(min_value)+(n+1)*delta)));
+         intervals[0].push_back (Interval(std::exp(std::log(min_value)+n*delta),
+                                          std::exp(std::log(min_value)+(n+1)*delta)));
        
        break;
       };
index 487f4679bc94d8d9bafd0d6e73756e2f04563852..270f2a0df88d61580c82c11a39d48ce05ef0da33 100644 (file)
@@ -653,7 +653,7 @@ create_boundary_mass_matrix_1 (const Mapping<dim>        &mapping,
                                           // diagonal entry.
          double max_diag_entry = 0;
          for (unsigned int i=0; i<dofs_per_cell; ++i)
-           if (fabs(cell_matrix(i,i)) > max_diag_entry)
+           if (std::fabs(cell_matrix(i,i)) > max_diag_entry)
              max_diag_entry = fabs(cell_matrix(i,i));
 #endif  
 
@@ -669,7 +669,7 @@ create_boundary_mass_matrix_1 (const Mapping<dim>        &mapping,
 //TODO:[?] We assume here that shape functions that have support also on the boundary also have their support point on the boundary (by having their indices in dof_is_on_face set true). This is not true, however, e.g. for discontinuous elements.
                                                   // compare here for relative
                                                   // smallness
-                 Assert (fabs(cell_matrix(i,j)) <= 1e-10 * max_diag_entry,
+                 Assert (std::fabs(cell_matrix(i,j)) <= 1e-10 * max_diag_entry,
                          ExcInternalError ());
                };
          
@@ -680,7 +680,7 @@ create_boundary_mass_matrix_1 (const Mapping<dim>        &mapping,
              {
                                                   // compare here for relative
                                                   // smallness
-               Assert (fabs(cell_vector(j)) <= 1e-10 * max_diag_entry,
+               Assert (std::fabs(cell_vector(j)) <= 1e-10 * max_diag_entry,
                        ExcInternalError());
              };
          mutex.release ();
index 4b4d8614bd97996011f7468a32410a5f364aca0a..091819f838a57425082b6224e9c8ba1ad063f48f 100644 (file)
@@ -58,7 +58,7 @@ void
 TimeDependent::insert_timestep (const TimeStepBase *position,
                                TimeStepBase       *new_timestep) 
 {
-  Assert ((find(timesteps.begin(), timesteps.end(), position) != timesteps.end()) ||
+  Assert ((std::find(timesteps.begin(), timesteps.end(), position) != timesteps.end()) ||
          (position == 0),
          ExcInvalidPosition());
 
@@ -97,7 +97,7 @@ TimeDependent::insert_timestep (const TimeStepBase *position,
       {
                                         // inner time step
        std::vector<TimeStepBase*>::iterator insert_position
-         = find(timesteps.begin(), timesteps.end(), position);
+         = std::find(timesteps.begin(), timesteps.end(), position);
        
        (*(insert_position-1))->set_next_timestep (new_timestep);
        new_timestep->set_previous_timestep (*(insert_position-1));
@@ -109,7 +109,7 @@ TimeDependent::insert_timestep (const TimeStepBase *position,
                                   // array
   timesteps.insert ((position == 0 ?
                     timesteps.end() :
-                    find(timesteps.begin(), timesteps.end(), position)),
+                    std::find(timesteps.begin(), timesteps.end(), position)),
                    new_timestep);
 };
 
index 0421d80c5801ad821faca8488f3af5da56b2cfbf..bf104eb10aabe10a12ae1c164a7bc5a485656141 100644 (file)
@@ -966,7 +966,8 @@ VectorTools::integrate_difference (const Mapping<dim>    &mapping,
   std::vector<std::vector<Tensor<1,dim> > > function_grads (n_q_points,
                                                            std::vector<Tensor<1,dim> >(n_components));
   std::vector<double> weight_values (n_q_points);
-  std::vector<Vector<double> > weight_vectors (n_q_points, n_components);
+  std::vector<Vector<double> > weight_vectors (n_q_points, 
+                                              Vector<double>(n_components));
   
   std::vector<Vector<double> >         psi_values (n_q_points,
                                                   Vector<double>(n_components));
@@ -1097,9 +1098,9 @@ VectorTools::integrate_difference (const Mapping<dim>    &mapping,
                          psi_scalar[q] = psi_values[q].norm_sqr();
 
                                                       // Integration on one cell
-                     diff = inner_product (psi_scalar.begin(), psi_scalar.end(),
-                                           fe_values.get_JxW_values().begin(),
-                                           0.0);
+                     diff = std::inner_product (psi_scalar.begin(), psi_scalar.end(),
+                                                fe_values.get_JxW_values().begin(),
+                                                0.0);
                      if (norm == L2_norm)
                        diff=sqrt(diff);
                      break;
@@ -1114,7 +1115,7 @@ VectorTools::integrate_difference (const Mapping<dim>    &mapping,
                                psi_scalar[q] = 0;
                                // weighted scalar product
                                for (unsigned int i=0; i<n_components; ++i)
-                                 psi_scalar[q] += fabs(psi_values[q](i))
+                                 psi_scalar[q] += std::fabs(psi_values[q](i))
                                                   * weight_vectors[q](i);
                              }
                          else // weight->n_components == 1
@@ -1144,7 +1145,7 @@ VectorTools::integrate_difference (const Mapping<dim>    &mapping,
                                psi_scalar[q] = 0;
                                for (unsigned int i=0; i<n_components; ++i)
                                  {
-                                   double newval = fabs(psi_values[q](i))
+                                   double newval = std::fabs(psi_values[q](i))
                                                    * weight_vectors[q](i);
                                    if (psi_scalar[q]<newval)
                                      psi_scalar[q] = newval;
index fa06d9a20bd5fdfceb57061629ab505e73b208d3..5ef51077eb8b19c2635c4ec46f3d61f1075af37c 100644 (file)
@@ -437,11 +437,6 @@ class BlockVector
                                      * @name 5: Mixed stuff
                                      */
                                     //@{
-                                    /**
-                                     *  Output of vector in user-defined format.
-                                     */
-    void print (FILE* fp, const char* format = 0) const;
-    
                                     /**
                                      *  Output of vector in user-defined format.
                                      */
index 1c6b6144c7127fa17ef2907c0d1bdc668dd13646..a5aafd99ab1281ce11bf4a7a3183f2a32e471aa3 100644 (file)
@@ -204,7 +204,7 @@ Number BlockVector<Number>::l1_norm () const
 template <typename Number>
 Number BlockVector<Number>::l2_norm () const
 {
-  return sqrt(norm_sqr());
+  return std::sqrt(norm_sqr());
 }
 
 
index 1c492bf0cb3393c8387ada1c7c90ca9c53019021..256d706e83a8a41f0094509db95333def4375a54 100644 (file)
@@ -273,7 +273,7 @@ double FullMatrix<number>::residual (Vector<number2>& dst,
       dst(i) = s;
       res += s*s;
     }
-  return sqrt(res);
+  return std::sqrt(res);
 }
 
 
@@ -595,7 +595,7 @@ number FullMatrix<number>::l1_norm () const
     {
       sum=0;
       for (unsigned int row=0; row<n_rows; ++row)
-       sum += fabs(el(row,col));
+       sum += std::fabs(el(row,col));
       if (sum > max)
        max = sum;
     }
@@ -615,7 +615,7 @@ number FullMatrix<number>::linfty_norm () const
     {
       sum=0;
       for (unsigned int col=0; col<n_cols; ++col)
-       sum += fabs(el(row,col));
+       sum += std::fabs(el(row,col));
       if (sum > max)
        max = sum;
     }
@@ -1074,7 +1074,7 @@ FullMatrix<number>::norm2 () const
   number s = 0.;
   for (unsigned int i=0;i<n_rows()*n_cols();++i)
     s += data()[i]*data()[i];
-  return sqrt(s);
+  return std::sqrt(s);
 }
 
 
@@ -1093,7 +1093,7 @@ FullMatrix<number>::relative_symmetry_norm2 () const
        s += (*this)(i,j)*(*this)(i,j);
       }
   if (s!=0.)
-    return sqrt(a)/sqrt(s);
+    return std::sqrt(a)/std::sqrt(s);
   return 0;
 }
 
@@ -1323,13 +1323,13 @@ FullMatrix<number>::gauss_jordan()
   for (unsigned int j=0; j<n(); ++j)
     {
                                       // pivotsearch
-      number       max = fabs(el(j,j));
+      number       max = std::fabs(el(j,j));
       unsigned int r   = j;
       for (unsigned int i=j+1; i<n(); ++i)
        {
-         if (fabs(el(i,j)) > max)
+         if (std::fabs(el(i,j)) > max)
            {
-             max = fabs(el(i,j));
+             max = std::fabs(el(i,j));
              r = i;
            }
        }
@@ -1391,9 +1391,9 @@ FullMatrix<number>::householder(Vector<number2>& src)
     number2 sigma = 0;
     unsigned int i;
     for (i=j ; i<m() ; ++i) sigma += el(i,j)*el(i,j);
-    if (fabs(sigma) < 1.e-15) return;
+    if (std::fabs(sigma) < 1.e-15) return;
     number2 s = el(j,j);
-    s = (s<0) ? sqrt(sigma) : -sqrt(sigma);
+    s = (s<0) ? std::sqrt(sigma) : -std::sqrt(sigma);
     number2 dj = s;
 
     number2 beta = 1./(s*el(j,j)-sigma);
@@ -1432,7 +1432,7 @@ FullMatrix<number>::least_squares(Vector<number2>& dst, Vector<number2>& src)
 
   number2 sum = 0.;
   for (unsigned int i=n() ; i<m() ; ++i) sum += src(i) * src(i);
-  return sqrt(sum);
+  return std::sqrt(sum);
 }
 
 
index df95f6aa67a92f27d2b4a6a919ea54751bbd689a..d0e5f76002ae6e89a7fdc750c46f5d6210fa2893 100644 (file)
@@ -171,7 +171,7 @@ template<class VECTOR>
 double
 SolverCG<VECTOR>::criterion()
 {
-  return sqrt(res2);
+  return std::sqrt(res2);
 }
 
 
index b12ad24d3eebe00a28d7d4483cfe1bbaf68c1d34..e356222bf5a557c5c1efcc1ca521f49010ba9995 100644 (file)
@@ -108,7 +108,7 @@ void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
        number rowsum = 0;
        for (unsigned int global_index=rowstart;
             global_index<rowstart+rowlength; ++global_index)
-         rowsum += fabs(global_entry(global_index));
+         rowsum += std::fabs(global_entry(global_index));
 
        *diagonal_element += strengthen_diagonal * rowsum;
       };
index 964da1c14f7025b89feca3e3e87ca9425cb24683..6e4e03ad3755d68824094db71f1a60c954be363d 100644 (file)
@@ -241,7 +241,7 @@ void SwappableVector<number>::kill_file ()
   
   if (filename != "")
     {
-      int status = remove (filename.c_str());
+      int status = std::remove (filename.c_str());
       AssertThrow (status == 0, ExcInternalError());
   
       filename = "";
index a852fff4e3ce9efcd7335da920b8f694f6525c8b..0ada7046dbb89f66cc75c4a2685307f5af6d8a94 100644 (file)
@@ -417,11 +417,6 @@ class Vector
                                      * @name 5: Mixed stuff
                                      */
                                     //@{
-                                    /**
-                                     *  Output of vector in user-defined format.
-                                     */
-    void print (FILE* fp, const char* format = 0) const;
-    
                                     /**
                                      *  Output of vector in user-defined format.
                                      */
index a5920399284598a9bb4ccf17d5968c53a29b6269..682610b6e160d9706441cd0b1e8ddfc788cd1f75 100644 (file)
@@ -207,14 +207,14 @@ Number Vector<Number>::l1_norm () const
                 eptr = ptr + (dim/4)*4;
   while (ptr!=eptr)
     {
-      sum0 += fabs(*ptr++);
-      sum1 += fabs(*ptr++);
-      sum2 += fabs(*ptr++);
-      sum3 += fabs(*ptr++);
+      sum0 += std::fabs(*ptr++);
+      sum1 += std::fabs(*ptr++);
+      sum2 += std::fabs(*ptr++);
+      sum3 += std::fabs(*ptr++);
     };
                                   // add up remaining elements
   while (ptr != end())
-    sum0 += fabs(*ptr++);
+    sum0 += std::fabs(*ptr++);
   
   return sum0+sum1+sum2+sum3;
 };
@@ -223,7 +223,7 @@ Number Vector<Number>::l1_norm () const
 template <typename Number>
 Number Vector<Number>::l2_norm () const
 {
-  return sqrt(norm_sqr());
+  return std::sqrt(norm_sqr());
 };
 
 
@@ -237,15 +237,15 @@ Number Vector<Number>::linfty_norm () const {
         max3=0.;
   for (unsigned int i=0; i<(dim/4); ++i) 
     {
-      if (max0<fabs(val[4*i]))   max0=fabs(val[4*i]);
-      if (max1<fabs(val[4*i+1])) max1=fabs(val[4*i+1]);
-      if (max2<fabs(val[4*i+2])) max2=fabs(val[4*i+2]);
-      if (max3<fabs(val[4*i+3])) max3=fabs(val[4*i+3]);
+      if (max0<std::fabs(val[4*i]))   max0=std::fabs(val[4*i]);
+      if (max1<std::fabs(val[4*i+1])) max1=std::fabs(val[4*i+1]);
+      if (max2<std::fabs(val[4*i+2])) max2=std::fabs(val[4*i+2]);
+      if (max3<std::fabs(val[4*i+3])) max3=std::fabs(val[4*i+3]);
     };
                                   // add up remaining elements
   for (unsigned int i=(dim/4)*4; i<dim; ++i)
-    if (max0<fabs(val[i]))
-      max0 = fabs(val[i]);
+    if (max0<std::fabs(val[i]))
+      max0 = std::fabs(val[i]);
 
   return std::max (std::max(max0, max1),
                   std::max(max2, max3));
@@ -514,26 +514,14 @@ Vector<Number>::operator = (const Vector<Number2>& v)
 
 
 
-template <typename Number>
-void Vector<Number>::print (FILE* f, const char* format) const
-{
-  Assert (dim!=0, ExcEmptyVector());
-  if (!format) format = " %5.2f";
-  for (unsigned int j=0;j<size();j++)
-    fprintf(f, format, val[j]);
-  fputc('\n',f);
-}
-
-
-
 template <typename Number>
 void Vector<Number>::print (const char* format) const
 {
   Assert (dim!=0, ExcEmptyVector());
   if (!format) format = " %5.2f";
   for (unsigned int j=0;j<size();j++)
-    printf (format, val[j]);
-  printf ("\n");
+    std::printf (format, val[j]);
+  std::printf ("\n");
 }
 
 
@@ -579,10 +567,10 @@ void Vector<Number>::block_write (std::ostream &out) const
   const unsigned int sz = size();
   char buf[16];
   
-  sprintf(buf, "%d", sz);
-  strcat(buf, "\n[");
+  std::sprintf(buf, "%d", sz);
+  std::strcat(buf, "\n[");
   
-  out.write(buf, strlen(buf));
+  out.write(buf, std::strlen(buf));
   out.write (reinterpret_cast<const char*>(begin()),
             reinterpret_cast<const char*>(end())
             - reinterpret_cast<const char*>(begin()));
@@ -607,7 +595,7 @@ void Vector<Number>::block_read (std::istream &in)
   
 
   in.getline(buf,16,'\n');
-  sz=atoi(buf);
+  sz=std::atoi(buf);
   
                                   // fast initialization, since the
                                   // data elements are overwritten anyway
index f779e404f0390dac90bbd43ddb1d12ec2fc6d1b1..d9f6e9ed489e64292c4ac0ae3e9477c5d4743840 100644 (file)
@@ -201,8 +201,8 @@ CompressedSparsityPattern::bandwidth () const
   for (unsigned int row=0; row<rows; ++row)
     for (std::set<unsigned int>::const_iterator i=column_indices[row].begin();
         i!=column_indices[row].end(); ++i)
-      if (static_cast<unsigned int>(abs(static_cast<int>(row-*i))) > b)
-       b = abs(static_cast<signed int>(row-*i));
+      if (static_cast<unsigned int>(std::abs(static_cast<int>(row-*i))) > b)
+       b = std::abs(static_cast<signed int>(row-*i));
 
   return b;
 };
index 8eb682f67b73b4bf4520ffdac0aa856f469b2d33..cc0760cf88164bb13e5a7a8fc475c5a1a5263f99 100644 (file)
@@ -663,8 +663,8 @@ SparsityPattern::bandwidth () const
     for (unsigned int j=rowstart[i]; j<rowstart[i+1]; ++j)
       if (colnums[j] != invalid_entry)
        {
-         if (static_cast<unsigned int>(abs(static_cast<int>(i-colnums[j]))) > b)
-           b = abs(static_cast<signed int>(i-colnums[j]));
+         if (static_cast<unsigned int>(std::abs(static_cast<int>(i-colnums[j]))) > b)
+           b = std::abs(static_cast<signed int>(i-colnums[j]));
        }
       else
                                         // leave if at the end of

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.