libMesh/libmesh: coverage diff

Base 9e965b Head #4523 33cf8b
Total Total +/- New
Rate 65.94% 65.94% +0.00% 100.00%
Hits 79392 79390 -2 21
Misses 41016 41010 -6 0
Filename Stmts Miss Cover
include/numerics/dense_matrix.h -6 -6 +2.20%
include/numerics/dense_vector.h -7 -6 +2.99%
include/parallel/parallel_algorithms.h +5 +5 +100.00%
src/mesh/mesh_triangle_holes.C 0 +1 -0.27%
TOTAL -8 -6 +0.00%
code
coverage unchanged
code
coverage increased
code
coverage decreased
+
line added or modified

include/numerics/dense_matrix.h

922  
923  
924  
925 +
926 +
927  
928  
929  

void DenseMatrix<T>::swap(DenseMatrix<T> & other_matrix)
{
  using std::swap;
  swap(this->_m, other_matrix._m);
  swap(this->_n, other_matrix._n);
  _val.swap(other_matrix._val);
  DecompositionType _temp = _decomposition_type;
  _decomposition_type = other_matrix._decomposition_type;

1144  
1145  
1146  
1147 +
1148 +
1149 +
1150  
1151  
1152  

  libmesh_assert (this->_n);
  typedef decltype(libmesh_real(T(0))) realfromT;
  return libmesh_transform_reduce
    (_val.begin(), _val.end(), std::numeric_limits<realfromT>::max(),
     [](const auto & a, const auto & b){using std::min; return min(a,b);},
     [](const T & v){return libmesh_real(v);});
}



1159  
1160  
1161  
1162 +
1163 +
1164 +
1165  
1166  
1167  

  libmesh_assert (this->_n);
  typedef decltype(libmesh_real(T(0))) realfromT;
  return libmesh_transform_reduce
    (_val.begin(), _val.end(), std::numeric_limits<realfromT>::lowest(),
     [](const auto & a, const auto & b){using std::max; return max(a,b);},
     [](const T & v){return libmesh_real(v);});
}

include/numerics/dense_vector.h

496  
497  
498  
499 +
500 +
501  
502  
503  

inline
void DenseVector<T>::scale (const T factor)
{
  for (auto & v : _val)
    v *= factor;
}



651  
652  
653  
654 +
655 +
656 +
657  
658  
659  

  libmesh_assert (this->size());
  typedef decltype(libmesh_real(T(0))) realfromT;
  return libmesh_transform_reduce
    (_val.begin(), _val.end(), std::numeric_limits<realfromT>::max(),
     [](const auto & a, const auto & b){using std::min; return min(a,b);},
     [](const T & v){return libmesh_real(v);});
}



665  
666  
667  
668 +
669 +
670 +
671  
672  
673  

  libmesh_assert (this->size());
  typedef decltype(libmesh_real(T(0))) realfromT;
  return libmesh_transform_reduce
    (_val.begin(), _val.end(), std::numeric_limits<realfromT>::lowest(),
     [](const auto & a, const auto & b){using std::max; return max(a,b);},
     [](const T & v){return libmesh_real(v);});
}



739  
740  
741  
742  
743  
744  
745  

  const int N = cast_int<int>(sub_n);
  for (int i=0; i<N; i++)
    dest(i) = _val[i];
}


} // namespace libMesh

include/parallel/parallel_algorithms.h

33  
34  
35  
36 +
37  
38  
39  
40 +
41  
42  
43  
44  
45  
46 +
47 +
48 +
49  
50  
51  

template <typename InputIt, class T, class BinaryOp, class UnaryOp>
T libmesh_transform_reduce(InputIt begin, InputIt end, T init, BinaryOp reduce, UnaryOp transform)
{
  return std::transform_reduce(begin, end, init, reduce, transform);
}
#else
template <typename InputIt, class T, class BinaryOp, class UnaryOp>
T libmesh_transform_reduce(InputIt begin, InputIt end, T init, BinaryOp reduce, UnaryOp transform)
{
  // Reuse init as returnval.
  //
  // Don't try to do any fancy reduce() reordering/vectorization;
  // people who want that can get a real compiler.
  for (auto it = begin; it != end; ++it)
    init = reduce(init, transform(*it));
  return init;
}
#endif // LIBMESH_HAVE_CXX17_TRANSFORM_REDUCE

src/mesh/mesh_triangle_holes.C

270  
271  
272  
273  
274  
275  
276  

    {
      ray_target = inside - Point(1);
      intersection_distances =
        this->find_ray_intersections(inside, ray_target);
    }

  // I'd make this an assert, but I'm not 100% confident we can't