libMesh::Utility Namespace Reference

Classes
struct	do_pow
	An efficient template instantiation for raising to an arbitrary integer power. More...
struct	do_pow< 0, T >
struct	do_pow< 1, T >
struct	do_pow< 6, T >
class	ReverseBytes
	This Functor simply takes an object and reverses its byte representation. More...

Functions
template<typename T >
std::string	enum_to_string (const T e)
uint32_t	hashword (const uint32_t *k, size_t length, uint32_t initval=0)
	The hashword function takes an array of uint32_t's of length 'length' and computes a single key from it. More...
uint32_t	hashword (const std::vector< uint32_t > &keys, uint32_t initval=0)
	Calls function above with slightly more convenient std::vector interface. More...
uint32_t	hashword2 (const uint32_t &first, const uint32_t &second, uint32_t initval=0)
	This is a hard-coded version of hashword for hashing exactly 2 numbers. More...
uint64_t	hashword2 (const uint64_t first, const uint64_t second)
	Call the 64-bit FNV hash function. More...
uint16_t	hashword2 (const uint16_t first, const uint16_t second)
uint64_t	hashword (const uint64_t *k, size_t length)
	Call the 64-bit FNV hash function. More...
uint16_t	hashword (const uint16_t *k, size_t length)
	In a personal communication from Bob Jenkins, he recommended using "Probably final() from lookup3.c... More...
template<typename Container >
Container::value_type	hashword (const Container &keys)
	Calls functions above with slightly more convenient std::vector/array compatible interface. More...
template<typename T >
T	string_to_enum (const std::string &s)
std::string	get_timestamp ()
void	print_timestamp (std::ostream &target=std::cout)
std::string	system_info ()
template<typename Map >
Map::mapped_type &	map_find (Map &map, const typename Map::key_type &key, const char *filename, int line_number)
	This function should not be called directly (although it can be), instead see the libmesh_map_find() macro. More...
template<typename Map >
const Map::mapped_type &	map_find (const Map &map, const typename Map::key_type &key, const char *filename, int line_number)
	A version of the function above that works for const objects. More...
template<typename ForwardIter , typename T >
void	iota (ForwardIter first, ForwardIter last, T value)
	Utility::iota is a duplication of the SGI STL extension std::iota. More...
template<class InputIterator >
bool	is_sorted (InputIterator first, InputIterator last)
	Utility::is_sorted mimics the behavior of the SGI STL extension std::is_sorted. More...
template<class ForwardIterator , class T >
ForwardIterator	binary_find (ForwardIterator first, ForwardIterator last, const T &value)
	The STL provides std::binary_search() which returns true or false depending on whether the searched-for value is found. More...
template<class ForwardIterator , class T , class Compare >
ForwardIterator	binary_find (ForwardIterator first, ForwardIterator last, const T &value, Compare comp)
	As above, but takes a custom comparison object. More...
template<int N, typename T >
T	pow (const T &x)
unsigned int	factorial (unsigned int n)
	A simple implementation of the factorial. More...
template<typename T >
T	binomial (T n, T k)
template<typename T >
void	deallocate (std::vector< T > &vec)
	A convenient method to truly empty a vector using the "swap trick". More...
std::string	complex_filename (const std::string &basename, unsigned int r_o_c=0)
void	prepare_complex_data (const std::vector< Complex > &source, std::vector< Real > &real_part, std::vector< Real > &imag_part)
	Prepare complex data for writing. More...
int	mkdir (const char *pathname)
	Create a directory. More...

Function Documentation

binary_find() [1/2]

template<class ForwardIterator , class T >

ForwardIterator libMesh::Utility::binary_find	(	ForwardIterator	first,
		ForwardIterator	last,
		const T &	value
	)

The STL provides std::binary_search() which returns true or false depending on whether the searched-for value is found.

In contrast, Utility::binary_find() uses a std::lower_bound() based search on a sorted range to find the required value.

Returns

An iterator to the searched-for element, or "last" if the element is not found.

Definition at line 183 of file utility.h.

{
  ForwardIterator it = std::lower_bound(first, last, value);
  return (it == last || value < *it) ? last : it;
}

References value.

Referenced by libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole().

binary_find() [2/2]

template<class ForwardIterator , class T , class Compare >

ForwardIterator libMesh::Utility::binary_find	(	ForwardIterator	first,
		ForwardIterator	last,
		const T &	value,
		Compare	comp
	)

As above, but takes a custom comparison object.

Definition at line 193 of file utility.h.

{
  ForwardIterator it = std::lower_bound(first, last, value, comp);
  return (it == last || comp(value,*it)) ? last : it;
}

References value.

binomial()

template<typename T >

T libMesh::Utility::binomial	(	T	n,
		T	k
	)

Definition at line 272 of file utility.h.

{
  T ret = 1;
 
  // Binomial function is "symmetric" in k, C(n, k) = C(n, n-k).
  if (k > n - k)
    k = n - k;
 
  // Compute n * (n-1) * ... * (n-k+1) / (k * (k-1) * ... * 1)
  for (T i = 0; i < k; ++i)
    {
      ret *= (n - i);
      ret /= (i + 1);
    }
 
  return ret;
}

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::shape(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv().

complex_filename()

std::string libMesh::Utility::complex_filename	(	const std::string &	basename,
		unsigned int	r_o_c = 0
	)

Returns

For r_o_c = 0 the filename for output of the real part of complex data, and for r_o_c = 1 the filename for the imaginary part.

Definition at line 105 of file utility.C.

{
  std::string name(basename);
 
  if (r_o_c == 0)
    name.append(".real");
 
  else
    name.append(".imag");
 
  return name;
}

References libMesh::Quality::name().

deallocate()

template<typename T >

void libMesh::Utility::deallocate

(

std::vector< T > &

vec

)

A convenient method to truly empty a vector using the "swap trick".

Definition at line 295 of file utility.h.

{
  std::vector<T>().swap(vec);
}

Referenced by libMesh::Nemesis_IO::read().

enum_to_string()

template<typename T >

std::string libMesh::Utility::enum_to_string

(

const T

e

)

Returns

the string which matches the enumeration e of type T.

Referenced by libMesh::RBDataSerialization::add_elem_to_builder(), libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::MeshTools::find_nodal_neighbors(), libMesh::ReferenceElem::get(), libMesh::FEInterface::get_continuity(), libMesh::Elem::get_info(), libMesh::QNodal::init_1D(), libMesh::QClough::init_2D(), libMesh::QGaussLobatto::init_2D(), libMesh::QTrap::init_2D(), libMesh::QConical::init_2D(), libMesh::QGrid::init_2D(), libMesh::QGauss::init_2D(), libMesh::QSimpson::init_2D(), libMesh::QNodal::init_2D(), libMesh::QGrundmann_Moller::init_2D(), libMesh::QClough::init_3D(), libMesh::QGaussLobatto::init_3D(), libMesh::QTrap::init_3D(), libMesh::QConical::init_3D(), libMesh::QGrid::init_3D(), libMesh::QGauss::init_3D(), libMesh::QSimpson::init_3D(), libMesh::QNodal::init_3D(), libMesh::QGrundmann_Moller::init_3D(), libMesh::LinearSolver< Number >::print_converged_reason(), libMesh::Elem::quality(), libMesh::ExodusII_IO::read(), libMesh::AbaqusIO::read_elements(), libMesh::DofMap::reinit(), libMesh::Elem::second_order_equivalent_type(), libMesh::PetscLinearSolver< Number >::set_petsc_solver_type(), libMesh::SlepcEigenSolver< libMesh::Number >::set_slepc_solver_type(), libMesh::AztecLinearSolver< T >::set_solver_type(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::LaspackLinearSolver< T >::solve(), QuadratureTest::testBuild(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_discontinuous_gmv(), and libMesh::ExodusII_IO_Helper::write_elements().

factorial()

unsigned int libMesh::Utility::factorial ( unsigned int  n )

inline

A simple implementation of the factorial.

Definition at line 255 of file utility.h.

{
 
  unsigned int factorial_n = 1;
 
  if (n==0)
    return factorial_n;
 
  for (unsigned int i=1; i<n; i++)
    factorial_n *= i+1;
 
  return factorial_n;
}

get_timestamp()

std::string libMesh::Utility::get_timestamp

(

)

Definition at line 37 of file timestamp.C.

{
#ifdef LIBMESH_HAVE_LOCALE
  // Create time_put "facet"
  std::locale loc;
  const std::time_put<char> & tp = std::use_facet <std::time_put<char>> (loc);
 
  // Call C-style time getting functions
  time_t now = time(nullptr);
  tm * tm_struct = localtime(&now);
 
  // Date will eventually be stored in this ostringstream's string
  std::ostringstream date_stream;
 
  // See below for documentation on the use of the
  // std::time_put::put() function
  tp.put(date_stream,        /*s*/
         date_stream,        /*str*/
         date_stream.fill(), /*fill*/
         tm_struct,          /*tm*/
         'c');               /*format*/
 
  // Another way to use it is to totally customize the format...
  //    char pattern[]="%d %B %Y %I:%M:%S %p";
  //    tp.put(date_stream,                /*s*/
  //   date_stream,                /*str*/
  //   date_stream.fill(),         /*fill*/
  //   tm_struct,                  /*tm*/
  //   pattern,                    /*format begin*/
  //   pattern+sizeof(pattern)-1); /*format end  */
 
  return date_stream.str();
#else
  // C-style code originally found here:
  // http://people.sc.fsu.edu/~burkardt/cpp_src/timestamp/timestamp.C
  // Author: John Burkardt, 24 September 2003
  const unsigned int time_size = 40;
  char time_buffer[time_size];
 
  time_t now = time (nullptr);
  tm * tm_struct = localtime (&now);
 
  // No more than time_size characters will be placed into the array.  If the
  // total number of resulting characters, including the terminating
  // NUL character, is not more than time_size, strftime() returns the
  // number of characters in the array, not counting the terminating
  // NUL.  Otherwise, zero is returned and the buffer contents are
  // indeterminate.
  size_t len = strftime ( time_buffer, time_size, "%c", tm_struct );
 
  if (len != 0)
    return std::string(time_buffer);
  else
    {
      libMesh::out << "Error formatting time buffer, returning empty string!" << std::endl;
      return std::string("");
    }
 
#endif // LIBMESH_HAVE_LOCALE
}

References libMesh::out.

Referenced by libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::PerfLog::get_info_header(), print_timestamp(), system_info(), libMesh::TransientRBConstruction::update_residual_terms(), and libMesh::RBConstruction::update_residual_terms().

hashword() [1/5]

template<typename Container >

Container::value_type libMesh::Utility::hashword ( const Container &  keys )

inline

Calls functions above with slightly more convenient std::vector/array compatible interface.

Definition at line 304 of file hashword.h.

{
  return hashword(keys.data(), keys.size());
}

References hashword().

hashword() [2/5]

uint32_t libMesh::Utility::hashword ( const std::vector< uint32_t > &  keys, uint32_t  initval = 0  )

inline

Calls function above with slightly more convenient std::vector interface.

Definition at line 195 of file hashword.h.

{
  return hashword(keys.data(), keys.size(), initval);
}

References hashword().

hashword() [3/5]

uint16_t libMesh::Utility::hashword ( const uint16_t *  k, size_t  length  )

inline

In a personal communication from Bob Jenkins, he recommended using "Probably final() from lookup3.c...

You could hash up to 6 16-bit integers that way. The output is c, or the top or bottom 16 bits of c if you only need 16 bit hash values." [JWP]

Definition at line 263 of file hashword.h.

{
  // Three values that will be passed to final() after they are initialized.
  uint32_t a = 0;
  uint32_t b = 0;
  uint32_t c = 0;
 
  switch (length)
    {
    case 3:
      {
        // Cast the inputs to 32 bit integers and call final().
        a = k[0];
        b = k[1];
        c = k[2];
        break;
      }
    case 4:
      {
        // Combine the 4 16-bit inputs, "w, x, y, z" into two 32-bit
        // inputs "wx" and "yz" using bit operations and call final.
        a = ((k[0]<<16) | (k[1] & 0xffff)); // wx
        b = ((k[2]<<16) | (k[3] & 0xffff)); // yz
        break;
      }
    default:
      libmesh_error_msg("Unsupported length: " << length);
    }
 
  // Result is returned in c
  final(a,b,c);
  return static_cast<uint16_t>(c);
}

hashword() [4/5]

uint32_t libMesh::Utility::hashword ( const uint32_t *  k, size_t  length, uint32_t  initval = 0  )

inline

The hashword function takes an array of uint32_t's of length 'length' and computes a single key from it.

Author

Bob Jenkins

Date

May 2006

Copyright

Public Domain http://burtleburtle.net/bob/hash/index.html

Definition at line 153 of file hashword.h.

{
  uint32_t a,b,c;
 
  // Set up the internal state
  a = b = c = 0xdeadbeef + ((static_cast<uint32_t>(length))<<2) + initval;
 
  //------------------------------------------------- handle most of the key
  while (length > 3)
    {
      a += k[0];
      b += k[1];
      c += k[2];
      mix(a,b,c);
      length -= 3;
      k += 3;
    }
 
  //------------------------------------------- handle the last 3 uint32_t's
  switch(length)                     // all the case statements fall through
    {
    case 3 : c+=k[2];
      libmesh_fallthrough();
    case 2 : b+=k[1];
      libmesh_fallthrough();
    case 1 : a+=k[0];
      final(a,b,c);
      libmesh_fallthrough();
    default:     // case 0: nothing left to add
      break;
    }
 
  //------------------------------------------------------ report the result
  return c;
}

Referenced by libMesh::Elem::compute_key(), libMesh::SparsityPattern::Build::handle_vi_vj(), hashword(), and libMesh::Elem::key().

hashword() [5/5]

uint64_t libMesh::Utility::hashword ( const uint64_t *  k, size_t  length  )

inline

Call the 64-bit FNV hash function.

Definition at line 249 of file hashword.h.

{
  return fnv_64_buf(k, 8*length);
}

hashword2() [1/3]

uint16_t libMesh::Utility::hashword2 ( const uint16_t  first, const uint16_t  second  )

inline

Definition at line 240 of file hashword.h.

{
  return static_cast<uint16_t>(first%65449 + (second<<5)%65449);
}

hashword2() [2/3]

uint32_t libMesh::Utility::hashword2 ( const uint32_t &  first, const uint32_t &  second, uint32_t  initval = 0  )

inline

This is a hard-coded version of hashword for hashing exactly 2 numbers.

Author

Bob Jenkins

Date

May 2006

Copyright

Public Domain http://burtleburtle.net/bob/hash/index.html

Definition at line 210 of file hashword.h.

{
  uint32_t a,b,c;
 
  // Set up the internal state
  a = b = c = 0xdeadbeef + 8 + initval;
 
  b+=second;
  a+=first;
  final(a,b,c);
 
  return c;
}

Referenced by libMesh::Elem::compute_key(), and libMesh::SparsityPattern::Build::handle_vi_vj().

hashword2() [3/3]

uint64_t libMesh::Utility::hashword2 ( const uint64_t  first, const uint64_t  second  )

inline

Call the 64-bit FNV hash function.

Definition at line 228 of file hashword.h.

{
  // This isn't optimal (it would be nice to avoid this packing step)
  // but we are going to go ahead and conform to the 32-bit
  // hashword2() interface.
  uint64_t k[2] = {first, second};
 
  // len is the total number of bytes in two 64-bit ints
  return fnv_64_buf(k, /*len=*/8*2);
}

iota()

template<typename ForwardIter , typename T >

void libMesh::Utility::iota	(	ForwardIter	first,
		ForwardIter	last,
		T	value
	)

Utility::iota is a duplication of the SGI STL extension std::iota.

It simply assigns sequentially increasing values to a range. That is, it assigns value to *first, value + 1 to *(first + 1) and so on. In general, each iterator i in the range [first, last) is assigned value + (i - first).

Definition at line 105 of file utility.h.

{
  // Use std::iota instead!
  libmesh_deprecated();
 
  while (first != last)
    {
      *first = value++;
      ++first;
    }
}

References value.

Referenced by libMesh::PetscVector< libMesh::Number >::create_subvector(), libMesh::DTKAdapter::DTKAdapter(), libMesh::DynaIO::ElementDefinition::ElementDefinition(), libMesh::PetscVector< libMesh::Number >::localize(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), libMesh::System::project_vector(), libMesh::System::projection_matrix(), DiagonalMatrixTest::testNumerics(), QuadratureTest::testTetQuadrature(), and QuadratureTest::testTriQuadrature().

is_sorted()

template<class InputIterator >

bool libMesh::Utility::is_sorted	(	InputIterator	first,
		InputIterator	last
	)

Utility::is_sorted mimics the behavior of the SGI STL extension std::is_sorted.

Checks to see if the range [first,last) is sorted in non-decreasing order, ie. for each "i" in [first,last) *i <= *(i+1).

Definition at line 125 of file utility.h.

{
  if (first == last)
    return true;
 
  // "prev" always points to the entry just to the left of "first"
  //  [-    -    -    -    -    -]
  //   ^    ^
  // prev first
  //
  //  [-    -    -    -    -    -]
  //        ^    ^
  //      prev first
  //
  //  [-    -    -    -    -    -]
  //             ^    ^
  //           prev first
  InputIterator prev( first );
  for (++first; first != last; ++prev, ++first)
    if (*first < *prev)    // Note: this is the same as *prev > *first,
      return false;        // but we only require op< to be defined.
 
  // If we haven't returned yet, it's sorted!
  return true;
 
 
  // A one-liner version using adjacent_find.  This doesn't work for
  // C-style arrays, since their pointers do not have a value_type.
  //
  // Works by checking to see if adjacent entries satisfy *i >
  // *(i+1) and returns the first one which does.  If "last" is
  // returned, no such pair was found, and therefore the range must
  // be in non-decreasing order.
  //
  // return (last ==
  // std::adjacent_find(first, last,
  // std::greater<typename InputIterator::value_type >()));
 
  // A second one-linear attempt.  This one checks for a **strictly
  // increasing** (no duplicate entries) range.  Also doesn't work
  // with C-style arrays.
  //
  // return (last ==
  // std::adjacent_find(first, last,
  // std::not2(std::less<typename InputIterator::value_type>())));
}

References libMesh::MeshTools::Subdivision::prev.

map_find() [1/2]

template<typename Map >

const Map::mapped_type& libMesh::Utility::map_find ( const Map &  map, const typename Map::key_type &  key, const char *  filename, int  line_number  )

inline

A version of the function above that works for const objects.

Definition at line 84 of file utility.h.

{
  auto it = map.find(key);
  if (it == map.end())
    libmesh_error_msg("map_find() error: key not found in file "        \
                      << filename << " on line " << line_number);
  return it->second;
}

map_find() [2/2]

template<typename Map >

Map::mapped_type& libMesh::Utility::map_find ( Map &  map, const typename Map::key_type &  key, const char *  filename, int  line_number  )

inline

This function should not be called directly (although it can be), instead see the libmesh_map_find() macro.

Calls find(key), and checks the result against end(). Returns the corresponding value if found, throws an error otherwise. Templated on the type of map, so this will work with both std::map and std::unordered_map.

Definition at line 66 of file utility.h.

{
  auto it = map.find(key);
  if (it == map.end())
    libmesh_error_msg("map_find() error: key not found in file "        \
                      << filename << " on line " << line_number);
  return it->second;
}

mkdir()

int libMesh::Utility::mkdir

(

const char *

pathname

)

Create a directory.

Definition at line 140 of file utility.C.

                                       {
#if defined(LIBMESH_HAVE_MKDIR)
  return ::mkdir(pathname, 0755);
#elif LIBMESH_HAVE_DECL__MKDIR
  return _mkdir(pathname);
#else
  libmesh_error_msg("Function mkdir not available on this system.");
#endif
 
}

Referenced by libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::write_out_vectors(), and libMesh::RBConstruction::write_riesz_representors_to_files().

pow()

template<int N, typename T >

T libMesh::Utility::pow ( const T &  x )

inline

Definition at line 246 of file utility.h.

{
  return do_pow<N,T>::apply(x);
}

References libMesh::Utility::do_pow< N, T >::apply().

Referenced by libMesh::FEHermite< Dim >::hermite_raw_shape_second_deriv(), libMesh::FESubdivision::regular_shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv().

prepare_complex_data()

void libMesh::Utility::prepare_complex_data	(	const std::vector< Complex > &	source,
		std::vector< Real > &	real_part,
		std::vector< Real > &	imag_part
	)

Prepare complex data for writing.

Definition at line 121 of file utility.C.

{
  const unsigned int len = source.size();
 
  real_part.resize(len);
  imag_part.resize(len);
 
  for (unsigned int i=0; i<len; i++)
    {
      real_part[i] = source[i].real();
      imag_part[i] = source[i].imag();
    }
}

print_timestamp()

void libMesh::Utility::print_timestamp ( std::ostream &  target = std::cout )

inline

Definition at line 37 of file timestamp.h.

{
  target << get_timestamp() << std::endl;
}

References get_timestamp().

string_to_enum()

template<typename T >

T libMesh::Utility::string_to_enum

(

const std::string &

s

)

Returns

the enumeration of type T which matches the string s.

system_info()

std::string libMesh::Utility::system_info

(

)

Returns

A string containing information about the system you are running on.

Definition at line 57 of file utility.C.

{
  std::ostringstream oss;
 
  std::string date = Utility::get_timestamp();
 
#ifdef LIBMESH_HAVE_SYS_UTSNAME_H
  // Get system information
  struct utsname sysInfo;
  uname(&sysInfo);
#endif
 
  // Get user information
#ifdef LIBMESH_HAVE_GETPWUID
  struct passwd * p = getpwuid(getuid());
#endif
 
 
  oss << '\n'
      << " ---------------------------------------------------------------------\n"
      << "| Time:           " << date             << '\n'
#ifdef LIBMESH_HAVE_SYS_UTSNAME_H
      << "| OS:             " << sysInfo.sysname  << '\n'
      << "| HostName:       " << sysInfo.nodename << '\n'
      << "| OS Release      " << sysInfo.release  << '\n'
      << "| OS Version:     " << sysInfo.version  << '\n'
      << "| Machine:        " << sysInfo.machine  << '\n'
#else
      << "| OS:             " << "Unknown"        << '\n'
      << "| HostName:       " << "Unknown"        << '\n'
      << "| OS Release      " << "Unknown"        << '\n'
      << "| OS Version:     " << "Unknown"        << '\n'
      << "| Machine:        " << "Unknown"        << '\n'
#endif
#ifdef LIBMESH_HAVE_GETPWUID
      << "| Username:       " << p->pw_name       << '\n'
#else
      << "| Username:       " << "Unknown"        << '\n'
#endif
      << " ---------------------------------------------------------------------\n";
 
  return oss.str();
}

References get_timestamp().