Reference documentation for deal.II version Git d132f0c 20170323 19:35:29 0400

Namespaces  
MPI  
System  
Trilinos  
Classes  
struct  fixed_int_power 
struct  fixed_int_power< a, 0 > 
Functions  
std::string  int_to_string (const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int) 
template<typename number >  
std::string  to_string (const number value, const unsigned int digits=numbers::invalid_unsigned_int) 
unsigned int  needed_digits (const unsigned int max_number) 
int  string_to_int (const std::string &s) 
std::string  dim_string (const int dim, const int spacedim) 
std::vector< int >  string_to_int (const std::vector< std::string > &s) 
double  string_to_double (const std::string &s) 
std::vector< double >  string_to_double (const std::vector< std::string > &s) 
std::vector< std::string >  split_string_list (const std::string &s, const char delimiter= ',') 
std::vector< std::string >  break_text_into_lines (const std::string &original_text, const unsigned int width, const char delimiter= ' ') 
bool  match_at_string_start (const std::string &name, const std::string &pattern) 
std::pair< int, unsigned int >  get_integer_at_position (const std::string &name, const unsigned int position) 
std::string  replace_in_string (const std::string &input, const std::string &from, const std::string &to) 
std::string  trim (const std::string &input) 
double  generate_normal_random_number (const double a, const double sigma) 
template<int N, typename T >  
T  fixed_power (const T t) 
template<typename Iterator , typename T >  
Iterator  lower_bound (Iterator first, Iterator last, const T &val) 
template<typename Iterator , typename T , typename Comp >  
Iterator  lower_bound (Iterator first, Iterator last, const T &val, const Comp comp) 
std::vector< unsigned int >  reverse_permutation (const std::vector< unsigned int > &permutation) 
std::vector< unsigned int >  invert_permutation (const std::vector< unsigned int > &permutation) 
std::vector< unsigned long long int >  reverse_permutation (const std::vector< unsigned long long int > &permutation) 
std::vector< unsigned long long int >  invert_permutation (const std::vector< unsigned long long int > &permutation) 
static::ExceptionBase &  ExcInvalidNumber2StringConversersion (unsigned int arg1, unsigned int arg2) 
static::ExceptionBase &  ExcInvalidNumber (unsigned int arg1) 
static::ExceptionBase &  ExcCantConvertString (std::string arg1) 
A namespace for utility functions that are not particularly specific to finite element computing or numerical programs, but nevertheless are needed in various contexts when writing applications.
std::string Utilities::int_to_string  (  const unsigned int  value, 
const unsigned int  digits = numbers::invalid_unsigned_int 

) 
Convert a number value
to a string, with as many digits as given to fill with leading zeros.
If the second parameter is left at its default value, the number is not padded with leading zeros. The result is then the same as if the standard C function itoa()
had been called.
When calling this function signed integers are implicitly converted to unsigned integers and long integers might experience an overflow.
Utilities::to_string()
instead. In its current implementation the function simply calls to_string<unsigned int>()
. Definition at line 85 of file utilities.cc.
std::string Utilities::to_string  (  const number  value, 
const unsigned int  digits = numbers::invalid_unsigned_int 

) 
Convert a number value
to a string, with digits
characters. The string is padded with leading zeros, after a possible minus sign. Therefore the total number of padding zeros is digits
minus any signs, decimal points and digits of value
.
If the second parameter is left at its default value, the number is not padded with leading zeros. The result is then the same as if the boost function lexical_cast<std::string>()
had been called.
Definition at line 92 of file utilities.cc.
unsigned int Utilities::needed_digits  (  const unsigned int  max_number  ) 
Determine how many digits are needed to represent numbers at most as large as the given number.
Definition at line 171 of file utilities.cc.
int Utilities::string_to_int  (  const std::string &  s  ) 
Given a string, convert it to an integer. Throw an assertion if that is not possible.
Definition at line 192 of file utilities.cc.
std::string Utilities::dim_string  (  const int  dim, 
const int  spacedim  
) 
Return a string describing the dimensions of the object. Often, functions in the deal.II library as well as in user codes need to define a string containing the template dimensions of some objects defined using two template parameters: dim (the topological dimension of the object) and spacedim (the dimension of the embedding Euclidean space). Since in all deal.II classes, by default spacedim is equal to dimension, the above string is usually contracted to "<dim>", instead of "<dim,spacedim>". This function returns a string containing "dim" if dim is equal to spacedim, otherwise it returns "dim,spacedim".
Definition at line 161 of file utilities.cc.
std::vector< int > Utilities::string_to_int  (  const std::vector< std::string > &  s  ) 
Given a list of strings, convert it to a list of integers. Throw an assertion if that is not possible.
Definition at line 219 of file utilities.cc.
double Utilities::string_to_double  (  const std::string &  s  ) 
Given a string, convert it to an double. Throw an assertion if that is not possible.
Definition at line 230 of file utilities.cc.
std::vector< double > Utilities::string_to_double  (  const std::vector< std::string > &  s  ) 
Given a list of strings, convert it to a list of doubles. Throw an assertion if that is not possible.
Definition at line 257 of file utilities.cc.
std::vector< std::string > Utilities::split_string_list  (  const std::string &  s, 
const char  delimiter = ',' 

) 
Given a string that contains text separated by a delimiter
, split it into its components; for each component, remove leading and trailing spaces. The default value of the delimiter is a comma, so that the function splits comma separated lists of strings.
To make data input from tables simpler, if the input string ends in a delimiter (possibly followed by an arbitrary amount of whitespace), then this last delimiter is ignored. For example,
yields the same 3element list of output {"abc","def","ghi"}
as you would get if the input had been
or
As a consequence of this rule, a call like
yields a oneelement list. Because of the trimming of whitespace, the single element is the empty string.
This function can digest the case that the delimiter is a space. In this case, it returns all words in the string. Combined with the rules above, this implies that
yields again the 3element list of output {"abc","def","ghi"}
from above despite the presence of space at the end of the string. Furthermore,
yields an empty list regardless of the number of spaces in the string.
Definition at line 268 of file utilities.cc.
std::vector< std::string > Utilities::break_text_into_lines  (  const std::string &  original_text, 
const unsigned int  width,  
const char  delimiter = ' ' 

) 
Take a text, usually a documentation or something, and try to break it into individual lines of text at most width
characters wide, by breaking at positions marked by delimiter
in the text. If this is not possible, return the shortest lines that are longer than width
. The default value of the delimiter is a space character. If original_text contains newline characters (
), the string is split at these locations, too.
Definition at line 316 of file utilities.cc.
bool Utilities::match_at_string_start  (  const std::string &  name, 
const std::string &  pattern  
) 
Return true if the given pattern string appears in the first position of the string.
Definition at line 393 of file utilities.cc.
std::pair< int, unsigned int > Utilities::get_integer_at_position  (  const std::string &  name, 
const unsigned int  position  
) 
Read a (signed) integer starting at the position in name
indicated by the second argument, and return this integer as a pair together with how many characters it takes up in the string.
If no integer can be read at the indicated position, return (1,numbers::invalid_unsigned_int)
Definition at line 409 of file utilities.cc.
std::string Utilities::replace_in_string  (  const std::string &  input, 
const std::string &  from,  
const std::string &  to  
) 
Return a string with all occurrences of from
in input
replaced by to
.
Definition at line 115 of file utilities.cc.
std::string Utilities::trim  (  const std::string &  input  ) 
Return a string with all standard whitespace characters (including '\t
', '\n
', and '\r
') at the beginning and end of input
removed.
Definition at line 134 of file utilities.cc.
double Utilities::generate_normal_random_number  (  const double  a, 
const double  sigma  
) 
Generate a random number from a normalized Gaussian probability distribution centered around a
and with standard deviation sigma
.
This function is reentrant, i.e., it can safely be called from multiple threads at the same time. In addition, each thread will get the same sequence of numbers every time. On the other hand, if you run Threads::Task objects via the Threading Building Blocks, then tasks will be assigned to mostly random threads, and may get a different sequence of random numbers in different runs of the program, since a previous task may already have consumed the first few random numbers generated for the thread you're on. If this is a problem, you need to create your own random number generator objects every time you want to start from a defined point.
Definition at line 453 of file utilities.cc.

inline 
Calculate a fixed power, provided as a template argument, of a number.
This function provides an efficient way to calculate things like t^N
where N
is a known number at compile time.
Use this function as in fixed_power<dim> (n)
.
Definition at line 592 of file utilities.h.

inline 
Optimized replacement for std::lower_bound
for searching within the range of column indices. Slashes execution time by approximately one half for the present application, partly because because the binary search is replaced by a linear search for small loop lengths.
Another reason for this function is rather obscure: when using the GCC libstdc++ function std::lower_bound, complexity is O(log(N)) as required. However, when using the debug version of the GCC libstdc++ as we do when running the testsuite, then std::lower_bound tests whether the sequence is in fact partitioned with respect to the pivot 'value' (i.e. in essence that the sequence is sorted as required for binary search to work). However, verifying this means that the complexity of std::lower_bound jumps to O(N); we call this function O(N) times below, making the overall complexity O(N**2). The consequence is that a few tests with big meshes completely run off the wall time limit for tests and fail with the libstdc++ debug mode
This function simply makes the assumption that the sequence is sorted, and we simply don't do the additional check.
Definition at line 618 of file utilities.h.

inline 
The same function as above, but taking an argument that is used to compare individual elements of the sequence of objects pointed to by the iterators.
Definition at line 631 of file utilities.h.
std::vector< unsigned int > Utilities::reverse_permutation  (  const std::vector< unsigned int > &  permutation  ) 
Given a permutation vector (i.e. a vector \(p_0\ldots p_{N1}\) where each \(p_i\in [0,N)\) and \(p_i\neq p_j\) for \(i\neq j\)), produce the reverse permutation \(q_i=N1p_i\).
Definition at line 472 of file utilities.cc.
std::vector< unsigned int > Utilities::invert_permutation  (  const std::vector< unsigned int > &  permutation  ) 
Given a permutation vector (i.e. a vector \(p_0\ldots p_{N1}\) where each \(p_i\in [0,N)\) and \(p_i\neq p_j\) for \(i\neq j\)), produce the inverse permutation \(q_0\ldots q_{N1}\) so that \(q_{p_i}=p_{q_i}=i\).
Definition at line 486 of file utilities.cc.
std::vector< unsigned long long int > Utilities::reverse_permutation  (  const std::vector< unsigned long long int > &  permutation  ) 
Given a permutation vector (i.e. a vector \(p_0\ldots p_{N1}\) where each \(p_i\in [0,N)\) and \(p_i\neq p_j\) for \(i\neq j\)), produce the reverse permutation \(q_i=N1p_i\).
Definition at line 508 of file utilities.cc.
std::vector< unsigned long long int > Utilities::invert_permutation  (  const std::vector< unsigned long long int > &  permutation  ) 
Given a permutation vector (i.e. a vector \(p_0\ldots p_{N1}\) where each \(p_i\in [0,N)\) and \(p_i\neq p_j\) for \(i\neq j\)), produce the inverse permutation \(q_0\ldots q_{N1}\) so that \(q_{p_i}=p_{q_i}=i\).
Definition at line 522 of file utilities.cc.