std::this_thread::sleep_for

Defined in header <thread> template< class Rep, class Period > void sleep_for( const std::chrono::duration<Rep, Period>& sleep_duration ); (since C++11) Blocks the execution of the current thread for at least the specified sleep_duration. A steady clock is used to measure the duration. This function may block for longer than sleep_duration due to scheduling or resource contention delays. Parameters sleep_duration - time duration to sleep Return

std::this_thread::get_id

Defined in header <thread> std::thread::id get_id(); (since C++11) Returns the id of the current thread. Parameters (none). Return value id of the current thread. Example #include <iostream> #include <thread> #include <chrono> #include <mutex> std::mutex g_display_mutex; void foo() { std::thread::id this_id = std::this_thread::get_id(); g_display_mutex.lock(); std::cout << "thread " << this_id << " sleep

std::tgamma

Defined in header <cmath> float tgamma( float arg ); (1) (since C++11) double tgamma( double arg ); (2) (since C++11) long double tgamma( long double arg ); (3) (since C++11) double tgamma( Integral arg ); (4) (since C++11) 1-3) Computes the gamma function of arg. 4) A set of overloads or a function template accepting an argument of any integral type. Equivalent to 2) (the argument is cast to double). Parameters arg - value of a f

std::terminate_handler

Defined in header <exception> typedef void (*terminate_handler)(); std::terminate_handler is the function pointer type (pointer to function that takes no arguments and returns void), which is installed and queried by the functions std::set_terminate and std::get_terminate and called by std::terminate. The C++ implementation provides a default std::terminate_handler function, which calls std::abort(). If the null pointer value is installed (by means of std::set_terminate), t

std::terminate

Defined in header <exception> void terminate(); (until C++11) [[noreturn]] void terminate(); (since C++11) std::terminate() is called by the C++ runtime when exception handling fails for any of the following reasons: 1) an exception is thrown and not caught (it is implementation-defined whether any stack unwinding is done in this case) 2) an exception is thrown during exception handling (e.g. from a destructor of some local object, or from a function that had to be

std::tanh(std::valarray)

Defined in header <valarray> template< class T > valarray<T> tanh( const valarray<T>& va ); For each element in va computes hyperbolic tangent of the value of the element. Parameters va - value array to apply the operation to Return value Value array containing hyperbolic tangent of the values in va. Notes Unqualified function (tanh) is used to perform the computation. If such function is not available, std::tanh is used due to argumen

std::tanh(std::complex)

Defined in header <complex> template< class T > complex<T> tanh( const complex<T>& z ); (since C++11) Computes complex hyperbolic tangent of a complex value z. Parameters z - complex value Return value If no errors occur, complex hyperbolic tangent of z is returned. Error handling and special values Errors are reported consistent with math_errhandling. If the implementation supports IEEE floating-point arithmetic, std::tanh(std::conj

std::tanh

Defined in header <cmath> float tanh( float arg ); (1) double tanh( double arg ); (2) long double tanh( long double arg ); (3) double tanh( Integral arg ); (4) (since C++11) Computes the hyperbolic tangent of arg. 4) A set of overloads or a function template accepting an argument of any integral type. Equivalent to 2) (the argument is cast to double). Parameters arg - value of a floating-point or Integral type Return value I

std::tan(std::valarray)

Defined in header <valarray> template< class T > valarray<T> tan( const valarray<T>& va ); For each element in va computes tangent of the value of the element. Parameters va - value array to apply the operation to Return value Value array containing tangents of the values in va. Notes Unqualified function (tan) is used to perform the computation. If such function is not available, std::tan is used due to argument dependent lookup. The

std::tan(std::complex)

Defined in header <complex> template< class T > complex<T> tan( const complex<T>& z ); Computes complex tangent of a complex value z. Parameters z - complex value Return value If no errors occur, the complex tangent of z is returned. Errors and special cases are handled as if the operation is implemented by -i * std::tanh(i*z), where i is the imaginary unit. Notes Tangent is an analytical function on the complex plain and has no branc