/**
 * Calculates the minimum of a and b.
 *
 * @param a a numeric value.
 * @param b a numeric value.
 * @return the minimum of a and b.
 */
c::MIN

/**
 * Calculates the maximum of a and b.
 * 
 * @param a a numeric value.
 * @param b a numeric value.
 * @return the maximum of a and b.
 */
c::MAX

/**
 * Calculates the absolute value of a.
 *
 * The absolute value is simply the number with any negative sign taken away.
 *
 * For example:
 *
 * {{{
 *  ABS(-10) is 10.
 *  ABS(10) is also 10.
 * }}}
 *
 * @param a a numeric value.
 * @return the absolute value of a.
 */
c::ABS

/**
 * Ensures that x is between the limits set by low and high. If low is greater than high the result is undefined.
 * 
 * For example:
 *
 * {{{
 *  CLAMP(5, 10, 15) is 10.
 *  CLAMP(15, 5, 10) is 10.
 *  CLAMP(20, 15, 25) is 20.
 * }}}
 *
 * @param low the minimum value allowed
 * @param high the maximum value allowed
 * @return the value of x clamped to the range between low and high
 */
c::CLAMP




/**
 * Calculates the arc tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 */
GLib.Math.atan

/**
 * Calculates the arc tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose tangent is x.
 */
GLib.Math.atanf

/**
 * Returns the inverse hyperbolic tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If the absolute  value of ``x`` is greater than 1.0, {@link GLib.Math.atanh} returns
 * not-a-number ({@link double.NAN}) and {@link GLib.errno} is set {@link c::EDOM}.
 * 
 * @param x A numeric value which is between -1.0 and 1.0.
 */
GLib.Math.atanh

/**
 * Returns the result of multiplying the floating-point number ``x`` by 2 raised to the power ``exponent``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param exponent An integer value for the exponent.
 */
GLib.Math.ldexp

/**
 * Returns the natural logarithm of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.logf

/**
 * Returns the base 10 logarithm of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.log10f

/**
 * Breaks the argument ``x`` into an integral part and a fractional part.
 * each of which has the same sign as ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param iptr The output variable for the integral part.
 */
GLib.Math.modff

/**
 * Returns the value of 10 raised to the power of ``x``.
 * 
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.exp10

/**
 * Extracts the exponent of ``x`` and returns it as a floating-point value.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is de-normalized, {@link GLib.Math.logb} returns the exponent
 * ``x`` as if it had been normalized.
 * 
 * @param x A numeric value.
 */
GLib.Math.logb

/**
 * Extracts the exponent of x and returns it as a floating-point value.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.logbf} function extracts the exponent of x and returns it as a floating-point value.
 * 
 * If x is de-normalized, {@link GLib.Math.logb} returns the exponent x as if it had been normalized.
 * 
 * @param x A numeric value.
 */
GLib.Math.logbf

/**
 * Returns the value of 2 raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.exp2f

/**
 * Computes the remainder of dividing ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The return  value is ``x - n * y``, where n is the quotient of ``x / y``,
 * rounded towards zero to an integer.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fmod

/**
 * Returns the value of infinity checking.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * Returns 1 if ``value`` is positive infinity, and -1 if ``value`` is negative infinity.
 * Otherwise {@link double.is_infinity} returns 0.
 * 
 * @param value A numeric value.
 */
GLib.Math.isinff

/**
 * Returns the value of not-a-number (NaN) checking.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * Returns a non-zero value if ``value`` is neither infinite nor a not-a-number (NaN) value, and 0 otherwise.
 * 
 * @param value A numeric value.
 */
GLib.Math.finite

/**
 * Computes the remainder of dividing x by y.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The return value is ``x - n * y``, where n is the value ``x / y``, rounded to the nearest integer.
 * If this quotient is ``1/2 (mod 1)``, it is rounded to the nearest even number  (independent of the
 * current rounding mode).
 * 
 * If the return value is 0, it has the sign of ``x``.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.drem

/**
 * Returns a non-zero value if ``value`` is not-a-number ({@link float.NAN}).
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param value A numeric value.
 */
GLib.Math.isnanf

/**
 * Returns Bessel function of ``x0`` of the first kind of order 1.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.j1f

/**
 * Returns Bessel function of x0 of the second kind of order 0.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.y0f

/**
 * Returns the natural logarithm of the absolute value of the Gamma function.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The sign of the Gamma function is returned in the external integer Posix.signgam. It is 1 when
 * the Gamma function is positive or zero, -1 when it is negative.
 * 
 * Since using a constant location GLib.signgam is not thread-safe, the functions {@link GLib.Math.lgamma_r}
 * etc. have been introduced; they return this sign via an output argument.
 * 
 * For non-positeve integer values of ``x0``, {@link GLib.Math.lgamma} returns {@link c::HUGE_VAL}, sets
 * {@link GLib.errno} to {@link Posix.ERANGE} and raises the zero divide exception.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.lgamma

/**
 * Returns the natural logarithm of the absolute value of the Gamma function.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The sign of the Gamma function is returned in the external integer Posix.signgam. It is 1 when
 * the Gamma function is positive or zero, -1 when it is negative.
 * 
 * Since using a constant location GLib.signgam is not thread-safe, the functions {@link GLib.Math.lgamma_r}
 * etc. have been introduced; they return this sign via an output argument.
 * 
 * For non-positeve integer values of ``x0``, {@link GLib.Math.lgamma} returns {@link c::HUGE_VAL}, sets
 * {@link GLib.errno} to {@link Posix.ERANGE} and raises the zero divide exception.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.lgammaf

/**
 * Computes the remainder of dividing ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The return value is ``x - n * y``, where n is the value ``x / y``, rounded to the
 * nearest integer.
 * 
 * If this quotient is ``1/2 (mod 1)``, it is rounded to the nearest even number (independent
 * of the current rounding mode). If the return value is 0, it has the sign of ``x``.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.remainder

/**
 * Computes the remainder of dividing ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The return value is ``x - n * y``, where n is the value ``x / y``, rounded to
 * the nearest integer.
 * 
 * If this quotient is ``1/2 (mod 1)``, it is rounded to the nearest even number
 * (independent of the current rounding mode). If the return value is 0, it has the
 * sign of ``x``.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.remainderf

/**
 * Rounds argument ``x`` to the nearest integer not larger in absolute value.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.trunc} function rounds argument ``x`` to the nearest integer
 * not larger in absolute value.
 * 
 * @param x A numeric value.
 */
GLib.Math.trunc

/**
 * Rounds argument ``x`` to the nearest integer not larger in absolute value.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.truncf

/**
 * Computes the remainder and part of the quotient upon division of ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.remquof} function computes the remainder and part of the
 * quotient upon division  of ``x`` by ``y``. A few bits of the quotient are stored
 * via the quo output variable. The remainder  is returned as function value.
 * 
 * The value of the remainder is the same as that computed by the {@link GLib.Math.remainder} function.
 * 
 * The value stored via the quo output variable has the sign of ``x / y`` and agrees with the  quotient
 * in at least the low order 3 bits.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 * @param quo An output variable for the quotient.
 */
GLib.Math.remquof

/**
 * Rounds it's argument to the nearest integer value, using the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link float.NAN}, or if the rounded value is outside the range
 * of the return type, the numeric result is unspecified. A domain error may occur if the
 * magnitude of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.llrintf

/**
 * Returns the larger value of ``x`` and ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fmax

/**
 * Returns the smaller value of ``x`` and ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fminf

/**
 * Computes ``x * y + z``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The result is rounded according to the rounding  mode determined by the value of {@link c::FLT_ROUNDS}.
 * 
 * {@link c::FLT_ROUNDS} indicates the implementation-defined rounding behavior for floating-point addition,
 * and has one of the following values:
 * 
 *  * -1 The rounding mode is not determinable.
 *  * 0 Rounding is towards 0.
 *  * 1 Rounding is towards nearest number.
 *  * 2 Rounding istowards positive infinity.
 *  * 3 Rounding is towards negative infinity.
 *  * Other values represent machine-dependent, non-standard rounding modes.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 * @param z A numeric value.
 */
GLib.Math.fmaf

/**
 * Computes the remainder of dividing ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The return value is ``x - n * y``, where n is the value ``x / y``, rounded to the nearest integer.
 * If this quotient is ``1/2 (mod 1)``, it is rounded to the nearest even number  (independent of
 * the current rounding mode).
 * 
 * If the return value is 0, it has the sign of ``x``.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.dremf

/**
 * Returns the mantissa of ``x`` scaled to the range ``[1,2]``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * This function exists mainly for use in certain standardized tests for IEEE 754 conformance.
 * 
 * @param x A numeric value.
 */
GLib.Math.significandf

/**
 * Returns Bessel function of ``x0`` of the first kind of order 0.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.j0

/**
 * Returns Bessel function of ``x1`` of the second kind of order ``x0``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.yn} function returns Bessel function of ``x1`` of
 * the second kind of order ``x0``.
 * 
 * @param x0 Determines the Bessel function order.
 * @param x1 A numeric value.
 */
GLib.Math.yn

/**
 * Returns the complementary error function of ``x0``, that is ``1.0 - erf(x0)``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.erfc

/**
 * Returns the value of Gamma function for the argument ``x0``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The Gamma function is defined by ``Gamma(x) = integral from 0 to infinity of t^(x-1) e^-t dt``.
 * 
 * It is defined for every real number except for non-positive integers.
 * For non-negative integral m one has ``Gamma(m+1) = m!`` and, more generally, for all
 * ``x: Gamma(x+1) = x * Gamma(x)``
 * 
 * Furthermore, the following is valid for all values of ``x`` outside the poles: ``Gamma(x) * Gamma(1 - x) = PI / sin(PI * x)``
 * 
 * This function return the value of Gamma function for the argument ``x``. It had to be called "true gamma function" since there
 * is already a function gamma that returns something else.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.tgammaf

/**
 * Returns the natural logarithm of the absolute value of the Gamma function.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The sign of the Gamma function is returned in the second parameter.
 * 
 * It is 1 when the Gamma function is positive or zero, -1 when it is negative.
 * 
 * @param x0 A numeric value.
 * @param signgamp {@link GLib.Math.lgamma_r} sets signgamp to 1 when the Gamma function is positive or zero, -1 when it is negative.
 */
GLib.Math.lgamma_r

/**
 * Rounds it's argument to an integer value in floating point format.
 * using the current rounding direction and with raising the inexact exception.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.rintf

/**
 * Multiplies it's first argument ``x`` by 2 to the power ``n``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {@link GLib.Math.scalbn} is equivalent to {@link GLib.Math.ldexp}.
 * 
 * @param x A numeric value.
 * @param n A numeric value.
 */
GLib.Math.scalbnf

/**
 * Returns the exponent part of their argument as a signed integer.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * When no error occurs, the function is equivalent to the corresponding logb function, cast to int.
 * 
 * An error will occur for zero and infinity and NaN, and possibly for overflow.
 * 
 * @param x A numeric value.
 */
GLib.Math.ilogb

/**
 * Returns the exponent part of their argument as a signed integer.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * When no error occurs, the function is equivalent to the corresponding logb function, cast to int.
 * 
 * An error will occur for zero and infinity and NaN, and possibly for overflow.
 * 
 * @param x A numeric value.
 */
GLib.Math.ilogbf

/**
 * This function is equivalent to {@link GLib.Math.ldexp}.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param n A numeric value.
 */
GLib.Math.scalbln

/**
 * Rounds argument ``x`` to the nearest integer, but round halfway cases away from zero
 * (regardless of the current rounding direction), instead of to the nearest even integer like rint.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.roundf

/**
 * Rounds it's argument to the nearest integer value, rounding away from zero,
 * regardless of the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link double.NAN}, or if the rounded value is outside the range
 * of the return type, the numeric result is unspecified.
 * 
 * A domain error may occur if the magnitude of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.llround

/**
 * Rounds it's argument to the nearest integer value, rounding away from zero, regardless of the
 * current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link float.NAN}, or if the rounded value is outside the range of the
 * return type, the numeric result is unspecified.
 * 
 * A domain error may occur if the magnitude of x is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.llroundf

/**
 * Returns ``max(x - y, 0)``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` or ``y`` or both are {@link double.NAN}, {@link double.NAN} is returned.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fdim

/**
 * Multiplies ``x`` by 2 to the power ``n``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.scalbf} function multiplies ``x`` by 2 to the power ``n``.
 * 
 * @param x A numeric value.
 * @param n A numeric value.
 */
GLib.Math.scalbf

/**
 * Returns the tangent of ``x``, where ``x`` is given in radians.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 */
GLib.Math.tan

/**
 * Returns the hyperbolic tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {{{
 *  tanh(x) = sinh(x) / cosh(x)
 * }}}
 */
GLib.Math.tanhf

/**
 * Returns the inverse hyperbolic sine of ``x``, that is the value whose hyperbolic sine is ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.asinhf

/**
 * Returns the value of the base of natural logarithms raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value
 */
GLib.Math.exp

/**
 * Returns the base 10 logarithm of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.log10

/**
 * Returns a value equivalent to ``log(1 + x)``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It is computed in a way that is accurate even if the value of ``x`` is near zero.
 * 
 * @param x A numeric value.
 */
GLib.Math.log1pf

/**
 * Returns the value of 2 raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.exp2

/**
 * Returns the base 2 logarithm of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.log2

/**
 * Returns the base 2 logarithm of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.log2f

/**
 * Returns the value of ``x`` raised to the power of ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.pow

/**
 * Returns the length of the hypotenuse of a right-angle triangle.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.hypotf} function returns ``sqrt(x*x + y*y)``. This is the length of the hypotenuse
 * of a right-angle triangle with sides of length ``x`` and ``y``, or the distance of the point ``(x,y)``
 * from the origin.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.hypotf

/**
 * Returns the (real) cube root of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * This function cannot fail; every representable real value has a representable real cube root.
 * 
 * @param x A numeric value.
 */
GLib.Math.cbrtf

/**
 * Returns the absolute value.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.fabsf} function returns the absolute value of the floating-point number ``x``.
 * 
 * @param x A numeric value.
 */
GLib.Math.fabsf

/**
 * Rounds ``x`` down to the nearest integer.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.floorf

/**
 * The value of pi (ratio of circle's circumference to its diameter).
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 */
GLib.Math.PI

/**
 * Calculates the arc cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose cosine is ``x``. If ``x`` falls outside the range -1 to 1,
 * {@link GLib.Math.acos} fails and {@link GLib.errno} is set to {@link c::EDOM}.
 */
GLib.Math.acos

/**
 * Calculates the arc sine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose sine is ``x``. If ``x`` falls outside the range -1 to 1,
 * {@link GLib.Math.asin} fails and {@link GLib.errno} is set to {@link c::EDOM}.
 */
GLib.Math.asin

/**
 * Calculates the arc tangent of the two variables ``x`` and ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It is similar to calculating the arc tangent of ``y / x``, except that
 * the signs of both arguments are used to determine the quadrant of the result.
 */
GLib.Math.atan2

/**
 * Calculates the arc tangent of the two variables ``x`` and ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.atan2f} function calculates the arc tangent of the two variables ``x`` and ``y``.
 * 
 * It is similar to calculating the arc tangent of ``y / x``, except that the signs of both arguments are
 * used to determine the quadrant of the result.
 */
GLib.Math.atan2f

/**
 * Returns the cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x the given in radians.
 */
GLib.Math.cos

/**
 * Returns the cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x the given in radians.
 */
GLib.Math.cosf

/**
 * Returns the sine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x the given in radians.
 */
GLib.Math.sin

/**
 * Returns the tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x the given in radians.
 */
GLib.Math.tanf

/**
 * Returns the hyperbolic cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {{{
 *  cosh(x) = (exp(x) + exp(-x / 2)).
 * }}}
 */
GLib.Math.cosh

/**
 * returns the hyperbolic sine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {{{
 *  sinh(x) = (exp(x) - exp(-x / 2))
 * }}}
 */
GLib.Math.sinhf

/**
 * returns the hyperbolic tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {{{
 * tanh(x) = sinh(x) / cosh(x)
 * }}}
 */
GLib.Math.tanh

/**
 * Computes both sine and cosine of ``x`` at the same time.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * Several applications need sine and cosine of the same angle ``x``. This function
 * computes both at the same time, and stores the results via the output variables.
 * 
 * @param x A numeric value in radians.
 * @param sinx Output variable for sine of ``x``.
 * @param cosx Output variable for cosine of ``x``.
 */
GLib.Math.sincosf

/**
 * Calculates the inverse hyperbolic cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose hyperbolic cosine is ``x``. If ``x`` is less than 1.0,
 * {@link GLib.Math.acosh} returns not-a-number {@link double.NAN}) and {@link GLib.errno}
 * is set {@link c::EDOM}.
 * 
 * @param x A numeric value which is equal or greater than 1.0.
 */
GLib.Math.acosh

/**
 * Calculates the inverse hyperbolic cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose hyperbolic cosine is ``x``. If x is less than 1.0,
 * {@link GLib.Math.acosh} returns not-a-number {@link float.NAN} and {@link GLib.errno}
 * is {@link c::EDOM}.
 * 
 * @param x A numeric value which is equal or greater than 1.0.
 */
GLib.Math.acoshf

/**
 * Returns the value of the base of natural logarithms raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value
 */
GLib.Math.expf

/**
 * Split the number ``x`` into a normalized fraction and an exponent.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param exponent The output variable for the exponent.
 */
GLib.Math.frexp

/**
 * Breaks the argument ``x`` into an integral part and a fractional part,
 * each of which has the same sign as ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The integral part is stored in output variable ``iptr``.
 * 
 * @param x A numeric value.
 * @param iptr The output variable for the integral part.
 */
GLib.Math.modf

/**
 * Returns the value of 10 raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.pow10f

/**
 * Returns a value equivalent to ``exp(x) - 1``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It is computed in a way that  is accurate even if the value of ``x`` is near zero; a
 * case where ``exp(x) - 1`` would be inaccurate  due to subtraction of two numbers that
 * are nearly equal.
 * 
 * @param x A numeric value
 */
GLib.Math.expm1

/**
 * Returns the value of ``x`` raised to the power of ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.powf

/**
 * Returns the non-negative square root of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It fails and sets {@link GLib.errno} to {@link c::EDOM}, if ``x`` is negative.
 * 
 * @param x A numeric value.
 */
GLib.Math.sqrt

/**
 * Returns the non-negative square root of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It fails and sets {@link GLib.errno} to {@link c::EDOM}, if ``x`` is negative.
 * 
 * @param x A numeric value.
 */
GLib.Math.sqrtf

/**
 * Returns the (real) cube root of x.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * This function cannot fail; every representable real value has a representable real cube root.
 * 
 * @param x A numeric value.
 */
GLib.Math.cbrt

/**
 * Rounds ``x`` up to the nearest integer.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.ceilf

/**
 * Rounds ``x`` down to the nearest integer.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.floor

/**
 * Computes the remainder of dividing ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The return  value is ``x - n * y``, where ``n`` is the quotient of
 * ``x / y``, rounded towards zero to an integer.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fmodf

/**
 * Returns the value of not-a-number ({@link float.NAN}) checking.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.finitef} function returns a non-zero value if ``value``
 * is neither infinite nor a not-a-number ({@link float.NAN}) value, and
 * 0 otherwise.
 * 
 * @param value A numeric value.
 */
GLib.Math.finitef

/**
 * Returns the mantissa of ``x`` scaled to the range ``[1,2]``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * This function exists mainly for use in certain standardized tests for IEEE 754 conformance.
 * 
 * @param x A numeric value.
 */
GLib.Math.significand

/**
 * Returns a value whose absolute value matches that of ``x``, but whose sign bit matches that of ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is a {@link float.NAN}, then a {@link float.NAN} with the sign bit of ``y`` is returned.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.copysignf

/**
 * Returns a representation (determined by ``tagb``) of a quiet {@link double.NAN}.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If the implementation does not support quiet {@link double.NAN}s, the function returns zero.
 * 
 * The argument ``tagb`` is used in an unspecified manner. On IEEE 754 systems, there are many
 * representations of {@link double.NAN}, and ``tagb`` selects one. On other systems it may do nothing.
 * 
 * @param tagb A representation tag.
 */
GLib.Math.nan

/**
 * Returns a representation (determined by ``tag``) of a quiet {@link float.NAN}.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If the implementation does not support quiet {@link float.NAN}s, the function returns zero.
 * 
 * The argument ``tag`` is used in an unspecified manner. On IEEE 754 systems, there are many
 * representations of {@link float.NAN}, and ``tag`` selects one. On other systems it may do nothing.
 * 
 * @param tag A representation tag.
 */
GLib.Math.nanf

/**
 * Returns Bessel function of ``x0`` of the first kind of order 0.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.j0f

/**
 * Returns Bessel function of ``x`` of the first kind of order ``n``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param n Determines the Bessel function order.
 * @param x A numeric value.
 */
GLib.Math.jn

/**
 * Returns Bessel function of ``x`` of the first kind of order ``n``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param n Determines the Bessel function order.
 * @param x A numeric value.
 */
GLib.Math.jnf

/**
 * Returns Bessel function of ``x0`` of the second kind of order 1.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.y1f

/**
 * Returns Bessel function of ``x1`` of the second kind of order ``x0``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 Determines the Bessel function order.
 * @param x1 A numeric value.
 */
GLib.Math.ynf

/**
 * Returns the error function of ``x0``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * Defined as ``erf(x) = 2/sqrt(pi)* integral from 0 to x0 of exp(-t*t) dt``.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.erf

/**
 * Returns the complementary error function of ``x0``, that is ``1.0 - erf(x0)``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.erfcf

/**
 * Returns the value of Gamma function for the argument ``x0``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The Gamma function is defined by ``Gamma(x) = integral from 0 to infinity of t^(x-1) e^-t dt``.
 * 
 * It is defined for every real number except for non-positive integers. For non-negative integral m
 * one has ``Gamma(m+1) = m!`` and, more generally, for all ``x: Gamma(x+1) = x * Gamma(x)``.
 * 
 * Furthermore, the following is valid for all values of ``x`` outside the poles: ``Gamma(x) * Gamma(1 - x) = PI / sin(PI * x)``
 * 
 * This function return the value of Gamma function for the argument ``x``. It had to be called "true gamma function" since
 * there is already a function gamma that returns something else.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.tgamma

/**
 * Returns the natural logarithm of the absolute value of the Gamma function.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The sign of the Gamma function is returned in the second parameter.
 * 
 * It is 1 when the Gamma function is positive or zero, -1 when it is negative.
 * 
 * @param x0 A numeric value.
 * @param signgamp {@link GLib.Math.lgamma_rf} sets signgamp to 1 when the Gamma function is positive or zero, -1  when it is negative.
 */
GLib.Math.lgamma_rf

/**
 * Rounds it's argument to an integer value in floating point format,
 * using the current rounding direction and with raising the inexact exception.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.rint

/**
 * Returns the next representable neighbor of ``x`` in the direction towards ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The size of the step between ``x`` and the result depends on the type of the result.
 * 
 * If ``x = y`` the function simply returns ``y``. If either value is {@link double.NAN}, then {@link double.NAN}
 * is returned. Otherwise a value corresponding to the value of the least significant bit in the mantissa is added
 * or subtracted, depending on the direction.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.nextafter

/**
 * This function is equivalent to {@link Math.ldexp}.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param n A numeric value.
 */
GLib.Math.scalblnf

/**
 * Rounds argument ``x`` to an integer value in floating point format,
 * using the current rounding direction and without raising the inexact exception.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.nearbyint

/**
 * Rounds argument ``x`` to the nearest integer, but round halfway cases away from zero,
 * (regardless of the current rounding direction), instead of to the nearest even integer like rint.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.round

/**
 * Rounds it's argument to the nearest integer value, using the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link double.NAN}, or if the rounded value is outside the range of
 * the return type, the numeric result is unspecified. A domain error may occur if the magnitude
 * of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.lrint

/**
 * Rounds it's argument to the nearest integer value, using the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link float.NAN}, or if the rounded value is outside the range
 * of the return type, the numeric result is unspecified. A domain error may occur if the
 * magnitude of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.lrintf

/**
 * Rounds it's argument to the nearest integer value, using the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.llrint} rounds it's argument to the nearest integer value, using the
 * current rounding direction. If ``x`` is infinite or {@link double.NAN}, or if the rounded
 * value is outside the range of the return type, the numeric result is unspecified. A domain
 * error may occur if the magnitude of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.llrint

/**
 * Rounds it's argument to the nearest integer value, rounding away from zero, regardless of the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link double.NAN}, or if the rounded value is outside the range of the return type,
 * the numeric result is unspecified.
 * 
 * A domain error may occur if the magnitude of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.lround

/**
 * Rounds it's argument to the nearest integer value, rounding away from zero, regardless of the current rounding direction.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is infinite or {@link float.NAN}, or if the rounded value is outside the range of the return type,
 * the numeric result is unspecified.
 * 
 * A domain error may occur if the magnitude of ``x`` is too large.
 * 
 * @param x A numeric value.
 */
GLib.Math.lroundf

/**
 * Returns ``max(x - y, 0)``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` or ``y`` or both are {@link float.NAN}, {@link float.NAN} is returned.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fdimf

/**
 * Returns the larger value of ``x`` and ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fmaxf

/**
 * Multiplies ``x`` by 2 to the power ``n``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param n A numeric value.
 */
GLib.Math.scalb

/**
 * The base of natural logarithms.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 */
GLib.Math.E

/**
 * Calculates the arc cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose cosine is ``x``. If ``x`` falls outside the range -1 to 1,
 * {@link GLib.Math.acosf} fails and {@link GLib.errno} is set to {@link c::EDOM}.
 */
GLib.Math.acosf

/**
 * Calculates the arc sine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * That is the value whose
 * sine is ``x``. If ``x`` falls outside the range -1 to 1, {@link GLib.Math.asinf} fails and
 * {@link GLib.errno} is set to {@link c::EDOM}.
 */
GLib.Math.asinf

/**
 * Returns the sine of ``x``, where ``x`` is given in radians.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 */
GLib.Math.sinf

/**
 * Returns the hyperbolic cosine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {{{
 *  cosh(x) = (exp(x) + exp(-x / 2))
 * }}}
 */
GLib.Math.coshf

/**
 * Returns the hyperbolic sine of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {{{
 *  sinh(x) = (exp(x) - exp(-x / 2))
 * }}}
 */
GLib.Math.sinh

/**
 * computes both sine and cosine of ``x`` at the same time.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * Several applications need sine and cosine of the same angle ``x``. This function computes both
 * at the same time, and stores the results via the output variables.
 * 
 * @param x A numeric value in radians.
 * @param sinx Output variable for sine of x
 * @param cosx Output variable for cosine of x.
 */
GLib.Math.sincos

/**
 * Returns the inverse hyperbolic sine of ``x``, that is the value whose hyperbolic sine is ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.asinh

/**
 * Returns the inverse hyperbolic tangent of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If the absolute  value of ``x`` is greater than 1.0, {@link GLib.Math.atanhf} returns
 * not-a-number ({@link float.NAN}) and {@link GLib.errno} is set {@link c::EDOM}.
 * 
 * @param x A numeric value which is between -1.0 and 1.0.
 */
GLib.Math.atanhf

/**
 * Split the number ``x`` into a normalized fraction and an exponent.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param exp The output variable for the exponent.
 */
GLib.Math.frexpf

/**
 * Returns the result of multiplying the floating-point number ``x`` by 2 raised to the power ``exponent``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param exponent An integer value for the exponent.
 */
GLib.Math.ldexpf

/**
 * Returns the natural logarithm of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.log

/**
 * Returns the value of 10 raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.exp10f

/**
 * Returns the value of 10 raised to the power of ``x``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.pow10

/**
 * Returns a value equivalent to ``exp(x) - 1``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It is computed in a way that  is accurate even if the value of ``x`` is near zero; a case where ``exp(x) - 1``
 * would be inaccurate  due to subtraction of two numbers that are nearly equal.
 * 
 * @param x A numeric value
 */
GLib.Math.expm1f

/**
 * Returns a value equivalent to ``log(1 + x)``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * It is computed in a way that is accurate even if the value of ``x`` is near zero.
 * 
 * @param x A numeric value.
 */
GLib.Math.log1p

/**
 * Returns the length of the hypotenuse of a right-angle triangle
 * with sides of length ``x`` and ``y``, or the distance of the point ``(x,y)`` from the origin.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.hypot} function returns ``sqrt(x*x + y*y)``.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.hypot

/**
 * Rounds ``x`` up to the nearest integer.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.ceil

/**
 * Returns the absolute value.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.fabs

/**
 * Returns a value whose absolute value matches that of ``x``, but whose sign bit matches that of ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * If ``x`` is a {@link double.NAN}, then a Nan with the sign bit of ``y`` is returned.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.copysign

/**
 * Returns Bessel function of ``x0`` of the first kind of order 1.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.j1

/**
 * Returns Bessel function of ``x0`` of the second kind of order 0.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.y0

/**
 * Returns Bessel function of ``x0`` of the second kind of order 1.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x0 A numeric value.
 */
GLib.Math.y1

/**
 * Returns the error function of x0.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * Defined as ``erf(x) = 2/sqrt(pi)* integral from 0 to x0 of exp(-t*t) dt``.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.erff

/**
 * Computes the natural logarithm of the Gamma function.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {@link GLib.Math.gamma} function is equivalent to {@link GLib.Math.lgamma} and computes the natural logarithm of the Gamma function.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.gamma

/**
 * Computes the natural logarithm of the Gamma function.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * {@link GLib.Math.gammaf} function is equivalent to {@link GLib.Math.lgamma} and computes the natural logarithm of  the Gamma function.
 * 
 * @param x0 A numeric value.
 */
GLib.Math.gammaf

/**
 * Returns the next representable neighbor of ``x`` in the direction towards ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The size of the step between ``x`` and the result depends on the type of the result.
 * 
 * If ``x = y`` the function simply returns ``y``. If either value is {@link float.NAN}, then {@link float.NAN}
 * is returned. Otherwise a value corresponding to the value of the least significant bit in the
 * mantissa is added or subtracted, depending on the direction.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.nextafterf

/**
 * Multiplies it's first argument ``x`` by 2 to the power ``n``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The {@link GLib.Math.scalbn} function multiplies their first argument ``x`` by 2 to the power ``n``.
 * {@link GLib.Math.scalbn} is equivalent to {@link GLib.Math.ldexp}.
 * 
 * @param x A numeric value.
 * @param n A numeric value.
 */
GLib.Math.scalbn

/**
 * Rounds argument ``x`` to an integer value in floating point format,
 * using the current rounding direction and without raising the inexact exception.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 */
GLib.Math.nearbyintf

/**
 * Computes the remainder and part of the quotient upon division of ``x`` by ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * A few bits of the quotient are stored via the quo output variable. The remainder  is returned as function value.
 * 
 * The value of the remainder is the same as that computed by the {@link GLib.Math.remainder} function.
 * 
 * The value stored via the quo output variable has the sign of ``x / y`` and agrees with the  quotient
 * in at least the low order 3 bits.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 * @param quo An output variable for the quotient.
 */
GLib.Math.remquo

/**
 * Returns the smaller value of ``x`` and ``y``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fmin

/**
 * Computes ``x * y + z``.
 *
 * Note: Remember to link the math library: ``valac -X -lm ...``
 * 
 * The result is rounded according to the rounding  mode determined by the value of {@link c::FLT_ROUNDS}.
 * {@link c::FLT_ROUNDS} indicates the implementation-defined rounding behavior for floating-point addition,
 * and has one of the following values:
 * 
 *  * -1 The rounding mode is not determinable.
 *  * 0 Rounding is towards 0.
 *  * 1 Rounding is towards nearest number.
 *  * 2 Rounding istowards positive infinity.
 *  * 3 Rounding is towards negative infinity.
 *  * Other values represent machine-dependent, non-standard rounding modes.
 * 
 * @param x A numeric value.
 * @param y A numeric value.
 */
GLib.Math.fma



/**
 * Converts the value to its equivalent string representation
 */
bool.to_string

/**
 * Converts the string to its equivalent boolean representation
 *
 * @param str the string to convert
 * @return the converted value on success, or false.
 * @see bool.try_parse
 */
bool.parse

/**
 * Converts the string to its equivalent boolean representation
 *
 * @param str the string to convert
 * @param result the location to store the value
 * @return true on success, or false.
 */
bool.try_parse



/**
 * Determines whether a character is a printing character and not a space.
 */
char.isgraph

/**
 * Determines whether a character is an ASCII lower case letter.
 */
char.islower

/**
 * Determines whether a character is a punctuation character.
 */
char.ispunct

/**
 * Determines whether a character is alphanumeric.
 */
char.isalnum

/**
 * Determines whether a character is a control character.
 */
char.iscntrl

/**
 * Determines whether a character is digit (0-9).
 */
char.isdigit

/**
 * Determines whether a character is an ASCII upper case letter.
 */
char.isupper

/**
 * Determines whether a character is a white-space character.
 */
char.isspace

/**
 * Determines whether a character is alphabetic (i.e. a letter).
 */
char.isalpha

/**
 * Determines whether a character is a printing character.
 */
char.isprint

/**
 * Determines whether a character is a hexadecimal-digit character.
 */
char.isxdigit

/**
 * Converts the value to its equivalent string representation
 */
char.to_string



/**
 * Converts the value to its equivalent string representation
 */
uchar.to_string



/**
 * Converts the value to its equivalent string representation
 */
int.to_string

/**
 * Computes the absolute value
 *
 * @return The absolute value
 */
int.abs

/**
 * Converts the string to its equivalent int representation
 *
 * Function discards any whitespace characters until first non-whitespace character is found.
 * Then it takes as many characters as possible to form a valid integer number representation
 * and converts them to integer value. The valid integer value consists of the following parts:
 *
 *  * (optional) plus or minus sign
 *  * numeric digits
 *
 * @param str the string to convert
 * @see int.try_parse
 * @return Integer value corresponding to the contents of str on success.
 *    If the converted value falls out of range of corresponding return type,
 *    the return value is undefined. If no conversion can be performed, ​0 is
 *    returned.
 */
int.parse



/**
 * Converts the value to its equivalent string representation
 */
uint.to_string

/**
 * Minimum value for a variable of type uint.
 */
uint.MIN

/**
 * Converts the value to its equivalent string representation
 */
int.to_string



/**
 * Converts the value to its equivalent string representation
 */
short.to_string



/**
 * Converts the value to its equivalent string representation
 */
ushort.to_string

/**
 * Minimum value for a variable of type ushort.
 */
ushort.MIN



/**
 * Converts the value to its equivalent string representation
 */
long.to_string

/**
 * Computes the absolute value
 *
 * @return The absolute value
 */
long.abs

/**
 * Interprets an integer value in a byte string pointed to by str.
 * 
 * Function discards any whitespace characters until first non-whitespace
 * character is found. Then it takes as many characters as possible to
 * form a valid integer number representation and converts them to integer
 * value. The valid integer value consists of the following parts:
 * 
 *  * (optional) plus or minus sign
 *  * numeric digits 
 *
 * @param str pointer to the null-terminated byte string to be interpreted
 * @return Integer value corresponding to the contents of str on success.
 *   If the converted value falls out of range of corresponding return type,
 *   the return value is undefined. If no conversion can be performed, ​0 is
 *   returned. 
 */
long.parse

/**
 * Minimum value for a variable of type long.
 */
long.MIN

/**
 * Converts the value to its equivalent string representation
 */
long.to_string



/**
 * Minimum value for a variable of type size_t.
 */
size_t.MIN

/**
 * Converts the value to its equivalent string representation
 */
size_t.to_string



/**
 * Converts the value to its equivalent string representation
 */
ssize_t.to_string



/**
 * Converts the value to its equivalent string representation
 */
int8.to_string



/**
 * Minimum value for a variable of type uint8.
 */
uint8.MIN

/**
 * Converts the value to its equivalent string representation
 */
uint8.to_string



/**
 * Converts the value to its equivalent string representation
 */
int16.to_string



/**
 * Minimum value for a variable of type uint16.
 */
uint16.MIN

/**
 * Converts the value to its equivalent string representation
 */
uint16.to_string



/**
 * Converts the value to its equivalent string representation
 */
int32.to_string



/**
 * Minimum value for a variable of type uint32.
 */
uint32.MIN

/**
 * Converts the value to its equivalent string representation
 */
uint32.to_string



/**
 * Converts the value to its equivalent string representation
 */
int64.to_string

/**
 * Computes the absolute value
 *
 * @return The absolute value
 */
int64.abs

/**
 * Converts a string to a gint64 value.
 *
 * If the correct value would cause overflow, {@link int64.MAX} or {@link int64.MIN} is returned, and
 * {@link c::ERANGE} is stored in errno. If the base is outside the valid range, zero is returned, and
 * {@link c::ERANGE} is stored in {@link c::errno}. If the string conversion fails, zero is returned. 
 *
 * @param str the string to convert to a numeric value.
 * @return the int64 value or zero on error.
 */
int64.parse

/**
 * Converts a string to a gint64 value.
 *
 * If the correct value would cause overflow, {@link int64.MAX} or {@link int64.MIN} is returned, and
 * {@link c::ERANGE} is stored in errno. If the base is outside the valid range, zero is returned, and
 * {@link c::ERANGE} is stored in {@link c::errno}. If the string conversion fails, zero is returned. 
 *
 * @param str the string to convert to a numeric value.
 * @param result the location to store the value
 * @return true on success, or false.
 */
int64.try_parse



/**
 * Minimum value for a variable of type uint64.
 */
uint64.MIN

/**
 * Converts the value to its equivalent string representation
 */
uint64.to_string



/**
 * Converts a string to a uint64 value.
 *
 * This function behaves like the standard ``strtoull`` function does in the C locale.
 * It does this without actually changing the current locale, since that would not be
 * thread-safe. 
 *
 * This function is typically used when reading configuration files or other non-user
 * input that should be locale independent. To handle input from the user you should
 * normally use the locale-sensitive system ``strtoull`` function. 
 *
 * If the correct value would cause overflow, {@link int64.MAX} is returned, and
 * {@link c::ERANGE} is stored in {@link GLib.errno}. If the base is outside the valid
 * range, zero is returned, and {@link c::EINVAL} is stored in errno. If the string
 * conversion fails, zero is returned. 
 *
 * @param str the string to convert to a numeric value.
 * @return the guint64 value or zero on error.
 */
uint64.parse

/**
 * Converts a string to a uint64 value.
 *
 * This function behaves like the standard ``strtoull`` function does in the C locale.
 * It does this without actually changing the current locale, since that would not be
 * thread-safe. 
 *
 * This function is typically used when reading configuration files or other non-user
 * input that should be locale independent. To handle input from the user you should
 * normally use the locale-sensitive system ``strtoull`` function. 
 *
 * If the correct value would cause overflow, {@link int64.MAX} is returned, and
 * {@link c::ERANGE} is stored in {@link GLib.errno}. If the base is outside the valid
 * range, zero is returned, and {@link c::EINVAL} is stored in errno. If the string
 * conversion fails, zero is returned. 
 *
 * @param str the string to convert to a numeric value.
 * @param result the location to store the value
 * @return true on success, or false.
 */
uint64.try_parse



/**
 * The radix (integer base) used by the representation of all three floating-point types
 */
float.RADIX

/**
 * Number of base {@link c::FLT_RADIX} digits that can be represented without losing precision
 */
float.MANT_DIG

/**
 * Number of decimal digits that can be represented without losing precision
 */
float.DIG

/**
 * Minimum negative integer such that {@link c::FLT_RADIX} raised by power one less than that integer is a normalized float
 */
float.MIN_EXP

/**
 * Maximum positive integer such that {@link c::FLT_RADIX} raised by power one more than that integer is a normalized float
 */
float.MAX_EXP

/**
 * Minimum negative integer such that 10 raised by power one less than that integer is a normalized float
 */
float.MIN_10_EXP

/**
 * Maximum positive integer such that 10 raised by power one more than that integer is a normalized float
 */
float.MAX_10_EXP

/**
 * Difference between 1.0 and the next representable value for float
 */
float.EPSILON

/**
 * Minimum positive value of float, use -{@link float.MAX} to get the minimum negative value
 */
float.MIN

/**
 * Maximum value of float
 */
float.MAX

/**
 * Indicates that the value is not-a-number (NaN) 
 */
float.NAN

/**
 * Indicates that the value is not representable by the underlying type (positive or negative infinity) 
 */
float.INFINITY

/**
 * Determines if the given floating point number is not-a-number (NaN).
 */
float.is_nan

/**
 * Determines if the given floating point number has finite value i.e. it is normal, subnormal or zero, but not infinite or NAN.
 */
float.is_finite

/**
 * Determines if the given floating point number is normal, i.e. is neither zero, subnormal, infinite, nor NaN.
 */
float.is_normal

/**
 * Determines if the given floating point number is a negative or positive infinity
 */
float.is_infinity

/**
 * Converts the value to its equivalent string representation
 */
float.to_string



/**
 * Number of base {@link c::FLT_RADIX} digits that can be represented without losing precision
 */
double.MANT_DIG

/**
 * Number of decimal digits that can be represented without losing precision
 */
double.DIG

/**
 * Minimum negative integer such that {@link c::FLT_RADIX} raised by power one less than that integer is a normalized double
 */
double.MIN_EXP

/**
 * Maximum positive integer such that {@link c::FLT_RADIX} raised by power one more than that integer is a normalized double
 */
double.MAX_EXP

/**
 * Minimum negative integer such that 10 raised by power one less than that integer is a normalized double
 */
double.MIN_10_EXP

/**
 * Maximum positive integer such that 10 raised by power one more than that integer is a normalized double
 */
double.MAX_10_EXP

/**
 * Difference between 1.0 and the next representable value for double
 */
double.EPSILON

/**
 * Minimum positive value of double, use -{@link double.MAX} to get the minimum negative value
 */
double.MIN

/**
 * Maximum value of double
 */
double.MAX

/**
 * Indicates that the value is not-a-number (NaN) 
 */
double.NAN

/**
 * Indicates that the value is not representable by the underlying type (positive or negative infinity) 
 */
double.INFINITY

/**
 * Determines if the  double is not-a-number (NaN).
 */
double.is_nan

/**
 * Determines if the given double has finite value i.e. it is normal, subnormal or zero, but not infinite or NAN.
 */
double.is_finite

/**
 * Determines if the given double is normal, i.e. is neither zero, subnormal, infinite, nor NaN.
 */
double.is_normal

/**
 * Determines if the given double is a negative or positive infinity
 */
double.is_infinity

/**
 * Converts the value to its equivalent string representation
 */
double.to_string

/**
 * Converts a string to a double value.
 *
 * This function behaves like the standard strtod() function does in the C locale. It does this
 * without actually changing the current locale, since that would not be thread-safe. A limitation
 * of the implementation is that this function will still accept localized versions of infinities
 * and NANs.
 * 
 * This function is typically used when reading configuration files or other non-user input that
 * should be locale independent. To handle input from the user you should normally use the
 * locale-sensitive system strtod() function.
 * 
 * If the correct value would cause overflow, plus or minus {@link c::HUGE_VAL} is returned (according
 * to the sign of the value), and {@link c::ERANGE} is stored in {@link GLib.errno}. If the correct
 * value would cause underflow, zero is returned and {@link c::ERANGE} is stored in {@link GLib.errno}.
 * 
 * This function resets errno before calling strtod() so that you can reliably detect overflow
 * and underflow.
 *
 * @param str the string to convert to a numeric value.
 * @return the guint64 value or zero on error.
 */
double.parse

/**
 * Converts a string to a double value.
 *
 * This function behaves like the standard strtod() function does in the C locale. It does this
 * without actually changing the current locale, since that would not be thread-safe. A limitation
 * of the implementation is that this function will still accept localized versions of infinities
 * and NANs.
 * 
 * This function is typically used when reading configuration files or other non-user input that
 * should be locale independent. To handle input from the user you should normally use the
 * locale-sensitive system strtod() function.
 * 
 * If the correct value would cause overflow, plus or minus {@link c::HUGE_VAL} is returned (according
 * to the sign of the value), and {@link c::ERANGE} is stored in {@link GLib.errno}. If the correct
 * value would cause underflow, zero is returned and {@link c::ERANGE} is stored in {@link GLib.errno}.
 * 
 * This function resets errno before calling strtod() so that you can reliably detect overflow
 * and underflow.
 *
 * @param str the string to convert to a numeric value.
 * @param result the location to store the value
 * @return true on success, or false.
 */
double.try_parse


/**
 * Arithmetic type capable of representing times. 
 */
time_t

/**
 * Returns the current time of the system as time since epoch 
 */
time_t.time_t



/**
 * Struct to hold information about variadic function arguments 
 *
 * It is legal to pass a pointer to a va_list object to another function and then
 * use that object after the function returns. 
 */
va_list

/**
 * The va_start macro enables access to the variable arguments
 */
va_list.va_list

/**
 * Makes a copy of the variadic function arguments 
 */
va_list.va_list.copy

/**
 * Accesses the next variadic function argument 
 */
va_list.arg



/**
 * Converts the value to its equivalent string representation
 */
unichar.to_string

/**
 * Finds the leftmost occurrence of the given string.
 *
 * @param needle a string
 * @param start_index the starting position for the search in bytes.
 * @return the byte index of the first occurrence of the string, or -1 if the string does not occur.
 */
string.index_of

/**
 * Find the rightmost occurrence of the given string.
 *
 * @param needle a string to look for
 * @param start_index the starting position for the search in bytes.
 * @return the byte index of the last occurrence of ``needle``, or -1 if does not occur.
 */
string.last_index_of

/**
 * Checks if a ``needle`` exists in string
 *
 * @param needle the string to search for
 * @return returns ``true`` if needle is found in the string, ``false`` otherwise. 
 */
string.contains

/**
 * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
 *
 * If index does not point to a valid UTF-8 encoded character, results are undefined.
 * If you are not sure that the bytes are complete valid Unicode characters, you should
 * use {@link string.get_char_validated} instead.
 *
 * @param index a byte offset to a unicode character encoded as UTF-8 
 * @return the resulting character 
 */
string.get_char

/**
 * Finds the next UTF-8 character in the string after ``index``. 
 *
 * ``index`` does not have to be at the beginning of a UTF-8 character.
 * No check is made to see if the character found is actually valid other
 * than it starts with an appropriate byte.
 *
 * @param index a byte offset to a unicode character encoded as UTF-8
 * @param c the location to store the next unichar
 * @return ``true`` if a character is found in the string, ``false`` otherwise. 
 */
string.get_next_char

/**
 * Finds the previous UTF-8 character in the string before ``index``.
 *
 * ``index`` does not have to be at the beginning of a UTF-8 character.
 * No check is made to see if the character found is actually valid other
 * than it starts with an appropriate byte.
 *
 * @param index a byte offset to a unicode character encoded as UTF-8
 * @param c the location to store the next unichar
 * @return ``true`` if a character is found in the string, ``false`` otherwise. 
 */
string.get_prev_char

/**
 * Converst utf8-char-position to a byte offset.
 *
 * Since 2.10, this function allows to pass a negative offset to step backwards.
 * It is usually worth stepping backwards from the end instead of forwards if offset
 * is in the last fourth of the string, since moving forward is about 3 times faster
 * than moving backward.
 *
 * @param c the utf8-character offset
 * @return the byte offset of the nth utf8-character.
 */
string.index_of_nth_char

/**
 * Splits a string into a maximum of max_tokens pieces, using the given delimiter.
 */
string.split

/**
 * Removes a portion of the string and replaces it with something else.
 *
 * Removes the characters designated by ``start`` and ``end`` from the string,
 * and replaces them with ``str``, if supplied.
 *
 * If ``start`` or ``end`` is negative, {@link string.splice} uses it as
 * a character index from the end of the string.
 *
 * @param start the zero-based byte-index at which to begin extraction.
 * @param end the zero-based byte-index at which to end extraction.
 * @param str removed chars are replaced with this string.
 * @return a newly-allocated string holding the result.
 */
string.splice

/**
 * Extracts the text from one string and returns a new string.
 *
 * If ``start`` or ``end`` is negative, {@link string.slice} uses it as
 * a character index from the end of the string.
 *
 * @param start the zero-based byte-index at which to begin extraction.
 * @param end the zero-based byte-index at which to end extraction.
 * @return a newly-allocated string holding the result.
 */
string.slice

/**
 * Reads the data from string
 *
 * The format string consists of whitespace characters (any single whitespace character
 * in the format string consumes all available consecutive whitespace characters from
 * the input), non-whitespace characters except % (each such character in the format
 * strings consumes exactly one identical character from the input) and conversion
 * specifications. Each conversion specification has the following format: 
 *
 *  {{{%[flags][width][.precision][length]specifier}}}
 *
 * ''Flags:''
 *
 * || ''Character'' || ''Description'' ||
 * || + || The sign of signed conversions is always prepended to the result of the conversion ||
 * || <space> || if the result of a signed conversion does not start with a sign character, or is empty, space is prepended to the result. It is ignored if + flag is present. ||
 * || - || The result of the conversion is left-justified within the field ||
 * || # || Alternative form of the conversion is performed. ||
 * || 0 || Use 0 instead of spaces for padding when width is specified ||
 *
 * ''Width:''
 *
 * Integer value or * that specifies minimum field width. The result is padded with space characters (by default),
 * if required, on the left when right-justified, or on the right if left-justified. In the case when * is used,
 * the width is specified by an additional argument of type int. If the value of the argument is negative, it
 * results with the - flag specified and positive field width. 
 *
 * ''Precision:''
 *
 * . followed by integer number or * that specifies precision of the conversion. In the case when * is used, the precision is specified by an additional
 * argument of type int. If the value of this argument is negative, it is ignored. 
 *
 * ''Length:''
 *
 * || ''Character'' || ''Description'' ||
 * || hh || char ||
 * || h || short ||
 * || l || long ||
 * || ll || long-long ||
 * || L || long double ||
 * || z || sizue_t ||
 * || j || intmax_t ||
 * || t || ptrdiff_t ||
 *
 * ''Specifier:''
 *
 * || ''specifier'' || ''Output'' || ''Example'' ||
 * || a || Floating point, hexadecimal, lowercase || -0xc.90fep-2 ||
 * || A || Floating point, hexadecimal, uppercase || -0XC.90FEP-2 ||
 * || c || Character || c ||
 * || d, i || integer || 251 ||
 * || e || Mantissa/exponent (scientific), lowercase || 2.5121e+2 ||
 * || E || Mantissa/exponent (scientific), uppercase || 2.5121E+2 ||
 * || f || Floating point, decimal, lowercase || 2.32 ||
 * || F || Floating point, decimal, uppercase || 2.32 ||
 * || g || Floating point, shortest representation (%e or %f) || 512.23 ||
 * || G || Floating point, shortest representation (%E or %F) || 512.23 ||
 * || n || Nothing || ||
 * || o || Octal || 320 ||
 * || p || Pointer address || b2010020 ||
 * || s || String || my str ||
 * || u || Decimal integer || 93535 ||
 * || x || Integer, hexadecimal, lowercase || 3ab ||
 * || X || Integer, hexadecimal, uppercase || 3AB ||
 * || % || %% to output % || % ||
 *
 * ''Examples:''
 *
 * || ''Format:'' || ''Parameters:'' || ''Output:'' ||
 * || "Characters:\t%c %%\n" || 65 || "Characters: A %" ||
 * || "Decimal:\t%i %d %.6i %i %.0i %+i %u\n" ||  1, 2, 3, 0, 0, 4, -1 || "Decimal: 1 2 000003 0  +4 4294967295" ||
 * || "Hexadecimal:\t%x %x %X %#x\n" ||  5, 10, 10, 6 || "Hexadecimal: 5 a A 0x6" ||
 * || "Octal:\t%o %#o %#o\n" || 10, 10, 4 || "Octal: 12 012 04" ||
 * || "Rounding:\t%f %.0f %.32f\n" || 1.5, 1.5, 1.3 || "Rounding: 1.500000 2 1.30000000626" ||
 * || "Padding:\t%05.2f %.2f %5.2f\n" || 1.5, 1.5, 1.5 || "Padding: 01.50 1.50  1.50" ||
 * || "Scientific:\t%E %e\n" || 1.5, 1.5 || "Scientific: 1.500000E+00 1.500000e+00" ||
 * || "Hexadecimal:\t%a %A\n" || 1.5, 1.5 || "Hexadecimal: 0x1.8p+0 0X1.8P+0" ||
 *
 * @param format character string specifying how to read the input (See {@link GLib.FileStream.printf})
 * @param ... receiving arguments 
 */
string.scanf

/**
 * Checks whether valid string character starts at specified index.
 *
 * Embedded NULs are not supported by the string class.
 *
 * @param index a byte offset
 */
string.valid_char

/**
 * Returns the byte at the given index
 *
 * @param index a byte offset
 */
string.get

/**
 * Replace occurrences of the search string with the replacement string at a maximum of max_tokens
 *
 * @param old The value being searched for
 * @param replacement The replacement value that replaces ``old`` values.
 * @param max_tokens The maximum number. If this is less than 0, the string will be replaced completely.
 * @return a string with the replaced values. 
 */
string.replace

/**
 * Returns the characters in a string beginning at the specified location through the specified number of characters.
 *
 * ``offset`` is a byte index. The index of the first character is 0, and the index of the last character is 1 less than
 * the length of the string. {@link string.substring} begins extracting characters at ``offset`` and collects ``len``
 * characters (unless it reaches the end of the string first, in which case it will return fewer).
 *
 * If ``offset`` is positive and is greater than or equal to the length of the string, {@link string.substring} returns
 * null and reports a critical warning.
 *
 * If ``offset`` is negative, {@link string.substring} uses it as a character index from the end of the string.
 * If start is negative and abs(start) is larger than the length of the string, {@link string.substring}, 
 * {@link string.substring} returns null and reports a critical warning.
 *
 * If ``len`` is 0, {@link string.substring} returns an empty string.
 *
 * If ``len`` is omitted or negative, {@link string.substring} extracts characters to the end of the string.
 *
 * @param offset Location at which to begin extracting characters. (in bytes)
 * @param len The number of characters to extract. (in bytes)
 * @return the specified substring. 
 */
string.substring

/**
 * Returns the string as a UTF-8 char array
 */
string.to_utf8

/**
 * Converts any ``delimiter`` characters in string to ``new_delimiter``.
 *
 * Any characters in string which are found in ``delimiters`` are changed to the ``new_delimiter`` character.
 *
 * @param delimiters a string containing the current delimiters, or null to use the standard delimiters defined in {@link c::G_STR_DELIMITERS} 
 * @param new_delimiter the new delimiter character
 * @return a newly-allocated string holding the result
 */
string.delimit

/**
 * Find the rightmost occurrence of the given Unicode character in a UTF-8 encoded string.
 *
 * @param c a unicode character
 * @param start_index the starting position for the search in bytes.
 * @return the byte index of the last occurrence of the character, or -1 if the character does not occur.
 */
string.last_index_of_char

/**
 * Finds the leftmost occurrence of the given Unicode character in a UTF-8 encoded string.
 *
 * @param c a unicode character
 * @param start_index the starting position for the search in bytes.
 * @return the byte index of the first occurrence of the character, or -1 if the character does not occur.
 */
string.index_of_char

/**
 * The string as a sequence of bytes
 */
string.data

/**
 * Removes trailing whitespace from a string.
 *
 * @return a newly-allocated string holding the result
 * @see string._chomp
 * @see string._chug
 * @see string._strip
 * @see string.chug
 * @see string.strip
 */
string.chomp

/**
 * Removes leading whitespace from a string.
 *
 * @return a newly-allocated string holding the result
 * @see string._chomp
 * @see string._chug
 * @see string._strip
 * @see string.chomp
 * @see string.strip
 */
string.chug

/**
 * Removes leading and trailing whitespace from a string.
 *
 * @return a newly-allocated string holding the result
 * @see string._chomp
 * @see string._chug
 * @see string._strip
 * @see string.chomp
 * @see string.chug
 */
string.strip

/**
 * Converts the value to its equivalent string representation
 */
string.to_string

/**
 * Returns the length of the given string in bytes.
 */
string.length


/**
 * Copies count characters from the object pointed to by src to the object pointed to by dest.
 *
 * If the objects overlap, the behavior is undefined. 
 *
 * @param s1 pointer to the memory location to copy to
 * @param s2 pointer to the memory location to copy from
 * @param n number of bytes to copy 
 * @return dest
 */
GLib.Memory.cmp

/**
 * Copies count characters from the object pointed to by src to the object pointed to by dest.
 * 
 * If the objects overlap, the behavior is undefined. 
 * 
 * @param dest pointer to the memory location to copy to
 * @param src pointer to the memory location to copy from
 * @param n number of bytes to copy  * @return dest
 * @return dest
 */
GLib.Memory.copy

/**
 * Copies src into each of the first count characters
 * of the object pointed to by dest. 
 * 
 * @param dest pointer to the object to fill
 * @param src fill byte
 * @param n number of bytes to fill
 * @return dest
 */
GLib.Memory.set

/**
 * A preprocessor macro that expands to a thread-local modifiable lvalue of type int.
 *
 * Several standard library functions indicate errors by writing positive integers to errno.
 * Typically, the value of errno is set to one the error codes, listed in Posix as macro
 * constants that begin with the letter E, followed by uppercase letters or digits.
 *
 * The value of errno is 0 at program startup, and although library functions are allowed to write
 * positive integers to errno whether or not an error occurred, library functions never store ​0 in
 * errno.
 */
GLib.errno

/**
 * Returns a string corresponding to the given error code, e.g. "no such process".
 */
GLib.strerror

/**
 * Structure holding a calendar date and time broken down into its components.
 */
GLib.Time

/**
 * Converts the value to its equivalent string representation
 */
GLib.Time.to_string

/**
 * Seconds after the minute – [0, 60]
 *
 * Range allows for a positive leap second.
 */
GLib.Time.second

/**
 * Minutes after the hour – [0, 59]
 */
GLib.Time.minute

/**
 * Hours since midnight – [0, 23]
 */
GLib.Time.hour

/**
 * Day of the month – [1, 31]
 */
GLib.Time.day

/**
 * Months since January – [0, 11]
 */
GLib.Time.month

/**
 * Years since 1900
 */
GLib.Time.year

/**
 * Days since Sunday – [0, 6]
 */
GLib.Time.weekday

/**
 * Days since January 1 – [0, 365]
 */
GLib.Time.day_of_year

/**
 * Daylight Saving Time flag. The value is positive if DST is in effect, zero if not and negative if no information is available
 */
GLib.Time.isdst

/**
 * Converts given time since epoch as time_t value into calendar time, expressed in Coordinated Universal Time (UTC). 
 *
 * @param time a time_t object to convert
 */
GLib.Time.gm

/**
 * Converts given time since epoch as time_t value into calendar time, expressed in local time.
 *
 * @param time a time_t object to convert
 */
GLib.Time.local

/**
 * Converts the date and time information to a formatted string.
 *
 * @param format a date-time format. See {@link GLib.Time.format} for details.
 * @return a newly-allocated string holding the result.
 * @see GLib.Time.strptime
 * @see GLib.Time.strftime
 */
GLib.Time.format

/**
 * Converts local calendar time to a time since epoch as a time_t object, ignoring
 * the values of {@link GLib.Time.weekday} {@link GLib.Time.day_of_year}
 *
 * The values of other components of time are not restricted to their usual ranges.
 * A negative value of {@link GLib.Time.isdst} causes mktime to attempt to determine
 * if Daylight Saving Time was in effect.
 *
 * If successful, recalculates and updates all fields in time to fit their proper
 * ranges. 
 *
 * @return time since epoch as a time_t object on success or -1 if time cannot be
 *   represented as a time_t object. 
 */
GLib.Time.mktime

/**
 * Converts the date and time information to a null-terminated
 * multibyte character string str according to format string format. Up to count bytes are written. 
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || % || writes literal %. The full conversion specification must be %%. || - ||
 *
 * ''Year:''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || Y || writes year as a 4 digit decimal number || year ||
 * || y ||  writes last 2 digits of year as a decimal number (range [00,99]) || {@link GLib.Time.year} ||
 *
 * ''Month:''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || b || writes abbreviated month name, e.g. Oct (locale dependent) || {@link GLib.Time.month} ||
 * || B || writes full month name, e.g. October (locale dependent) || {@link GLib.Time.month} ||
 * || m || writes month as a decimal number (range [01,12]) || {@link GLib.Time.month} ||
 * 
 * ''Week:''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || U || writes week of the year as a decimal number (Sunday is the first day of the week) (range [00,53]) || {@link GLib.Time.year}, {@link GLib.Time.weekday}, {@link GLib.Time.day_of_year} ||
 * || W || writes week of the year as a decimal number (Monday is the first day of the week) (range [00,53]) || {@link GLib.Time.year}, {@link GLib.Time.weekday}, {@link GLib.Time.day_of_year} ||
 *
 * ''Day of the year/month:''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || j || writes day of the year as a decimal number (range [001,366]) || {@link GLib.Time.day_of_year} ||
 * || d || writes day of the month as a decimal number (range [01,31]) || {@link GLib.Time.day} ||
 *
 * ''Day of the week''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || a || writes abbreviated weekday name, e.g. Fri (locale dependent) || {@link GLib.Time.weekday} ||
 * || A || writes full weekday name, e.g. Friday (locale dependent) || {@link GLib.Time.weekday} ||
 * || w || writes weekday as a decimal number, where Sunday is 0 (range [0-6]) || {@link GLib.Time.weekday} ||
 *
 * ''Hour, minute, second''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || H || writes hour as a decimal number, 24 hour clock (range [00-23]) || {@link GLib.Time.hour} ||
 * || I || writes hour as a decimal number, 12 hour clock (range [01,12]) || {@link GLib.Time.hour} ||
 * || M || writes minute as a decimal number (range [00,59]) || {@link GLib.Time.minute} ||
 * || S || writes second as a decimal number (range [00,60]) || {@link GLib.Time.second} ||
 *
 * ''Other:''
 *
 * || ''Conversion specifier'' || ''Explanation'' || ''Fields'' ||
 * || c || writes standard date and time string, e.g. Sun Oct 17 04:41:13 2010 (locale dependent) || all ||
 * || x || writes localized date representation (locale dependent) || all ||
 * || X || writes localized time representation (locale dependent) || all ||
 * || p || writes localized a.m. or p.m. (locale dependent) || {@link GLib.Time.hour} ||
 * || Z || writes time zone name or abbreviation, or no characters if the time zone information is not available (locale dependent) || {@link GLib.Time.isdst} ||
 *
 * @param f A byte buffer
 * @param format A string specifying the format of conversion.
 * @return Number of bytes written into the character array pointed to by str not including the
 *   terminating '\0' on success. If count was reached before the entire string could be stored,
 *   ​0 is returned and the contents are undefined.
 * @see GLib.Time.strptime
 * @see GLib.Time.format
 */
GLib.Time.strftime

/**
 * Parse a time/date generated with {@link GLib.Time.strftime} or {@link GLib.Time.format}
 *
 * @param buf the string to parse
 * @param format the expected format. See {@link GLib.Time.format} for details.
 * @return a pointer to the character following the last parsed character, or null on failure.
 * @see GLib.Time.strftime
 * @see GLib.Time.format
 */
GLib.Time.strptime



/**
 * Selects the entire C locale
 */
GLib.LocaleCategory.ALL

/**
 * Selects the collation category of the C locale
 */
GLib.LocaleCategory.COLLATE

/**
 * Selects the character classification category of the C locale
 */
GLib.LocaleCategory.CTYPE

/**
 * Selects the monetary formatting category of the C locale
 */
GLib.LocaleCategory.MONETARY

/**
 * The language that should be used. 
 */
GLib.LocaleCategory.MESSAGES

/**
 * Selects the numeric formatting category of the C locale
 */
GLib.LocaleCategory.NUMERIC

/**
 * Selects the time formatting category of the C locale 
 */
GLib.LocaleCategory.TIME


/**
 * Used to control a I/O stream 
 */
GLib.FileStream

/**
 * Used to indicate that the end of file has been reached.
 */
GLib.FileStream.EOF

/**
 * Opens a file indicated by a filename.
 *
 * Mode is used to determine the file access mode. 
 * 
 * || ''Mode:'' || ''Meaning:'' || ''Explanation:'' || ''File already exists:'' || ''File does not exist:'' ||
 * || "r" || read || Open a file for reading || read from start || failure to open ||
 * || "w" || write || Create a file for writing || destroy contents || create new ||
 * || "a" || append || Append to a file || write to end || create new ||
 * || "r+" || read extended || Open a file for read/write || read from start || error ||
 * || "w+" || write extended || Create a file for read/write || destroy contents || create new ||
 * || "a+" || append extended || Open a file for read/write || write to end || create new ||
 *
 * File access mode flag "b" can optionally be specified to open a file in binary mode. This flag
 * has effect only on Windows systems.
 *
 * On the append file access modes, data is written to the end of the file regardless of the current
 * position of the file position indicator. 
 *
 * @param path file name to associate the file stream to 
 * @param mode character string determining file access mode
 * @return opened file stream on success, ``null`` on failure
 */
GLib.FileStream.open

/**
 * Opens a file indicated by a file descriptor.
 *
 * Mode is used to determine the file access mode. 
 *
 * @param fildes file descriptor to associate the file stream
 * @param mode character string determining file access mode (See {@link GLib.FileStream.open} for details)
 * @return opened file stream on success, ``null`` on failure
 */
GLib.FileStream.fdopen

/**
 * Writes the results to a file stream stream.
 *
 * The format string consists of whitespace characters, non-whitespace characters (except %) and
 * conversion specifications. Each conversion specification has the following format: 
 *
 * {{{%[flags][width][.precision][length]specifier}}}
 *
 * ''Flags:''
 *
 * || ''Character'' || ''Description'' ||
 * || + || The sign of signed conversions is always prepended to the result of the conversion ||
 * || <space> || if the result of a signed conversion does not start with a sign character, or is empty, space is prepended to the result. It is ignored if + flag is present. ||
 * || - || The result of the conversion is left-justified within the field ||
 * || # || Alternative form of the conversion is performed. ||
 * || 0 || Use 0 instead of spaces for padding when width is specified ||
 *
 * ''Width:''
 *
 * Integer value or * that specifies minimum field width. The result is padded with space characters (by default),
 * if required, on the left when right-justified, or on the right if left-justified. In the case when * is used,
 * the width is specified by an additional argument of type int. If the value of the argument is negative, it
 * results with the - flag specified and positive field width. 
 *
 * ''Precision:''
 *
 * . followed by integer number or * that specifies precision of the conversion. In the case when * is used, the precision is specified by an additional
 * argument of type int. If the value of this argument is negative, it is ignored. 
 *
 * ''Length:''
 *
 * || ''Character'' || ''Description'' ||
 * || hh || char ||
 * || h || short ||
 * || l || long ||
 * || ll || long-long ||
 * || L || long double ||
 * || z || sizue_t ||
 * || j || intmax_t ||
 * || t || ptrdiff_t ||
 *
 * ''Specifier:''
 *
 * || ''specifier'' || ''Output'' || ''Example'' ||
 * || a || Floating point, hexadecimal, lowercase || -0xc.90fep-2 ||
 * || A || Floating point, hexadecimal, uppercase || -0XC.90FEP-2 ||
 * || c || Character || c ||
 * || d, i || integer || 251 ||
 * || e || Mantissa/exponent (scientific), lowercase || 2.5121e+2 ||
 * || E || Mantissa/exponent (scientific), uppercase || 2.5121E+2 ||
 * || f || Floating point, decimal, lowercase || 2.32 ||
 * || F || Floating point, decimal, uppercase || 2.32 ||
 * || g || Floating point, shortest representation (%e or %f) || 512.23 ||
 * || G || Floating point, shortest representation (%E or %F) || 512.23 ||
 * || n || Nothing || ||
 * || o || Octal || 320 ||
 * || p || Pointer address || b2010020 ||
 * || s || String || my str ||
 * || u || Decimal integer || 93535 ||
 * || x || Integer, hexadecimal, lowercase || 3ab ||
 * || X || Integer, hexadecimal, uppercase || 3AB ||
 * || % || %% to output % || % ||
 *
 * ''Examples:''
 *
 * || ''Format:'' || ''Parameters:'' || ''Output:'' ||
 * || "Characters:\t%c %%\n" || 65 || "Characters: A %" ||
 * || "Decimal:\t%i %d %.6i %i %.0i %+i %u\n" ||  1, 2, 3, 0, 0, 4, -1 || "Decimal: 1 2 000003 0  +4 4294967295" ||
 * || "Hexadecimal:\t%x %x %X %#x\n" ||  5, 10, 10, 6 || "Hexadecimal: 5 a A 0x6" ||
 * || "Octal:\t%o %#o %#o\n" || 10, 10, 4 || "Octal: 12 012 04" ||
 * || "Rounding:\t%f %.0f %.32f\n" || 1.5, 1.5, 1.3 || "Rounding: 1.500000 2 1.30000000626" ||
 * || "Padding:\t%05.2f %.2f %5.2f\n" || 1.5, 1.5, 1.5 || "Padding: 01.50 1.50  1.50" ||
 * || "Scientific:\t%E %e\n" || 1.5, 1.5 || "Scientific: 1.500000E+00 1.500000e+00" ||
 * || "Hexadecimal:\t%a %A\n" || 1.5, 1.5 || "Hexadecimal: 0x1.8p+0 0X1.8P+0" ||
 *
 * @param format a string specifying how to interpret the data. (See {@link GLib.FileStream.printf})
 * @param ... variable argument list containing the data to print.
 */
GLib.FileStream.printf

/**
 * Loads the data from the locations, defined by vlist, converts them to character string
 * equivalents and writes the results to a variety of sinks. 
 *
 * @param format a string specifying how to interpret the data. (See {@link GLib.FileStream.printf})
 * @param args variable argument list containing the data to print.
 */
GLib.FileStream.vprintf

/**
 * Reads the data from stream.
 *
 * @param format character string specifying how to read the input (See {@link GLib.FileStream.printf})
 * @param ... receiving arguments 
 */
GLib.FileStream.scanf

/**
 * Writes a character ``c`` to the given output stream stream.
 *
 * @param c character to be written 
 * @return c on success, {@link GLib.FileStream.EOF} on failure. 
 */
GLib.FileStream.putc

/**
 * Writes string ``s`` to the given output stream 
 *
 * @param s string to be written 
 * @return non-negative number on success or {@link GLib.FileStream.EOF} otherwise 
 */
GLib.FileStream.puts

/**
 * Reads the next character from the given input stream.
 *
 * @return next character from the stream or {@link GLib.FileStream.EOF} if an error
 *   has occurred or the end of file has been reached. 
 */
GLib.FileStream.getc

/**
 * Puts the character ch back to the given file stream.
 *
 * @param c character to be put back
 * @return buf on success, ``null`` on an error 
 */
GLib.FileStream.ungetc

/**
 * Reads at most ``s.length - 1`` characters from the given file stream and stores them in ``s``.
 *
 * The produced character string is always ``null``-terminated. Parsing stops if end-of-file
 * occurs or a newline character is found, in which case str will contain that newline character. 
 *
 * @param s buf to read the characters to 
 * @return buf on success, ``null`` on an error 
 */
GLib.FileStream.gets

/**
 * Checks if the end of the given file stream has been reached.
 *
 * This function only reports the stream state as reported by the most recent I/O operation,
 * it does not examine the associated data source. For example, if the most recent I/O was a
 * {@link GLib.FileStream.getc}, which returned the last byte of a file, {@link GLib.FileStream.eof}
 * returns non-zero. The next {@link GLib.FileStream.getc} fails and changes the stream state
 * to end-of-file. Only then feof returns zero.
 *
 * In typical usage, input stream processing stops on any error; {@link GLib.FileStream.eof} and
 * {@link GLib.FileStream.error} are then used to distinguish between different error conditions. 
 */
GLib.FileStream.eof

/**
 * Causes the output file stream to be synchronized with the actual contents of the file.
 *
 * If the given stream is of the input type, then the behavior of the function is undefined. 
 *
 * @return Returns zero on success. Otherwise EOF is returned and the error indicator of the
 *   file stream is set. 
 */
GLib.FileStream.flush

/**
 * Sets the file position indicator for the file stream stream to the value pointed to by offset.
 *
 * This function can be used to set the indicator beyond the actual end of the file, however,
 * negative position values are not accepted.
 *
 * For text streams, the only valid values of offset are 0​ (applicable to any origin) and a value
 * returned by an earlier call to ftell (only applicable to {@link c::SEEK_SET}).
 *
 * @param offset number of characters to shift the position relative to origin
 * @param whence position to which offset is added.
 * @return ​0 upon success, nonzero value otherwise. Associated {@link GLib.FileStream.EOF}
 *   flag is cleared for the stream and the effect of any ungetc is undone.
 */
GLib.FileStream.seek

/**
 * Returns the file position indicator for the file stream stream.
 *
 * @return file position indicator on success or {@link GLib.FileStream.EOF} if failure occurs. 
 */
GLib.FileStream.tell

/**
 * Moves the file position indicator to the beginning of the given file stream.
 *
 * EOF and error flags are also cleared.
 */
GLib.FileStream.rewind

/**
 * Returns the file descriptor for a open file.
 */
GLib.FileStream.fileno

/**
 * Checks the given stream for errors.
 *
 * @return nonzero value if the file stream has errors occurred, 0 otherwise
 */
GLib.FileStream.error

/**
 * Resets the error flags and the {@link GLib.FileStream.EOF} indicator for the given file stream. 
 */
GLib.FileStream.clearerr

/**
 * Reads specified number of objects in the array buffer from the given input stream stream.
 * 
 * @param buf pointer to the first object object in the array to be read
 * @param size the element's size, this is always sizeof(uint8) or 1
 * @return number of objects read successfully 
 */
GLib.FileStream.read

/**
 * Writes count of objects in the given array buffer to the output stream stream. 
 *
 * @param buf pointer to the first object object in the array to be written
 * @param size the element's size, this is always sizeof(uint8) or 1
 * @return number of objects written successfully
 */
GLib.FileStream.write

/**
 * Reads a line, including any line terminating character(s), from a FileStream. Returns a newly-allocated string containing the line, excluding any line terminator.
 */
GLib.FileStream.read_line



/**
 * Specifies access and modification times for a files
 */
GLib.UTimBuf

/**
 * Access time
 */
GLib.UTimBuf.actime

/**
 * Modification time
 */
GLib.UTimBuf.modtime




/**
 * Installs the specified system locale or its portion as the new C locale.
 *
 * The modifications remain in effect and influences the execution of all
 * locale-sensitive C library functions until the next call to setlocale.
 * If locale is a null pointer, setlocale queries the current C locale
 * without modifying it. 
 *
 * @param category locale category identifier, one of the {@link GLib.LocaleCategory} macros. 
 * @param locale  system-specific locale identifier. Can be "" for
 *    the user-preferred locale or "C" for the minimal locale 
 * @return Pointer to a string identifying the C locale after applying
 *    the changes, if any, or null pointer on failure. 
 */
GLib.Intl.setlocale



/**
 * Converts the value to its equivalent string representation
 *
 * Format: "%FT%H:%M:%S%z"
 */
GLib.DateTime.to_string



/**
 * Returns true if the child process terminated normally
 */
GLib.Process.if_exited

/**
 * Returns true if the child process terminated because of an unhalded signal.
 */
GLib.Process.if_signaled

/**
 * Returns true if the child process exited and triggered a core dump
 */
GLib.Process.core_dump

/**
 * Returns the signal number of the signal caused the child process to stop when
 * {@link GLib.Process.if_stopped} is true
 */
GLib.Process.stop_sig

/**
 * Returns a true if the child process stopped. 
 */
GLib.Process.if_stopped

/**
 * Returns true if the status was returned for a child process that has continued. 
 *
 * Warning: {@link GLib.Process.if_continued} is an XSI extension and is not available
 *   on all systems.
 */
GLib.Process.if_continued

/**
 * Returns the exit status if the process exited
 */
GLib.Process.exit_status

/**
 * Returns the ID of the signal that forced the child process to terminate.
 */
GLib.Process.term_sig

/**
 * Causes abnormal program termination unless {@link c::SIGABRT} is being caught by a signal
 * handler passed to signal and the handler does not return.
 *
 * Functions, passed to {@link c::atexit} are not called. Whether open resources such as files
 * are closed is implementation defined. Implementation defined status is returned to the host
 * environment that indicates unsuccessful execution. 
 */
GLib.Process.abort

/**
 * Causes normal program termination to occur.
 *
 * Several cleanup steps are performed:
 *
 *  * functions passed to {@link c::atexit} are called.
 *  * all C streams are flushed and closed
 *  * files created by tmpfile are removed
 *  * control is returned to the host environment.
 *
 * If exit_code is {@link c::EXIT_SUCCESS}, an implementation-defined status, indicating 
 * successful termination is returned. If exit_code is {@link c::EXIT_FAILURE}, an
 * implementation-defined status, indicating unsuccessful termination is returned.
 * In other cases implementation-defined status value is returned. 
 *
 * @param status exit status of the program
 */
GLib.Process.exit

/**
 * Sends signal sig to the program.
 *
 * The signal handler, specified using {@link c::signal} is invoked.
 *
 * If the user-defined signal handling strategy is not set using {@link c::signal} yet,
 * it is implementation-defined whether the signal will be ignored or default handler
 * will be invoked. 
 *
 * @param sig the signal to be sent.
 * @return 0 upon success, non-zero value on failure.
 */
GLib.Process.raise

/**
 * Sets the error handler for signal sig.
 *
 * The signal handler can be set so that default handling will occur, signal is ignored,
 * or an user-defined function is called.
 *
 * When signal handler is set to a function and a signal occurs, it is implementation
 * defined whether {@link c::signal} (sig, {@link c::SIG_DFL}) will be executed immediately
 * before the start of signal handler. Also, the implementation can prevent some
 * implementation-defined set af signals from occurring while the signal handler runs.
 *
 * If the user defined function returns when handling {@link c::SIGFPE}, {@link c::SIGILL}
 * or {@link c::SIGSEGV}, the behavior is undefined. In most implementations the program
 * terminates.
 *
 * If the signal handler is called as a result of abort or raise, the behavior is undefined
 * if any of the following requirements is not followed: 
 *
 *  * the signal handler calls {@link c::raise}.
 *  * the signal handler refers to an object of static storage duration which is not declared
 *    as volatile sig_atomic_t.
 *  * the signal handler calls any function within the standard library, except {@link c::abort},
 *    {@link c::_Exit}, or {@link c::signal} with the first argument not being the number of the
 *    signal currently handled. 
 */
GLib.Process.signal


/**
 * The string as a sequence of bytes
 */
GLib.StringBuilder.data



/**
 * Sorts the array, using ``compare_func``
 *
 * @param compare_func a comparison function, qsort-style, without a target
 */
GLib.GenericArray.sort

/**
 * Sorts the array, using ``compare_func``
 *
 * @param compare_func a comparison function, qsort-style, with a target
 */
GLib.GenericArray.sort_with_data

/**
 * Number of pointers in the array.
 */
GLib.GenericArray.length


/**
 * Returns the byte at the given index
 *
 * @param index index of the desired byte
 * @return the selected byte
 */
GLib.Bytes.get

/**
 * Extracts bytes from {@link GLib.Bytes} and returns it.
 *
 * @param start the zero-based index at which to begin extraction.
 * @param end the zero-based index at which to end extraction.
 * @return a newly-allocated {@link GLib.Bytes}.
 */
GLib.Bytes.slice

/**
 * The size of the byte data in the {@link GLib.Bytes}.
 */
GLib.Bytes.length



/**
 * Unlinks a {@link GLib.Node} from a tree, resulting in two separate trees.
 */
GLib.Node.unlink

/**
 * Unlinks a {@link GLib.Node} from a tree, resulting in two separate trees.
 *
 * Warning: This function may lead to memory leaks when you don't free the
 *    node on your own!
 *
 * @see GLib.Node.unlink
 */
GLib.Node._unlink



/**
 * The input stream
 */
GLib.stdin

/**
 * The output stream
 */
GLib.stdout

/**
 * The error stream
 */
GLib.stderr


/**
 * {@link GLib.FileUtils.close} closes a file descriptor, so that it no longer refers to any file and may be reused.
 * 
 * Any record locks held on the file it was associated with, and owned by the process, are removed (regardless of the file descriptor that was used to obtain the lock).
 * 
 * If fd is the last copy of a particular file descriptor the resources associated with it are freed; if the descriptor was the last reference to a file which has been removed using {@link GLib.FileUtils.unlink} the file is deleted. 
 * 
 * @return returns zero on success. On error, -1 is returned, and {@link GLib.errno} is set appropriately.
 * @see c::EBADF
 * @see c::EINTR
 * @see c::EIO
 */
GLib.FileUtils.close

/**
 * Creates a symbolic link
 *
 * @param oldpath Target of the link.
 * @param newpath The link name.
 * @return successful 0; otherwise, -1 and set errno to indicate the error.
 */
GLib.FileUtils.symlink
