lmathlib.c - external/github.com/lua/lua - Git at Google

 /*
 ** $Id: lmathlib.c,v 1.119 2016/12/22 13:08:50 roberto Exp roberto $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */

 #define lmathlib_c
 #define LUA_LIB

 #include "lprefix.h"


 #include <limits.h>
 #include <stdlib.h>
 #include <math.h>

 #include "lua.h"

 #include "lauxlib.h"
 #include "lualib.h"


 #undef PI
 #define PI	(l_mathop(3.141592653589793238462643383279502884))


 static int math_abs (lua_State *L) {
   if (lua_isinteger(L, 1)) {
     lua_Integer n = lua_tointeger(L, 1);
     if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
     lua_pushinteger(L, n);
   }
   else
     lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_sin (lua_State *L) {
   lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_cos (lua_State *L) {
   lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_tan (lua_State *L) {
   lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_asin (lua_State *L) {
   lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_acos (lua_State *L) {
   lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_atan (lua_State *L) {
   lua_Number y = luaL_checknumber(L, 1);
   lua_Number x = luaL_optnumber(L, 2, 1);
   lua_pushnumber(L, l_mathop(atan2)(y, x));
   return 1;
 }


 static int math_toint (lua_State *L) {
   int valid;
   lua_Integer n = lua_tointegerx(L, 1, &valid);
   if (valid)
     lua_pushinteger(L, n);
   else {
     luaL_checkany(L, 1);
     lua_pushnil(L);  /* value is not convertible to integer */
   }
   return 1;
 }


 static void pushnumint (lua_State *L, lua_Number d) {
   lua_Integer n;
   if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
     lua_pushinteger(L, n);  /* result is integer */
   else
     lua_pushnumber(L, d);  /* result is float */
 }


 static int math_floor (lua_State *L) {
   if (lua_isinteger(L, 1))
     lua_settop(L, 1);  /* integer is its own floor */
   else {
     lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
     pushnumint(L, d);
   }
   return 1;
 }


 static int math_ceil (lua_State *L) {
   if (lua_isinteger(L, 1))
     lua_settop(L, 1);  /* integer is its own ceil */
   else {
     lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
     pushnumint(L, d);
   }
   return 1;
 }


 static int math_fmod (lua_State *L) {
   if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
     lua_Integer d = lua_tointeger(L, 2);
     if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
       luaL_argcheck(L, d != 0, 2, "zero");
       lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
     }
     else
       lua_pushinteger(L, lua_tointeger(L, 1) % d);
   }
   else
     lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
                                      luaL_checknumber(L, 2)));
   return 1;
 }


 /*
 ** next function does not use 'modf', avoiding problems with 'double*'
 ** (which is not compatible with 'float*') when lua_Number is not
 ** 'double'.
 */
 static int math_modf (lua_State *L) {
   if (lua_isinteger(L ,1)) {
     lua_settop(L, 1);  /* number is its own integer part */
     lua_pushnumber(L, 0);  /* no fractional part */
   }
   else {
     lua_Number n = luaL_checknumber(L, 1);
     /* integer part (rounds toward zero) */
     lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
     pushnumint(L, ip);
     /* fractional part (test needed for inf/-inf) */
     lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
   }
   return 2;
 }


 static int math_sqrt (lua_State *L) {
   lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
   return 1;
 }


 static int math_ult (lua_State *L) {
   lua_Integer a = luaL_checkinteger(L, 1);
   lua_Integer b = luaL_checkinteger(L, 2);
   lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
   return 1;
 }

 static int math_log (lua_State *L) {
   lua_Number x = luaL_checknumber(L, 1);
   lua_Number res;
   if (lua_isnoneornil(L, 2))
     res = l_mathop(log)(x);
   else {
     lua_Number base = luaL_checknumber(L, 2);
 #if !defined(LUA_USE_C89)
     if (base == l_mathop(2.0))
       res = l_mathop(log2)(x); else
 #endif
     if (base == l_mathop(10.0))
       res = l_mathop(log10)(x);
     else
       res = l_mathop(log)(x)/l_mathop(log)(base);
   }
   lua_pushnumber(L, res);
   return 1;
 }

 static int math_exp (lua_State *L) {
   lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_deg (lua_State *L) {
   lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
   return 1;
 }

 static int math_rad (lua_State *L) {
   lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
   return 1;
 }


 static int math_min (lua_State *L) {
   int n = lua_gettop(L);  /* number of arguments */
   int imin = 1;  /* index of current minimum value */
   int i;
   luaL_argcheck(L, n >= 1, 1, "value expected");
   for (i = 2; i <= n; i++) {
     if (lua_compare(L, i, imin, LUA_OPLT))
       imin = i;
   }
   lua_pushvalue(L, imin);
   return 1;
 }


 static int math_max (lua_State *L) {
   int n = lua_gettop(L);  /* number of arguments */
   int imax = 1;  /* index of current maximum value */
   int i;
   luaL_argcheck(L, n >= 1, 1, "value expected");
   for (i = 2; i <= n; i++) {
     if (lua_compare(L, imax, i, LUA_OPLT))
       imax = i;
   }
   lua_pushvalue(L, imax);
   return 1;
 }


 static int math_type (lua_State *L) {
   if (lua_type(L, 1) == LUA_TNUMBER) {
       if (lua_isinteger(L, 1))
         lua_pushliteral(L, "integer");
       else
         lua_pushliteral(L, "float");
   }
   else {
     luaL_checkany(L, 1);
     lua_pushnil(L);
   }
   return 1;
 }


 /*
 ** {==================================================================
 ** Pseudo-Random Number Generator based on 'xorshift128+'.
 ** ===================================================================
 */


 #define twotomin53	(1.0 / 9007199254740992.0)  /* 2^-53 */


 #if defined(LLONG_MAX) && !defined(LUA_DEBUG)		/* { */

 /*
 ** Assume long long.
 */

 /* a 64-bit value */
 typedef unsigned long long I;

 static I xorshift128plus (I *state) {
   I x = state[0];
   I y = state[1];
   state[0] = y;
   x ^= x << 23;
   state[1] = x ^ y ^ (x >> 18) ^ (y >> 5);
   return state[1] + y;
 }


 #define mask53		(~(~0ll << 53))

 /*
 ** Convert 53 bits from a random integer into a double in the
 ** interval [0,1).
 */
 static double I2d (I x) {
   return (x & mask53) * twotomin53;
 }

 /* convert an 'I' to a lua_Integer */
 #define I2Int(x)	((lua_Integer)(x))

 /* convert a lua_Integer to an 'I' */
 #define Int2I(x)	((I)(x))

 #else				/* }{ */

 /*
 ** No long long; Use two 32-bit integers to represent a 64-bit quantity.
 */

 #if LUAI_BITSINT >= 32
 typedef unsigned int lu_int32;
 #else
 typedef unsigned long lu_int32;
 #endif

 /* a 64-bit value */
 typedef struct I {
   lu_int32 x1, x2;
 } I;


 /*
 ** basic operations on 'I' values
 */

 static I pack (int x1, int x2) {
   I result;
   result.x1 = x1;
   result.x2 = x2;
   return result;
 }

 static I Ishl (I i, int n) {
   return pack((i.x1 << n) | (i.x2 >> (32 - n)), i.x2 << n);
 }

 static I Ishr (I i, int n) {
   return pack(i.x1 >> n, (i.x2 >> n) | (i.x1 << (32 - n)));
 }

 static I Ixor (I i1, I i2) {
   return pack(i1.x1 ^ i2.x1, i1.x2 ^ i2.x2);
 }

 static I Iadd (I i1, I i2) {
   I result = pack(i1.x1 + i2.x1, i1.x2 + i2.x2);
   if (result.x2 < i1.x2)  /* carry? */
     result.x1++;
   return result;
 }


 /*
 ** implementation of 'xorshift128+' algorithm on 'I' values
 */
 static I xorshift128plus (I *state) {
   I x = state[0];
   I y = state[1];
   state[0] = y;
   x = Ixor(x, Ishl(x, 23));  /* x ^= x << 23; */
   /* s[1] = x ^ y ^ (x >> 18) ^ (y >> 5); */
   state[1] = Ixor(Ixor(Ixor(x, y), Ishr(x, 18)), Ishr(y, 5));
   return Iadd(state[1], y);  /* return state[1] + y; */
 }


 /*
 ** Converts an 'I' into a double, getting its lower half plus 21
 ** (53 - 32) bits from its higher half and joining them into a double.
 */

 #define mask32		0xffffffff
 #define mask21		(~(~0 << 21))

 #define twoto32		4294967296.0  /* 2^32 */

 static double I2d (I x) {
   return ((x.x1 & mask21) * twoto32 + (x.x2 & mask32)) * twotomin53;
 }

 static lua_Integer I2Int (I x) {
   return (((lua_Integer)x.x1 << 31) << 1) | x.x2;
 }

 static I Int2I (lua_Integer n) {
   return pack(n, (n >> 31) >> 1);
 }

 #endif				/* } */


 /*
 ** A state uses two 'I' values.
 */
 typedef struct {
   I s[2];
 } RanState;


 static int math_random (lua_State *L) {
   lua_Integer low, up;
   double r;
   RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
   I rv = xorshift128plus(state->s);  /* next pseudo-random value */
   switch (lua_gettop(L)) {  /* check number of arguments */
     case 0: {  /* no arguments */
       lua_pushnumber(L, (lua_Number)I2d(rv));  /* float between 0 and 1 */
       return 1;
     }
     case 1: {  /* only upper limit */
       low = 1;
       up = luaL_checkinteger(L, 1);
       if (up == 0) {  /* single 0 as argument? */
         lua_pushinteger(L, I2Int(rv));  /* full random integer */
         return 1;
       }
       break;
     }
     case 2: {  /* lower and upper limits */
       low = luaL_checkinteger(L, 1);
       up = luaL_checkinteger(L, 2);
       break;
     }
     default: return luaL_error(L, "wrong number of arguments");
   }
   /* random integer in the interval [low, up] */
   luaL_argcheck(L, low <= up, 1, "interval is empty");
   luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
                    "interval too large");
   r = I2d(rv);  /* convert random value to a double */
   r *= (double)(up - low) + 1.0;  /* scale it */
   lua_pushinteger(L, (lua_Integer)r + low);
   return 1;
 }


 static void setseed (I *state, lua_Integer n) {
   int i;
   state[0] = Int2I(n);
   state[1] = Int2I(~n);
   for (i = 0; i < 16; i++)
     xorshift128plus(state);  /* discard initial values */
 }


 static int math_randomseed (lua_State *L) {
   RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
   lua_Integer n = luaL_checkinteger(L, 1);
   setseed(state->s, n);
   return 0;
 }


 static const luaL_Reg randfuncs[] = {
   {"random", math_random},
   {"randomseed", math_randomseed},
   {NULL, NULL}
 };

 static void setrandfunc (lua_State *L) {
   RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0);
   setseed(state->s, 0);
   luaL_setfuncs(L, randfuncs, 1);
 }

 /* }================================================================== */


 /*
 ** {==================================================================
 ** Deprecated functions (for compatibility only)
 ** ===================================================================
 */
 #if defined(LUA_COMPAT_MATHLIB)

 static int math_cosh (lua_State *L) {
   lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_sinh (lua_State *L) {
   lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_tanh (lua_State *L) {
   lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
   return 1;
 }

 static int math_pow (lua_State *L) {
   lua_Number x = luaL_checknumber(L, 1);
   lua_Number y = luaL_checknumber(L, 2);
   lua_pushnumber(L, l_mathop(pow)(x, y));
   return 1;
 }

 static int math_frexp (lua_State *L) {
   int e;
   lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
   lua_pushinteger(L, e);
   return 2;
 }

 static int math_ldexp (lua_State *L) {
   lua_Number x = luaL_checknumber(L, 1);
   int ep = (int)luaL_checkinteger(L, 2);
   lua_pushnumber(L, l_mathop(ldexp)(x, ep));
   return 1;
 }

 static int math_log10 (lua_State *L) {
   lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
   return 1;
 }

 #endif
 /* }================================================================== */


 static const luaL_Reg mathlib[] = {
   {"abs",   math_abs},
   {"acos",  math_acos},
   {"asin",  math_asin},
   {"atan",  math_atan},
   {"ceil",  math_ceil},
   {"cos",   math_cos},
   {"deg",   math_deg},
   {"exp",   math_exp},
   {"tointeger", math_toint},
   {"floor", math_floor},
   {"fmod",   math_fmod},
   {"ult",   math_ult},
   {"log",   math_log},
   {"max",   math_max},
   {"min",   math_min},
   {"modf",   math_modf},
   {"rad",   math_rad},
   {"sin",   math_sin},
   {"sqrt",  math_sqrt},
   {"tan",   math_tan},
   {"type", math_type},
 #if defined(LUA_COMPAT_MATHLIB)
   {"atan2", math_atan},
   {"cosh",   math_cosh},
   {"sinh",   math_sinh},
   {"tanh",   math_tanh},
   {"pow",   math_pow},
   {"frexp", math_frexp},
   {"ldexp", math_ldexp},
   {"log10", math_log10},
 #endif
   /* placeholders */
   {"random", NULL},
   {"randomseed", NULL},
   {"pi", NULL},
   {"huge", NULL},
   {"maxinteger", NULL},
   {"mininteger", NULL},
   {NULL, NULL}
 };


 /*
 ** Open math library
 */
 LUAMOD_API int luaopen_math (lua_State *L) {
   luaL_newlib(L, mathlib);
   lua_pushnumber(L, PI);
   lua_setfield(L, -2, "pi");
   lua_pushnumber(L, (lua_Number)HUGE_VAL);
   lua_setfield(L, -2, "huge");
   lua_pushinteger(L, LUA_MAXINTEGER);
   lua_setfield(L, -2, "maxinteger");
   lua_pushinteger(L, LUA_MININTEGER);
   lua_setfield(L, -2, "mininteger");
   setrandfunc(L);
   return 1;
 }
	/*
	** $Id: lmathlib.c,v 1.119 2016/12/22 13:08:50 roberto Exp roberto $
	** Standard mathematical library
	** See Copyright Notice in lua.h
	*/

	#define lmathlib_c
	#define LUA_LIB

	#include "lprefix.h"


	#include <limits.h>
	#include <stdlib.h>
	#include <math.h>

	#include "lua.h"

	#include "lauxlib.h"
	#include "lualib.h"


	#undef PI
	#define PI (l_mathop(3.141592653589793238462643383279502884))


	static int math_abs (lua_State *L) {
	if (lua_isinteger(L, 1)) {
	lua_Integer n = lua_tointeger(L, 1);
	if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
	lua_pushinteger(L, n);
	}
	else
	lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_sin (lua_State *L) {
	lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_cos (lua_State *L) {
	lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_tan (lua_State *L) {
	lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_asin (lua_State *L) {
	lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_acos (lua_State *L) {
	lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_atan (lua_State *L) {
	lua_Number y = luaL_checknumber(L, 1);
	lua_Number x = luaL_optnumber(L, 2, 1);
	lua_pushnumber(L, l_mathop(atan2)(y, x));
	return 1;
	}


	static int math_toint (lua_State *L) {
	int valid;
	lua_Integer n = lua_tointegerx(L, 1, &valid);
	if (valid)
	lua_pushinteger(L, n);
	else {
	luaL_checkany(L, 1);
	lua_pushnil(L); /* value is not convertible to integer */
	}
	return 1;
	}


	static void pushnumint (lua_State *L, lua_Number d) {
	lua_Integer n;
	if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */
	lua_pushinteger(L, n); /* result is integer */
	else
	lua_pushnumber(L, d); /* result is float */
	}


	static int math_floor (lua_State *L) {
	if (lua_isinteger(L, 1))
	lua_settop(L, 1); /* integer is its own floor */
	else {
	lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
	pushnumint(L, d);
	}
	return 1;
	}


	static int math_ceil (lua_State *L) {
	if (lua_isinteger(L, 1))
	lua_settop(L, 1); /* integer is its own ceil */
	else {
	lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
	pushnumint(L, d);
	}
	return 1;
	}


	static int math_fmod (lua_State *L) {
	if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
	lua_Integer d = lua_tointeger(L, 2);
	if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
	luaL_argcheck(L, d != 0, 2, "zero");
	lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
	}
	else
	lua_pushinteger(L, lua_tointeger(L, 1) % d);
	}
	else
	lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
	luaL_checknumber(L, 2)));
	return 1;
	}


	/*
	** next function does not use 'modf', avoiding problems with 'double*'
	** (which is not compatible with 'float*') when lua_Number is not
	** 'double'.
	*/
	static int math_modf (lua_State *L) {
	if (lua_isinteger(L ,1)) {
	lua_settop(L, 1); /* number is its own integer part */
	lua_pushnumber(L, 0); /* no fractional part */
	}
	else {
	lua_Number n = luaL_checknumber(L, 1);
	/* integer part (rounds toward zero) */
	lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
	pushnumint(L, ip);
	/* fractional part (test needed for inf/-inf) */
	lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
	}
	return 2;
	}


	static int math_sqrt (lua_State *L) {
	lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
	return 1;
	}


	static int math_ult (lua_State *L) {
	lua_Integer a = luaL_checkinteger(L, 1);
	lua_Integer b = luaL_checkinteger(L, 2);
	lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
	return 1;
	}

	static int math_log (lua_State *L) {
	lua_Number x = luaL_checknumber(L, 1);
	lua_Number res;
	if (lua_isnoneornil(L, 2))
	res = l_mathop(log)(x);
	else {
	lua_Number base = luaL_checknumber(L, 2);
	#if !defined(LUA_USE_C89)
	if (base == l_mathop(2.0))
	res = l_mathop(log2)(x); else
	#endif
	if (base == l_mathop(10.0))
	res = l_mathop(log10)(x);
	else
	res = l_mathop(log)(x)/l_mathop(log)(base);
	}
	lua_pushnumber(L, res);
	return 1;
	}

	static int math_exp (lua_State *L) {
	lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_deg (lua_State *L) {
	lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
	return 1;
	}

	static int math_rad (lua_State *L) {
	lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
	return 1;
	}


	static int math_min (lua_State *L) {
	int n = lua_gettop(L); /* number of arguments */
	int imin = 1; /* index of current minimum value */
	int i;
	luaL_argcheck(L, n >= 1, 1, "value expected");
	for (i = 2; i <= n; i++) {
	if (lua_compare(L, i, imin, LUA_OPLT))
	imin = i;
	}
	lua_pushvalue(L, imin);
	return 1;
	}


	static int math_max (lua_State *L) {
	int n = lua_gettop(L); /* number of arguments */
	int imax = 1; /* index of current maximum value */
	int i;
	luaL_argcheck(L, n >= 1, 1, "value expected");
	for (i = 2; i <= n; i++) {
	if (lua_compare(L, imax, i, LUA_OPLT))
	imax = i;
	}
	lua_pushvalue(L, imax);
	return 1;
	}


	static int math_type (lua_State *L) {
	if (lua_type(L, 1) == LUA_TNUMBER) {
	if (lua_isinteger(L, 1))
	lua_pushliteral(L, "integer");
	else
	lua_pushliteral(L, "float");
	}
	else {
	luaL_checkany(L, 1);
	lua_pushnil(L);
	}
	return 1;
	}



	/*
	** {==================================================================
	** Pseudo-Random Number Generator based on 'xorshift128+'.
	** ===================================================================
	*/


	#define twotomin53 (1.0 / 9007199254740992.0) /* 2^-53 */


	#if defined(LLONG_MAX) && !defined(LUA_DEBUG) /* { */

	/*
	** Assume long long.
	*/

	/* a 64-bit value */
	typedef unsigned long long I;

	static I xorshift128plus (I *state) {
	I x = state[0];
	I y = state[1];
	state[0] = y;
	x ^= x << 23;
	state[1] = x ^ y ^ (x >> 18) ^ (y >> 5);
	return state[1] + y;
	}


	#define mask53 (~(~0ll << 53))

	/*
	** Convert 53 bits from a random integer into a double in the
	** interval [0,1).
	*/
	static double I2d (I x) {
	return (x & mask53) * twotomin53;
	}

	/* convert an 'I' to a lua_Integer */
	#define I2Int(x) ((lua_Integer)(x))

	/* convert a lua_Integer to an 'I' */
	#define Int2I(x) ((I)(x))

	#else /* }{ */

	/*
	** No long long; Use two 32-bit integers to represent a 64-bit quantity.
	*/

	#if LUAI_BITSINT >= 32
	typedef unsigned int lu_int32;
	#else
	typedef unsigned long lu_int32;
	#endif

	/* a 64-bit value */
	typedef struct I {
	lu_int32 x1, x2;
	} I;


	/*
	** basic operations on 'I' values
	*/

	static I pack (int x1, int x2) {
	I result;
	result.x1 = x1;
	result.x2 = x2;
	return result;
	}

	static I Ishl (I i, int n) {
	return pack((i.x1 << n) \| (i.x2 >> (32 - n)), i.x2 << n);
	}

	static I Ishr (I i, int n) {
	return pack(i.x1 >> n, (i.x2 >> n) \| (i.x1 << (32 - n)));
	}

	static I Ixor (I i1, I i2) {
	return pack(i1.x1 ^ i2.x1, i1.x2 ^ i2.x2);
	}

	static I Iadd (I i1, I i2) {
	I result = pack(i1.x1 + i2.x1, i1.x2 + i2.x2);
	if (result.x2 < i1.x2) /* carry? */
	result.x1++;
	return result;
	}


	/*
	** implementation of 'xorshift128+' algorithm on 'I' values
	*/
	static I xorshift128plus (I *state) {
	I x = state[0];
	I y = state[1];
	state[0] = y;
	x = Ixor(x, Ishl(x, 23)); /* x ^= x << 23; */
	/* s[1] = x ^ y ^ (x >> 18) ^ (y >> 5); */
	state[1] = Ixor(Ixor(Ixor(x, y), Ishr(x, 18)), Ishr(y, 5));
	return Iadd(state[1], y); /* return state[1] + y; */
	}


	/*
	** Converts an 'I' into a double, getting its lower half plus 21
	** (53 - 32) bits from its higher half and joining them into a double.
	*/

	#define mask32 0xffffffff
	#define mask21 (~(~0 << 21))

	#define twoto32 4294967296.0 /* 2^32 */

	static double I2d (I x) {
	return ((x.x1 & mask21) * twoto32 + (x.x2 & mask32)) * twotomin53;
	}

	static lua_Integer I2Int (I x) {
	return (((lua_Integer)x.x1 << 31) << 1) \| x.x2;
	}

	static I Int2I (lua_Integer n) {
	return pack(n, (n >> 31) >> 1);
	}

	#endif /* } */


	/*
	** A state uses two 'I' values.
	*/
	typedef struct {
	I s[2];
	} RanState;


	static int math_random (lua_State *L) {
	lua_Integer low, up;
	double r;
	RanState state = (RanState )lua_touserdata(L, lua_upvalueindex(1));
	I rv = xorshift128plus(state->s); /* next pseudo-random value */
	switch (lua_gettop(L)) { /* check number of arguments */
	case 0: { /* no arguments */
	lua_pushnumber(L, (lua_Number)I2d(rv)); /* float between 0 and 1 */
	return 1;
	}
	case 1: { /* only upper limit */
	low = 1;
	up = luaL_checkinteger(L, 1);
	if (up == 0) { /* single 0 as argument? */
	lua_pushinteger(L, I2Int(rv)); /* full random integer */
	return 1;
	}
	break;
	}
	case 2: { /* lower and upper limits */
	low = luaL_checkinteger(L, 1);
	up = luaL_checkinteger(L, 2);
	break;
	}
	default: return luaL_error(L, "wrong number of arguments");
	}
	/* random integer in the interval [low, up] */
	luaL_argcheck(L, low <= up, 1, "interval is empty");
	luaL_argcheck(L, low >= 0 \|\| up <= LUA_MAXINTEGER + low, 1,
	"interval too large");
	r = I2d(rv); /* convert random value to a double */
	r = (double)(up - low) + 1.0; / scale it */
	lua_pushinteger(L, (lua_Integer)r + low);
	return 1;
	}


	static void setseed (I *state, lua_Integer n) {
	int i;
	state[0] = Int2I(n);
	state[1] = Int2I(~n);
	for (i = 0; i < 16; i++)
	xorshift128plus(state); /* discard initial values */
	}


	static int math_randomseed (lua_State *L) {
	RanState state = (RanState )lua_touserdata(L, lua_upvalueindex(1));
	lua_Integer n = luaL_checkinteger(L, 1);
	setseed(state->s, n);
	return 0;
	}


	static const luaL_Reg randfuncs[] = {
	{"random", math_random},
	{"randomseed", math_randomseed},
	{NULL, NULL}
	};

	static void setrandfunc (lua_State *L) {
	RanState state = (RanState )lua_newuserdatauv(L, sizeof(RanState), 0);
	setseed(state->s, 0);
	luaL_setfuncs(L, randfuncs, 1);
	}

	/* }================================================================== */


	/*
	** {==================================================================
	** Deprecated functions (for compatibility only)
	** ===================================================================
	*/
	#if defined(LUA_COMPAT_MATHLIB)

	static int math_cosh (lua_State *L) {
	lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_sinh (lua_State *L) {
	lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_tanh (lua_State *L) {
	lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
	return 1;
	}

	static int math_pow (lua_State *L) {
	lua_Number x = luaL_checknumber(L, 1);
	lua_Number y = luaL_checknumber(L, 2);
	lua_pushnumber(L, l_mathop(pow)(x, y));
	return 1;
	}

	static int math_frexp (lua_State *L) {
	int e;
	lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
	lua_pushinteger(L, e);
	return 2;
	}

	static int math_ldexp (lua_State *L) {
	lua_Number x = luaL_checknumber(L, 1);
	int ep = (int)luaL_checkinteger(L, 2);
	lua_pushnumber(L, l_mathop(ldexp)(x, ep));
	return 1;
	}

	static int math_log10 (lua_State *L) {
	lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
	return 1;
	}

	#endif
	/* }================================================================== */



	static const luaL_Reg mathlib[] = {
	{"abs", math_abs},
	{"acos", math_acos},
	{"asin", math_asin},
	{"atan", math_atan},
	{"ceil", math_ceil},
	{"cos", math_cos},
	{"deg", math_deg},
	{"exp", math_exp},
	{"tointeger", math_toint},
	{"floor", math_floor},
	{"fmod", math_fmod},
	{"ult", math_ult},
	{"log", math_log},
	{"max", math_max},
	{"min", math_min},
	{"modf", math_modf},
	{"rad", math_rad},
	{"sin", math_sin},
	{"sqrt", math_sqrt},
	{"tan", math_tan},
	{"type", math_type},
	#if defined(LUA_COMPAT_MATHLIB)
	{"atan2", math_atan},
	{"cosh", math_cosh},
	{"sinh", math_sinh},
	{"tanh", math_tanh},
	{"pow", math_pow},
	{"frexp", math_frexp},
	{"ldexp", math_ldexp},
	{"log10", math_log10},
	#endif
	/* placeholders */
	{"random", NULL},
	{"randomseed", NULL},
	{"pi", NULL},
	{"huge", NULL},
	{"maxinteger", NULL},
	{"mininteger", NULL},
	{NULL, NULL}
	};


	/*
	** Open math library
	*/
	LUAMOD_API int luaopen_math (lua_State *L) {
	luaL_newlib(L, mathlib);
	lua_pushnumber(L, PI);
	lua_setfield(L, -2, "pi");
	lua_pushnumber(L, (lua_Number)HUGE_VAL);
	lua_setfield(L, -2, "huge");
	lua_pushinteger(L, LUA_MAXINTEGER);
	lua_setfield(L, -2, "maxinteger");
	lua_pushinteger(L, LUA_MININTEGER);
	lua_setfield(L, -2, "mininteger");
	setrandfunc(L);
	return 1;
	}