/*
 * MATH.C
 */

#include "defs.h"

/*
 * r = pow(val, exp)
 */
void
RUNESYSCALL(pow_Float32) (float32_t *val, float32_t *rval)
{
    *rval = powf(val[0], val[1]);
}

void
RUNESYSCALL(pow_Float64) (float64_t *val, float64_t *rval)
{
    *rval = pow(val[0], val[1]);
}

void
RUNESYSCALL(pow_Float128) (float128_t *val, float128_t *rval)
{
    *rval = powl(val[0], val[1]);
}

/*
 * r = exp * (val);
 */
void
RUNESYSCALL(exp_Float32) (float32_t *val, float32_t *rval)
{
    *rval = expf(*val);
}

void
RUNESYSCALL(exp_Float64) (float64_t *val, float64_t *rval)
{
    *rval = exp(*val);
}

void
RUNESYSCALL(exp_Float128) (float128_t *val, float128_t *rval)
{
    *rval = expl(*val);
}

void
RUNESYSCALL(exp2_Float32) (float32_t *val, float32_t *rval)
{
    *rval = exp2f(*val);
}

void
RUNESYSCALL(exp2_Float64) (float64_t *val, float64_t *rval)
{
    *rval = exp2(*val);
}

void
RUNESYSCALL(exp2_Float128) (float128_t *val, float128_t *rval)
{
    *rval = exp2l(*val);
}

void
RUNESYSCALL(expm1_Float32) (float32_t *val, float32_t *rval)
{
    *rval = expm1f(*val);
}

void
RUNESYSCALL(expm1_Float64) (float64_t *val, float64_t *rval)
{
    *rval = expm1(*val);
}

void
RUNESYSCALL(expm1_Float128) (float128_t *val, float128_t *rval)
{
    *rval = expm1l(*val);
}

/*
 * r = log * (val)
 */
void
RUNESYSCALL(log_Float32) (float32_t *val, float32_t *rval)
{
    *rval = logf(*val);
}

void
RUNESYSCALL(log_Float64) (float64_t *val, float64_t *rval)
{
    *rval = log(*val);
}

void
RUNESYSCALL(log_Float128) (float128_t *val, float128_t *rval)
{
    *rval = logl(*val);
}

void
RUNESYSCALL(log1p_Float32) (float32_t *val, float32_t *rval)
{
    *rval = log1pf(*val);
}

void
RUNESYSCALL(log1p_Float64) (float64_t *val, float64_t *rval)
{
    *rval = log1p(*val);
}

void
RUNESYSCALL(log1p_Float128) (float128_t *val, float128_t *rval)
{
    *rval = log1pl(*val);
}

void
RUNESYSCALL(log2_Float32) (float32_t *val, float32_t *rval)
{
    *rval = log2f(*val);
}

void
RUNESYSCALL(log2_Float64) (float64_t *val, float64_t *rval)
{
    *rval = log2(*val);
}

void
RUNESYSCALL(log2_Float128) (float128_t *val, float128_t *rval)
{
    *rval = log2l(*val);
}

void
RUNESYSCALL(log10_Float32) (float32_t *val, float32_t *rval)
{
    *rval = log10f(*val);
}

void
RUNESYSCALL(log10_Float64) (float64_t *val, float64_t *rval)
{
    *rval = log10(*val);
}

void
RUNESYSCALL(log10_Float128) (float128_t *val, float128_t *rval)
{
    *rval = log10l(*val);
}

/*
 * int ilogb(val)
 */

void
RUNESYSCALL(ilogb_Float32) (float32_t *val, int32_t *rval)
{
    *rval = ilogbf(*val);
}

void
RUNESYSCALL(ilogb_Float64) (float64_t *val, int32_t *rval)
{
    *rval = ilogb(*val);
}

void
RUNESYSCALL(ilogb_Float128) (float128_t *val, int32_t *rval)
{
    *rval = ilogbl(*val);
}


void
RUNESYSCALL(frexp_Float32) (float32_t *val, frexp_float32_res_t *rval)
{
    rval->mant = frexpf(*val, &rval->exp2);
}

void
RUNESYSCALL(frexp_Float64) (float64_t *val, frexp_float64_res_t *rval)
{
    rval->mant = frexp(*val, &rval->exp2);
}

void
RUNESYSCALL(frexp_Float128) (float128_t *val, frexp_float128_res_t *rval)
{
    rval->mant = frexpl(*val, &rval->exp2);
}


void
RUNESYSCALL(sin_Float32) (float32_t *val, float32_t *rval)
{
    *rval = sinf(*val);
}

void
RUNESYSCALL(sin_Float64) (float64_t *val, float64_t *rval)
{
    *rval = sin(*val);
}

void
RUNESYSCALL(sin_Float128) (float128_t *val, float128_t *rval)
{
    *rval = sinl(*val);
}

void
RUNESYSCALL(cos_Float32) (float32_t *val, float32_t *rval)
{
    *rval = cosf(*val);
}

void
RUNESYSCALL(cos_Float64) (float64_t *val, float64_t *rval)
{
    *rval = cos(*val);
}

void
RUNESYSCALL(cos_Float128) (float128_t *val, float128_t *rval)
{
    *rval = cosl(*val);
}

void
RUNESYSCALL(tan_Float32) (float32_t *val, float32_t *rval)
{
    *rval = tanf(*val);
}

void
RUNESYSCALL(tan_Float64) (float64_t *val, float64_t *rval)
{
    *rval = tan(*val);
}

void
RUNESYSCALL(tan_Float128) (float128_t *val, float128_t *rval)
{
    *rval = tanl(*val);
}

void
RUNESYSCALL(asin_Float32) (float32_t *val, float32_t *rval)
{
    *rval = asinf(*val);
}

void
RUNESYSCALL(asin_Float64) (float64_t *val, float64_t *rval)
{
    *rval = asin(*val);
}

void
RUNESYSCALL(asin_Float128) (float128_t *val, float128_t *rval)
{
    *rval = asinl(*val);
}

void
RUNESYSCALL(acos_Float32) (float32_t *val, float32_t *rval)
{
    *rval = acosf(*val);
}

void
RUNESYSCALL(acos_Float64) (float64_t *val, float64_t *rval)
{
    *rval = acos(*val);
}

void
RUNESYSCALL(acos_Float128) (float128_t *val, float128_t *rval)
{
    *rval = acosl(*val);
}

void
RUNESYSCALL(atan_Float32) (float32_t *val, float32_t *rval)
{
    *rval = atanf(*val);
}

void
RUNESYSCALL(atan_Float64) (float64_t *val, float64_t *rval)
{
    *rval = atan(*val);
}

void
RUNESYSCALL(atan_Float128) (float128_t *val, float128_t *rval)
{
    *rval = atanl(*val);
}

void
RUNESYSCALL(atan2_Float32) (float32_t *val, float32_t *rval)
{
    *rval = atan2f(val[0], val[1]);
}

void
RUNESYSCALL(atan2_Float64) (float64_t *val, float64_t *rval)
{
    *rval = atan2(val[0], val[1]);
}

void
RUNESYSCALL(atan2_Float128) (float128_t *val, float128_t *rval)
{
    *rval = atan2l(val[0], val[1]);
}

void
RUNESYSCALL(sinh_Float32) (float32_t *val, float32_t *rval)
{
    *rval = sinhf(*val);
}

void
RUNESYSCALL(sinh_Float64) (float64_t *val, float64_t *rval)
{
    *rval = sinh(*val);
}

void
RUNESYSCALL(sinh_Float128) (float128_t *val, float128_t *rval)
{
    *rval = sinhl(*val);
}

void
RUNESYSCALL(cosh_Float32) (float32_t *val, float32_t *rval)
{
    *rval = coshf(*val);
}

void
RUNESYSCALL(cosh_Float64) (float64_t *val, float64_t *rval)
{
    *rval = cosh(*val);
}

void
RUNESYSCALL(cosh_Float128) (float128_t *val, float128_t *rval)
{
    *rval = coshl(*val);
}