path: root/src/libmath/basic.c

#include <u.h>
#include <base.h>
#include <libmath.h>

#include <math.h>

// TODO(nnoll): Replace implementations with your own.

double
math·acos(double x)
{
    return acos(x);
}

float
math·acosf(float x)
{
    return acosf(x);
}


double
math·acosh(double x)
{
    return acosh(x);
}

float
math·acoshf(float x)
{
    return acoshf(x);
}


double
math·asin(double x)
{
    return asin(x);
}

float
math·asinf(float x)
{
    return asinf(x);
}


double
math·asinh(double x)
{
    return asinh(x);
}

float
math·asinhf(float x)
{
    return asinhf(x);
}


double
math·atan(double x)
{
    return atan(x);
}

float
math·atanf(float x)
{
    return atanf(x);
}


double
math·atan2(double x, double y)
{
    return atan2(x, y);
}

float
math·atan2f(float x, float y)
{
    return atan2f(x, y);
}

double
math·atanh(double x)
{
    return atanh(x);
}

float
math·atanhf(float x)
{
    return atanhf(x);
}


double
math·cbrt(double x)
{
    return cbrt(x);
}

float
math·cbrtf(float x)
{
    return cbrtf(x);
}


double
math·ceil(double x)
{
    return ceil(x);
}

float
math·ceilf(float x)
{
    return ceilf(x);
}

double
math·cos(double x)
{
    return cos(x);
}

float
math·cosf(float x)
{
    return cosf(x);
}


double
math·cosh(double x)
{
    return cosh(x);
}

float
math·coshf(float x)
{
    return coshf(x);
}


double
math·erf(double x)
{
    return erf(x);
}

float
math·erff(float x)
{
    return erff(x);
}


double
math·erfc(double x)
{
    return erfc(x);
}

float
math·erfcf(float x)
{
    return erfcf(x);
}


double
math·exp(double x)
{
    return exp(x);
}

float
math·expf(float x)
{
    return expf(x);
}


double
math·exp2(double x)
{
    return exp2(x);
}

float
math·exp2f(float x)
{
    return exp2f(x);
}


double
math·expm1(double x)
{
    return expm1(x);
}

float
math·expm1f(float x)
{
    return expm1f(x);
}


double
math·floor(double x)
{
    return floor(x);
}

float
math·floorf(float x)
{
    return floorf(x);
}


int
math·ilogb(double x)
{
    return ilogb(x);
}

int
math·ilogbf(float x)
{
    return ilogbf(x);
}

double
math·lgamma(double x)
{
    return lgamma(x);
}

float
math·lgammaf(float x)
{
    return lgammaf(x);
}


vlong   
math·llrint(double x)
{
      return math·llrint(x);
}

vlong
math·llrintf(float x)
{
      return math·llrintf(x);
}


vlong
math·llround(double x)
{
    return llround(x);
}

vlong
math·llroundf(float x)
{
    return llroundf(x);
}


double
math·log(double x)
{
    return log(x);
}

float
math·logf(float x)
{
    return logf(x);
}


double
math·log10(double x)
{
    return log10(x);
}

float
math·log10f(float x)
{
    return log10f(x);
}


double
math·log1p(double x)
{
    return log1p(x);
}

float
math·log1pf(float x)
{
    return log1pf(x);
}


double
math·log2(double x)
{
    return log2(x);
}

float
math·log2f(float x)
{
    return log2f(x);
}


double
math·logb(double x)
{
    return logb(x);
}

float
math·logbf(float x)
{
    return logbf(x);
}


long
math·lrint(double x)
{
    return lrint(x);
}

long
math·lrintf(float x)
{
    return lrintf(x);
}


long
math·lround(double x)
{
    return lround(x);
}

long
math·lroundf(float x)
{
    return lroundf(x);
}


double      math·modf(double, double *);
float       math·modff(float, float *);

double
math·nan(const char * x)
{
    return nan(x);
}

float
math·nanf(const char * x)
{
    return nanf(x);
}


double
math·nearbyint(double x)
{
    return nearbyint(x);
}

float
math·nearbyintf(float x)
{
    return nearbyintf(x);
}


double
math·pow(double x, double exp)
{
    return pow(x, exp);
}

float       
math·powf(float x, float exp)
{
    return powf(x, exp);
}

double
math·rint(double x)
{
    return rint(x);
}

float
math·rintf(float x)
{
    return rintf(x);
}


double
math·round(double x)
{
    return round(x);
}

float
math·roundf(float x)
{
    return roundf(x);
}


double      math·scalbln(double, long);
float       math·scalblnf(float, long);

double      math·scalbn(double, int);
float       math·scalbnf(float, int);

double
math·sin(double x)
{
    return sin(x);
}

float
math·sinf(float x)
{
    return sinf(x);
}


double
math·sinh(double x)
{
    return sinh(x);
}

float
math·sinhf(float x)
{
    return sinhf(x);
}


double
math·sqrt(double x)
{
    return sqrt(x);
}

float
math·sqrtf(float x)
{
    return sqrtf(x);
}


double
math·tan(double x)
{
    return tan(x);
}

float
math·tanf(float x)
{
    return tanf(x);
}


double
math·tanh(double x)
{
    return tanh(x);
}

float
math·tanhf(float x)
{
    return tanhf(x);
}


double
math·tgamma(double x)
{
    return tgamma(x);
}

float
math·tgammaf(float x)
{
    return tgammaf(x);
}


double
math·trunc(double x)
{
    return trunc(x);
}

float
math·truncf(float x)
{
    return truncf(x);
}