libMesh/libmesh: coverage diff

Base e27e71 Head #4300 1cc1b6
Total Total +/- New
Rate 65.01% 65.01% +0.00% 56.00%
Hits 76961 76962 +1 14
Misses 41430 41429 -1 11
Filename Stmts Miss Cover
src/mesh/mesh_triangle_holes.C 0 -1 +0.27%
TOTAL 0 -1 +0.00%
code
coverage unchanged
code
coverage increased
code
coverage decreased
+
line added or modified

include/numerics/dense_matrix.h

1122  
1123  
1124  
1125 +
1126  
1127  
1128  
1129  
1130  
1131 +
1132  
1133  
1134 +
1135  
1136  
1137  


template<typename T>
inline
auto DenseMatrix<T>::l1_norm () const
{
  libmesh_assert (this->_m);
  libmesh_assert (this->_n);

  using std::abs;
  auto columnsum = abs(T(0));
  for (unsigned int i=0; i!=this->_m; i++)
    {
      columnsum += abs((*this)(i,0));
    }
  auto my_max = columnsum;
  for (unsigned int j=1; j!=this->_n; j++)

1139  
1140  
1141  
1142 +
1143  
1144  
1145  

      columnsum = 0.;
      for (unsigned int i=0; i!=this->_m; i++)
        {
          columnsum += abs((*this)(i,j));
        }
      my_max = (my_max > columnsum? my_max : columnsum);
    }

1150  
1151  
1152  
1153 +
1154  
1155  
1156  
1157  
1158  
1159 +
1160  
1161  
1162 +
1163  
1164  
1165  


template<typename T>
inline
auto DenseMatrix<T>::linfty_norm () const
{
  libmesh_assert (this->_m);
  libmesh_assert (this->_n);
  using std::abs;

  auto rowsum = abs(T(0));
  for (unsigned int j=0; j!=this->_n; j++)
    {
      rowsum += abs((*this)(0,j));
    }
  auto my_max = rowsum;
  for (unsigned int i=1; i!=this->_m; i++)

1167  
1168  
1169  
1170 +
1171  
1172  
1173  

      rowsum = 0.;
      for (unsigned int j=0; j!=this->_n; j++)
        {
          rowsum += abs((*this)(i,j));
        }
      my_max = (my_max > rowsum? my_max : rowsum);
    }

include/numerics/dense_matrix_impl.h

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

      _pivots[i] = i;

      // abs(complex) must return a Real!
      auto the_max = abs( A(i,i) );
      for (unsigned int j=i+1; j<n_rows; ++j)
        {
          auto candidate_max = abs( A(j,i) );
          if (the_max < candidate_max)
            {
              the_max = candidate_max;

905  
906  
907  
908 +
909  
910  
911  

                                   "Error! Can only use Cholesky decomposition with symmetric positive definite matrices.");
#endif

              A(i,i) = sqrt(A(i,j));
            }
          else
            A(j,i) = A(i,j) / A(i,i);

include/numerics/tensor_tools.h

71  
72  
73  
74 +
75 +
76  
77  
78  


template<typename T>
inline
auto norm(const T & a)
{ using std::abs; return abs(a); }

template<typename T>
inline

86  
87  
88  
89 +
90  
91  
92  

template <typename T>
inline
auto norm(const VectorValue<T> & a) -> decltype(TensorTools::norm(T()))
{using std::sqrt; return sqrt(a.norm_sq());}

template <typename T>
inline

101  
102  
103  
104 +
105 +
106  
107  
108  


template<typename T>
inline
auto norm_sq(const T & a)
{ using std::norm; return norm(a); }

template<typename T>
inline

115  
116  
117  
118 +
119  
120  
121  


template <typename T>
inline
auto norm_sq(const VectorValue<T> & a)
{return a.norm_sq();}

template <typename T>

include/numerics/type_n_tensor.h

218  
219  
220  
221 +
222  
223  
224  

   * \returns The Frobenius norm of the tensor, i.e. the square-root of
   * the sum of the elements squared.
   */
  auto norm() const
  {
    libmesh_not_implemented();
    return 0.;

228  
229  
230  
231 +
232  
233  
234  

   * \returns The Frobenius norm of the tensor squared, i.e. the sum of the
   * entry magnitudes squared.
   */
  auto norm_sq() const
  {
    libmesh_not_implemented();
    return 0.;

include/numerics/type_tensor.h

1277  
1278  
1279  
1280 +
1281  
1282  
1283 +
1284  
1285  
1286  


template <typename T>
inline
auto TypeTensor<T>::norm() const
{
  using std::sqrt;
  return sqrt(this->norm_sq());
}



1346  
1347  
1348  
1349 +
1350  
1351  
1352  


template <typename T>
inline
auto TypeTensor<T>::norm_sq () const
{
  Real sum = 0.;
  for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)

include/numerics/type_vector.h

904  
905  
906  
907 +
908  
909  
910 +
911  
912  
913  


template <typename T>
inline
auto TypeVector<T>::norm() const
{
  using std::sqrt;
  return sqrt(this->norm_sq());
}



924  
925  
926  
927 +
928  
929  
930  


template <typename T>
inline
auto TypeVector<T>::norm_sq() const
{
#if LIBMESH_DIM == 1
  return (TensorTools::norm_sq(_coords[0]));

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