\brief Implementation of the nvinfer1::ILogger::log() virtual method Note samples should not be calling this function directly; it will eventually go

Natural logorithm. \param arg function argument \return logarithm of \a arg to base e template<typename T> typename enable<expr,T>::type log(T arg) {

Absolute value. \param arg operand \return absolute value of \a arg template<typename T> typename enable<T,T>::type fabs(T arg) { return unary_special

Exponential function. \param arg function argument \return e raised to \a arg template<typename T> typename enable<expr,T>::type exp(T arg) { return f

Check for NaN. \param arg number to check \retval true for NaNs \retval false else template<typename T> typename enable<bool,T>::type isnan(T arg) { r

Tool function. set precision, set_layer_name and check_trt_layer

Multiply by power of two. \param arg number to modify \param exp power of two to multiply with \return \a arg multplied by 2 raised to \a exp template

\brief Method for controlling the verbosity of logging output \param severity The logger will only emit messages that have severity of this level or

Natural logarithm of gamma function. \param arg function argument \return natural logarith of gamma function for \a arg template<typename T> typename

Square root. \param arg function argument \return square root of \a arg template<typename T> typename enable<expr,T>::type sqrt(T arg) { return functi

Absolute value. \param arg operand \return absolute value of \a arg template<typename T> typename enable<T,T>::type abs(T arg) { return unary_speciali

Remainder of division. \param x first operand \param y second operand \return remainder of floating point division. template<typename T,typename U> ty

Multiply by power of two. \param arg number to modify \param exp power of two to multiply with \return \a arg multplied by 2 raised to \a exp template

Error function. \param arg function argument \return error function value of \a arg template<typename T> typename enable<expr,T>::type erf(T arg) { re

Extract integer and fractional parts. \param arg number to decompress \param iptr address to store integer part at \return fractional part template<ty

Power function. \param base first argument \param exp second argument \return \a base raised to \a exp template<typename T,typename U> typename enable

Sine function. \param arg function argument \return sine value of \a arg template<typename T> typename enable<expr,T>::type sin(T arg) { return functi

Square root implementation. \param arg function argument \return function value stored in single-preicision

Debug************************************/

Nearest integer using half's internal rounding mode. \param arg half expression to round \return nearest integer using default rounding mode template<

\brief Construct a DimsCHW given channel count, height and width. \param channels The channel count. \param height The height of the data. \param wid

\brief Construct a DimsNCHW given batch size, channel count, height and width. \param batchSize The batch size (commonly denoted N). \param channels

\brief produces a LogStreamConsumer object that can be used to log messages of severity kERROR Example usage: LOG_ERROR(logger) << "hello world" <<

\brief produces a LogStreamConsumer object that can be used to log messages of severity kINTERNAL_ERROR ("fatal" severity) Example usage: LOG_FATAL(

\brief produces a LogStreamConsumer object that can be used to log messages of severity kINFO Example usage: LOG_INFO(logger) << "hello world" << st

\brief produces a LogStreamConsumer object that can be used to log messages of severity kVERBOSE Example usage: LOG_VERBOSE(logger) << "hello world"

\brief produces a LogStreamConsumer object that can be used to log messages of severity kWARNING Example usage: LOG_WARN(logger) << "hello world" <<

Arc cosine function. \param arg function argument \return arc cosine value of \a arg template<typename T> typename enable<expr,T>::type acos(T arg) {

Hyperbolic area cosine. \param arg function argument \return area cosine value of \a arg template<typename T> typename enable<expr,T>::type acosh(T ar

scale

Arc sine. \param arg function argument \return arc sine value of \a arg template<typename T> typename enable<expr,T>::type asin(T arg) { return functi

Hyperbolic area sine. \param arg function argument \return area sine value of \a arg template<typename T> typename enable<expr,T>::type asinh(T arg) {

Arc tangent function. \param arg function argument \return arc tangent value of \a arg template<typename T> typename enable<expr,T>::type atan(T arg)

Arc tangent function. \param x first argument \param y second argument \return arc tangent value template<typename T,typename U> typename enable<expr,

Hyperbolic area tangent. \param arg function argument \return area tangent value of \a arg template<typename T> typename enable<expr,T>::type atanh(T

Create the bert model

Cubic root. \param arg function argument \return cubic root of \a arg template<typename T> typename enable<expr,T>::type cbrt(T arg) { return function

Tool function. check trt layer,

Cosine function. \param arg function argument \return cosine value of \a arg template<typename T> typename enable<expr,T>::type cos(T arg) { return fu

Hyperbolic cosine. \param arg function argument \return hyperbolic cosine value of \a arg template<typename T> typename enable<expr,T>::type cosh(T ar

Complementary error function. \param arg function argument \return 1 minus error function value of \a arg template<typename T> typename enable<expr,T>

Binary exponential. \param arg function argument \return 2 raised to \a arg template<typename T> typename enable<expr,T>::type exp2(T arg) { return fu

Exponential minus one. \param arg function argument \return e raised to \a arg subtracted by 1 template<typename T> typename enable<expr,T>::type expm

Positive difference. \param x first operand \param y second operand \return \a x - \a y or 0 if difference negative template<typename T,typename U> ty

Fused multiply add. \param x first operand \param y second operand \param z third operand \return ( \a x * \a y ) + \a z rounded as one operation. tem

Maximum of half expressions. \param x first operand \param y second operand \return maximum of operands template<typename T,typename U> typename resul

Minimum of half expressions. \param x first operand \param y second operand \return minimum of operands template<typename T,typename U> typename resul

Decompress floating point number. \param arg number to decompress \param exp address to store exponent at \return significant in range [0.5, 1) templa

Convert half-precision to IEEE single-precision. Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.p

Hypotenuse function. \param x first argument \param y second argument \return square root of sum of squares without internal over- or underflows templ

Comparison for greater than. \param x first operand \param y second operand \retval true if \a x greater than \a y \retval false else template<typenam

Comparison for greater equal. \param x first operand \param y second operand \retval true if \a x greater equal \a y \retval false else template<typen

Check for infinity. \param arg number to check \retval true for positive or negative infinity \retval false else template<typename T> typename enable<

Comparison for less than. \param x first operand \param y second operand \retval true if \a x less than \a y \retval false else template<typename T,ty

Comparison for less equal. \param x first operand \param y second operand \retval true if \a x less equal \a y \retval false else template<typename T,

Load the weights from the onnx checkpoint

Common logorithm. \param arg function argument \return logarithm of \a arg to base 10 template<typename T> typename enable<expr,T>::type log10(T arg)

Natural logorithm. \param arg function argument \return logarithm of \a arg plus 1 to base e template<typename T> typename enable<expr,T>::type log1p(

Binary logorithm. \param arg function argument \return logarithm of \a arg to base 2 template<typename T> typename enable<expr,T>::type log2(T arg) {