// D import file generated from '../../../../libphobos/libdruntime/core/stdc/math.d'
module core.stdc.math;
private import core.stdc.config;

extern (C) @trusted nothrow 
{
	alias float float_t;
	alias double double_t;
	enum double HUGE_VAL = (double).infinity;
	enum double HUGE_VALF = (float).infinity;
	enum double HUGE_VALL = (real).infinity;
	enum float INFINITY = (float).infinity;
	enum float NAN = (float).nan;
	enum int FP_ILOGB0 = (int).min;
	enum int FP_ILOGBNAN = (int).min;
	enum int MATH_ERRNO = 1;
	enum int MATH_ERREXCEPT = 2;
	enum int math_errhandling = MATH_ERRNO | MATH_ERREXCEPT;
	version (none)
	{
		int fpclassify(float x);
		int fpclassify(double x);
		int fpclassify(real x);
		int isfinite(float x);
		int isfinite(double x);
		int isfinite(real x);
		int isinf(float x);
		int isinf(double x);
		int isinf(real x);
		int isnan(float x);
		int isnan(double x);
		int isnan(real x);
		int isnormal(float x);
		int isnormal(double x);
		int isnormal(real x);
		int signbit(float x);
		int signbit(double x);
		int signbit(real x);
		int isgreater(float x, float y);
		int isgreater(double x, double y);
		int isgreater(real x, real y);
		int isgreaterequal(float x, float y);
		int isgreaterequal(double x, double y);
		int isgreaterequal(real x, real y);
		int isless(float x, float y);
		int isless(double x, double y);
		int isless(real x, real y);
		int islessequal(float x, float y);
		int islessequal(double x, double y);
		int islessequal(real x, real y);
		int islessgreater(float x, float y);
		int islessgreater(double x, double y);
		int islessgreater(real x, real y);
		int isunordered(float x, float y);
		int isunordered(double x, double y);
		int isunordered(real x, real y);
	}
	version (DigitalMars)
	{
		version (Win32)
		{
			version = DigitalMarsWin32;
		}
		version (Win64)
		{
			version = DigitalMarsWin64;
		}
	}
	version (DigitalMarsWin32)
	{
		enum 
		{
			FP_NANS = 0,
			FP_NANQ = 1,
			FP_INFINITE = 2,
			FP_NORMAL = 3,
			FP_SUBNORMAL = 4,
			FP_ZERO = 5,
			FP_NAN = FP_NANQ,
			FP_EMPTY = 6,
			FP_UNSUPPORTED = 7,
		}
		enum 
		{
			FP_FAST_FMA = 0,
			FP_FAST_FMAF = 0,
			FP_FAST_FMAL = 0,
		}
		uint __fpclassify_f(float x);
		uint __fpclassify_d(double x);
		uint __fpclassify_ld(real x);
		extern (D) 
		{
			int fpclassify(float x);
			int fpclassify(double x);
			int fpclassify(real x);
			int isfinite(float x);
			int isfinite(double x);
			int isfinite(real x);
			int isinf(float x);
			int isinf(double x);
			int isinf(real x);
			int isnan(float x);
			int isnan(double x);
			int isnan(real x);
			int isnormal(float x);
			int isnormal(double x);
			int isnormal(real x);
			int signbit(float x);
			int signbit(double x);
			int signbit(real x);
		}
	}
	else
	{
		version (DigitalMarsWin64)
		{
			enum 
			{
				_FPCLASS_SNAN = 1,
				_FPCLASS_QNAN = 2,
				_FPCLASS_NINF = 4,
				_FPCLASS_NN = 8,
				_FPCLASS_ND = 16,
				_FPCLASS_NZ = 32,
				_FPCLASS_PZ = 64,
				_FPCLASS_PD = 128,
				_FPCLASS_PN = 256,
				_FPCLASS_PINF = 512,
			}
			float _copysignf(float x, float s);
			float _chgsignf(float x);
			int _finitef(float x);
			int _isnanf(float x);
			int _fpclassf(float x);
			double _copysign(double x, double s);
			double _chgsign(double x);
			int _finite(double x);
			int _isnan(double x);
			int _fpclass(double x);
			extern (D) 
			{
				int isnan(float x);
				int isnan(double x);
				int isnan(real x);
			}
		}
		else
		{
			version (linux)
			{
				enum 
				{
					FP_NAN,
					FP_INFINITE,
					FP_ZERO,
					FP_SUBNORMAL,
					FP_NORMAL,
				}
				enum 
				{
					FP_FAST_FMA = 0,
					FP_FAST_FMAF = 0,
					FP_FAST_FMAL = 0,
				}
				int __fpclassifyf(float x);
				int __fpclassify(double x);
				int __fpclassifyl(real x);
				int __finitef(float x);
				int __finite(double x);
				int __finitel(real x);
				int __isinff(float x);
				int __isinf(double x);
				int __isinfl(real x);
				int __isnanf(float x);
				int __isnan(double x);
				int __isnanl(real x);
				int __signbitf(float x);
				int __signbit(double x);
				int __signbitl(real x);
				extern (D) 
				{
					int fpclassify(float x);
					int fpclassify(double x);
					int fpclassify(real x);
					int isfinite(float x);
					int isfinite(double x);
					int isfinite(real x);
					int isinf(float x);
					int isinf(double x);
					int isinf(real x);
					int isnan(float x);
					int isnan(double x);
					int isnan(real x);
					int isnormal(float x);
					int isnormal(double x);
					int isnormal(real x);
					int signbit(float x);
					int signbit(double x);
					int signbit(real x);
				}
			}
			else
			{
				version (OSX)
				{
					enum 
					{
						FP_NAN = 1,
						FP_INFINITE = 2,
						FP_ZERO = 3,
						FP_NORMAL = 4,
						FP_SUBNORMAL = 5,
						FP_SUPERNORMAL = 6,
					}
					enum 
					{
						FP_FAST_FMA = 0,
						FP_FAST_FMAF = 0,
						FP_FAST_FMAL = 0,
					}
					int __fpclassifyf(float x);
					int __fpclassifyd(double x);
					int __fpclassify(real x);
					int __isfinitef(float x);
					int __isfinited(double x);
					int __isfinite(real x);
					int __isinff(float x);
					int __isinfd(double x);
					int __isinf(real x);
					int __isnanf(float x);
					int __isnand(double x);
					int __isnan(real x);
					int __signbitf(float x);
					int __signbitd(double x);
					int __signbitl(real x);
					extern (D) 
					{
						int fpclassify(float x);
						int fpclassify(double x);
						int fpclassify(real x);
						int isfinite(float x);
						int isfinite(double x);
						int isfinite(real x);
						int isinf(float x);
						int isinf(double x);
						int isinf(real x);
						int isnan(float x);
						int isnan(double x);
						int isnan(real x);
						int isnormal(float x);
						int isnormal(double x);
						int isnormal(real x);
						int signbit(float x);
						int signbit(double x);
						int signbit(real x);
					}
				}
				else
				{
					version (FreeBSD)
					{
						enum 
						{
							FP_INFINITE = 1,
							FP_NAN = 2,
							FP_NORMAL = 4,
							FP_SUBNORMAL = 8,
							FP_ZERO = 16,
						}
						enum 
						{
							FP_FAST_FMA = 0,
							FP_FAST_FMAF = 0,
							FP_FAST_FMAL = 0,
						}
						int __fpclassifyd(double);
						int __fpclassifyf(float);
						int __fpclassifyl(real);
						int __isfinitef(float);
						int __isfinite(double);
						int __isfinitel(real);
						int __isinff(float);
						int __isinfl(real);
						int __isnanl(real);
						int __isnormalf(float);
						int __isnormal(double);
						int __isnormall(real);
						int __signbit(double);
						int __signbitf(float);
						int __signbitl(real);
						extern (D) 
						{
							int fpclassify(float x);
							int fpclassify(double x);
							int fpclassify(real x);
							int isfinite(float x);
							int isfinite(double x);
							int isfinite(real x);
							int isinf(float x);
							int isinf(double x);
							int isinf(real x);
							int isnan(float x);
							int isnan(double x);
							int isnan(real x);
							int isnormal(float x);
							int isnormal(double x);
							int isnormal(real x);
							int signbit(float x);
							int signbit(double x);
							int signbit(real x);
						}
					}
				}
			}
		}
	}
	extern (D) 
	{
		int isgreater(float x, float y);
		int isgreater(double x, double y);
		int isgreater(real x, real y);
		int isgreaterequal(float x, float y);
		int isgreaterequal(double x, double y);
		int isgreaterequal(real x, real y);
		int isless(float x, float y);
		int isless(double x, double y);
		int isless(real x, real y);
		int islessequal(float x, float y);
		int islessequal(double x, double y);
		int islessequal(real x, real y);
		int islessgreater(float x, float y);
		int islessgreater(double x, double y);
		int islessgreater(real x, real y);
		int isunordered(float x, float y);
		int isunordered(double x, double y);
		int isunordered(real x, real y);
	}
	version (FreeBSD)
	{
		version (none)
		{
			pure real acosl(real x);

			pure real asinl(real x);

			pure real atanl(real x);

			pure real atan2l(real y, real x);

			pure real cosl(real x);

			pure real sinl(real x);

			pure real tanl(real x);

			pure real exp2l(real x);

			real frexpl(real value, int* exp);
			pure int ilogbl(real x);

			pure real ldexpl(real x, int exp);

			pure real logbl(real x);

			pure real scalbnl(real x, int n);

			pure real scalblnl(real x, c_long n);

			pure real fabsl(real x);

			pure real hypotl(real x, real y);

			pure real sqrtl(real x);

			pure real ceill(real x);

			pure real floorl(real x);

			pure real nearbyintl(real x);

			pure real rintl(real x);

			pure c_long lrintl(real x);

			pure real roundl(real x);

			pure c_long lroundl(real x);

			pure long llroundl(real x);

			pure real truncl(real x);

			pure real fmodl(real x, real y);

			pure real remainderl(real x, real y);

			real remquol(real x, real y, int* quo);
			pure real copysignl(real x, real y);

			pure real nextafterl(real x, real y);

			pure real nexttowardl(real x, real y);

			pure real fdiml(real x, real y);

			pure real fmaxl(real x, real y);

			pure real fminl(real x, real y);

			pure real fmal(real x, real y, real z);

		}
		else
		{
			pure real acosl(real x);

			pure real asinl(real x);

			pure real atanl(real x);

			pure real atan2l(real y, real x);

			pure real cosl(real x);

			pure real sinl(real x);

			pure real tanl(real x);

			pure real exp2l(real x);

			real frexpl(real value, int* exp);
			pure int ilogbl(real x);

			pure real ldexpl(real x, int exp);

			pure real logbl(real x);

			pure real modfl(real value, real* iptr);

			pure real scalbnl(real x, int n);

			pure real scalblnl(real x, c_long n);

			pure real fabsl(real x);

			pure real hypotl(real x, real y);

			pure real sqrtl(real x);

			pure real ceill(real x);

			pure real floorl(real x);

			pure real nearbyintl(real x);

			pure real rintl(real x);

			pure c_long lrintl(real x);

			pure real roundl(real x);

			pure c_long lroundl(real x);

			pure long llroundl(real x);

			pure real truncl(real x);

			pure real fmodl(real x, real y);

			pure real remainderl(real x, real y);

			real remquol(real x, real y, int* quo);
			pure real copysignl(real x, real y);

			pure double nan(char* tagp);

			pure float nanf(char* tagp);

			pure real nanl(char* tagp);

			pure real nextafterl(real x, real y);

			pure real nexttowardl(real x, real y);

			pure real fdiml(real x, real y);

			pure real fmaxl(real x, real y);

			pure real fminl(real x, real y);

			pure real fmal(real x, real y, real z);

		}
		pure double acos(double x);

		pure float acosf(float x);

		pure double asin(double x);

		pure float asinf(float x);

		pure double atan(double x);

		pure float atanf(float x);

		pure double atan2(double y, double x);

		pure float atan2f(float y, float x);

		pure double cos(double x);

		pure float cosf(float x);

		pure double sin(double x);

		pure float sinf(float x);

		pure double tan(double x);

		pure float tanf(float x);

		pure double acosh(double x);

		pure float acoshf(float x);

		pure real acoshl(real x);

		pure double asinh(double x);

		pure float asinhf(float x);

		pure real asinhl(real x);

		pure double atanh(double x);

		pure float atanhf(float x);

		pure real atanhl(real x);

		pure double cosh(double x);

		pure float coshf(float x);

		pure real coshl(real x);

		pure double sinh(double x);

		pure float sinhf(float x);

		pure real sinhl(real x);

		pure double tanh(double x);

		pure float tanhf(float x);

		pure real tanhl(real x);

		pure double exp(double x);

		pure float expf(float x);

		pure real expl(real x);

		pure double exp2(double x);

		pure float exp2f(float x);

		pure double expm1(double x);

		pure float expm1f(float x);

		pure real expm1l(real x);

		double frexp(double value, int* exp);
		float frexpf(float value, int* exp);
		pure int ilogb(double x);

		pure int ilogbf(float x);

		pure double ldexp(double x, int exp);

		pure float ldexpf(float x, int exp);

		pure double log(double x);

		pure float logf(float x);

		pure real logl(real x);

		pure double log10(double x);

		pure float log10f(float x);

		pure real log10l(real x);

		pure double log1p(double x);

		pure float log1pf(float x);

		pure real log1pl(real x);

		private enum real ONE_LN2 = 1 / 0x0.b17217f7d1cf79acp+0L;

		pure double log2(double x);

		pure float log2f(float x);

		pure real log2l(real x);

		pure double logb(double x);

		pure float logbf(float x);

		pure double modf(double value, double* iptr);

		pure float modff(float value, float* iptr);

		pure double scalbn(double x, int n);

		pure float scalbnf(float x, int n);

		double scalbln(double x, c_long n);
		float scalblnf(float x, c_long n);
		pure double cbrt(double x);

		pure float cbrtf(float x);

		pure real cbrtl(real x);

		pure double fabs(double x);

		pure float fabsf(float x);

		pure double hypot(double x, double y);

		pure float hypotf(float x, float y);

		pure double pow(double x, double y);

		pure float powf(float x, float y);

		pure real powl(real x, real y);

		pure double sqrt(double x);

		pure float sqrtf(float x);

		pure double erf(double x);

		pure float erff(float x);

		pure real erfl(real x);

		pure double erfc(double x);

		pure float erfcf(float x);

		pure real erfcl(real x);

		double lgamma(double x);
		float lgammaf(float x);
		real lgammal(real x);
		pure double tgamma(double x);

		pure float tgammaf(float x);

		pure real tgammal(real x);

		pure double ceil(double x);

		pure float ceilf(float x);

		pure double floor(double x);

		pure float floorf(float x);

		pure double nearbyint(double x);

		pure float nearbyintf(float x);

		pure double rint(double x);

		pure float rintf(float x);

		pure c_long lrint(double x);

		pure c_long lrintf(float x);

		pure long llrint(double x);

		pure long llrintf(float x);

		pure long llrintl(real x);

		pure double round(double x);

		pure float roundf(float x);

		pure c_long lround(double x);

		pure c_long lroundf(float x);

		pure long llround(double x);

		pure long llroundf(float x);

		pure double trunc(double x);

		pure float truncf(float x);

		pure double fmod(double x, double y);

		pure float fmodf(float x, float y);

		pure double remainder(double x, double y);

		pure float remainderf(float x, float y);

		double remquo(double x, double y, int* quo);
		float remquof(float x, float y, int* quo);
		pure double copysign(double x, double y);

		pure float copysignf(float x, float y);

		pure double nextafter(double x, double y);

		pure float nextafterf(float x, float y);

		pure double nexttoward(double x, real y);

		pure float nexttowardf(float x, real y);

		pure double fdim(double x, double y);

		pure float fdimf(float x, float y);

		pure double fmax(double x, double y);

		pure float fmaxf(float x, float y);

		pure double fmin(double x, double y);

		pure float fminf(float x, float y);

		pure double fma(double x, double y, double z);

		pure float fmaf(float x, float y, float z);

	}
	else
	{
		pure double acos(double x);

		pure float acosf(float x);

		pure real acosl(real x);

		pure double asin(double x);

		pure float asinf(float x);

		pure real asinl(real x);

		pure double atan(double x);

		pure float atanf(float x);

		pure real atanl(real x);

		pure double atan2(double y, double x);

		pure float atan2f(float y, float x);

		pure real atan2l(real y, real x);

		pure double cos(double x);

		pure float cosf(float x);

		pure real cosl(real x);

		pure double sin(double x);

		pure float sinf(float x);

		pure real sinl(real x);

		pure double tan(double x);

		pure float tanf(float x);

		pure real tanl(real x);

		pure double acosh(double x);

		pure float acoshf(float x);

		pure real acoshl(real x);

		pure double asinh(double x);

		pure float asinhf(float x);

		pure real asinhl(real x);

		pure double atanh(double x);

		pure float atanhf(float x);

		pure real atanhl(real x);

		pure double cosh(double x);

		pure float coshf(float x);

		pure real coshl(real x);

		pure double sinh(double x);

		pure float sinhf(float x);

		pure real sinhl(real x);

		pure double tanh(double x);

		pure float tanhf(float x);

		pure real tanhl(real x);

		pure double exp(double x);

		pure float expf(float x);

		pure real expl(real x);

		pure double exp2(double x);

		pure float exp2f(float x);

		pure real exp2l(real x);

		pure double expm1(double x);

		pure float expm1f(float x);

		pure real expm1l(real x);

		double frexp(double value, int* exp);
		float frexpf(float value, int* exp);
		real frexpl(real value, int* exp);
		pure int ilogb(double x);

		pure int ilogbf(float x);

		pure int ilogbl(real x);

		pure double ldexp(double x, int exp);

		pure float ldexpf(float x, int exp);

		pure real ldexpl(real x, int exp);

		pure double log(double x);

		pure float logf(float x);

		pure real logl(real x);

		pure double log10(double x);

		pure float log10f(float x);

		pure real log10l(real x);

		pure double log1p(double x);

		pure float log1pf(float x);

		pure real log1pl(real x);

		pure double log2(double x);

		pure float log2f(float x);

		pure real log2l(real x);

		pure double logb(double x);

		pure float logbf(float x);

		pure real logbl(real x);

		pure double modf(double value, double* iptr);

		pure float modff(float value, float* iptr);

		pure real modfl(real value, real* iptr);

		pure double scalbn(double x, int n);

		pure float scalbnf(float x, int n);

		pure real scalbnl(real x, int n);

		pure double scalbln(double x, c_long n);

		pure float scalblnf(float x, c_long n);

		pure real scalblnl(real x, c_long n);

		pure double cbrt(double x);

		pure float cbrtf(float x);

		pure real cbrtl(real x);

		pure double fabs(double x);

		pure float fabsf(float x);

		pure real fabsl(real x);

		pure double hypot(double x, double y);

		pure float hypotf(float x, float y);

		pure real hypotl(real x, real y);

		pure double pow(double x, double y);

		pure float powf(float x, float y);

		pure real powl(real x, real y);

		pure double sqrt(double x);

		pure float sqrtf(float x);

		pure real sqrtl(real x);

		pure double erf(double x);

		pure float erff(float x);

		pure real erfl(real x);

		pure double erfc(double x);

		pure float erfcf(float x);

		pure real erfcl(real x);

		double lgamma(double x);
		float lgammaf(float x);
		real lgammal(real x);
		pure double tgamma(double x);

		pure float tgammaf(float x);

		pure real tgammal(real x);

		pure double ceil(double x);

		pure float ceilf(float x);

		pure real ceill(real x);

		pure double floor(double x);

		pure float floorf(float x);

		pure real floorl(real x);

		pure double nearbyint(double x);

		pure float nearbyintf(float x);

		pure real nearbyintl(real x);

		pure double rint(double x);

		pure float rintf(float x);

		pure real rintl(real x);

		pure c_long lrint(double x);

		pure c_long lrintf(float x);

		pure c_long lrintl(real x);

		pure long llrint(double x);

		pure long llrintf(float x);

		pure long llrintl(real x);

		pure double round(double x);

		pure float roundf(float x);

		pure real roundl(real x);

		pure c_long lround(double x);

		pure c_long lroundf(float x);

		pure c_long lroundl(real x);

		pure long llround(double x);

		pure long llroundf(float x);

		pure long llroundl(real x);

		pure double trunc(double x);

		pure float truncf(float x);

		pure real truncl(real x);

		pure double fmod(double x, double y);

		pure float fmodf(float x, float y);

		pure real fmodl(real x, real y);

		pure double remainder(double x, double y);

		pure float remainderf(float x, float y);

		pure real remainderl(real x, real y);

		double remquo(double x, double y, int* quo);
		float remquof(float x, float y, int* quo);
		real remquol(real x, real y, int* quo);
		pure double copysign(double x, double y);

		pure float copysignf(float x, float y);

		pure real copysignl(real x, real y);

		pure double nan(char* tagp);

		pure float nanf(char* tagp);

		pure real nanl(char* tagp);

		pure double nextafter(double x, double y);

		pure float nextafterf(float x, float y);

		pure real nextafterl(real x, real y);

		pure double nexttoward(double x, real y);

		pure float nexttowardf(float x, real y);

		pure real nexttowardl(real x, real y);

		pure double fdim(double x, double y);

		pure float fdimf(float x, float y);

		pure real fdiml(real x, real y);

		pure double fmax(double x, double y);

		pure float fmaxf(float x, float y);

		pure real fmaxl(real x, real y);

		pure double fmin(double x, double y);

		pure float fminf(float x, float y);

		pure real fminl(real x, real y);

		pure double fma(double x, double y, double z);

		pure float fmaf(float x, float y, float z);

		pure real fmal(real x, real y, real z);

	}
}


