text: /*
  ** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
  ** Standard mathematical library
  ** See Copyright Notice in lua.h
  */
  
  
  #include <stdlib.h>
  #include <math.h>
  
  #define lmathlib_c
  #define LUA_LIB
  
  #include "lua.h"
  
  #include "lauxlib.h"
  #include "lualib.h"
  #include "lrotable.h"
  
  #undef PI
  #define PI (3.14159265358979323846)
  #define RADIANS_PER_DEGREE (PI/180.0)
  
  
  
  static int math_abs(lua_State* L)
  {
  #ifdef LUA_NUMBER_INTEGRAL
  	lua_Number x = luaL_checknumber(L, 1);
  
  	if(x < 0) x = -x;	//fails for -2^31
  
  	lua_pushnumber(L, x);
  #else
  	lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
  #endif
  	return 1;
  }
  
  #ifndef LUA_NUMBER_INTEGRAL
  
  static int math_sin(lua_State* L)
  {
  	lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_sinh(lua_State* L)
  {
  	lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_cos(lua_State* L)
  {
  	lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_cosh(lua_State* L)
  {
  	lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_tan(lua_State* L)
  {
  	lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_tanh(lua_State* L)
  {
  	lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_asin(lua_State* L)
  {
  	lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_acos(lua_State* L)
  {
  	lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_atan(lua_State* L)
  {
  	lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_atan2(lua_State* L)
  {
  	lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
  	return 1;
  }
  
  static int math_ceil(lua_State* L)
  {
  	lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_floor(lua_State* L)
  {
  	lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_fmod(lua_State* L)
  {
  	lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
  	return 1;
  }
  
  static int math_modf(lua_State* L)
  {
  	double ip;
  	double fp = modf(luaL_checknumber(L, 1), &ip);
  	lua_pushnumber(L, ip);
  	lua_pushnumber(L, fp);
  	return 2;
  }
  
  #else  // #ifndef LUA_NUMBER_INTEGRAL
  
  // In integer math, floor() and ceil() give the same value;
  // having them in the integer library allows you to write code that
  // works in both integer and floating point versions of Lua.
  // This identity function is used for them.
  
  static int math_identity(lua_State* L)
  {
  	lua_pushnumber(L, luaL_checknumber(L, 1));
  	return 1;
  }
  
  #endif // #ifndef LUA_NUMBER_INTEGRAL
  
  #ifdef LUA_NUMBER_INTEGRAL
  // Integer square root for integer version
  static lua_Number isqrt(lua_Number x)
  {
  	lua_Number op, res, one;
  
  	op = x;
  	res = 0;
  
  	/* "one" starts at the highest power of four <= than the argument. */
  	one = 1 << 30;  /* second-to-top bit set */
  
  	while(one > op) one >>= 2;
  
  	while(one != 0) {
  		if(op >= res + one) {
  			op = op - (res + one);
  			res = res +  2 * one;
  		}
  
  		res >>= 1;
  		one >>= 2;
  	}
  
  	return(res);
  }
  #endif
  
  static int math_sqrt(lua_State* L)
  {
  #ifdef LUA_NUMBER_INTEGRAL
  	lua_Number x = luaL_checknumber(L, 1);
  	luaL_argcheck(L, 0 <= x, 1, "negative");
  	lua_pushnumber(L, isqrt(x));
  #else
  	lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
  #endif
  	return 1;
  }
  
  #ifdef LUA_NUMBER_INTEGRAL
  	#define pow(a,b) luai_ipow(a,b)
  #endif
  
  static int math_pow(lua_State* L)
  {
  	lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
  	return 1;
  }
  
  #ifdef LUA_NUMBER_INTEGRAL
  	#undef pow
  #endif
  
  
  #ifndef LUA_NUMBER_INTEGRAL
  
  static int math_log(lua_State* L)
  {
  	lua_pushnumber(L, log(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_log10(lua_State* L)
  {
  	lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_exp(lua_State* L)
  {
  	lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
  	return 1;
  }
  
  static int math_deg(lua_State* L)
  {
  	lua_pushnumber(L, luaL_checknumber(L, 1) / RADIANS_PER_DEGREE);
  	return 1;
  }
  
  static int math_rad(lua_State* L)
  {
  	lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
  	return 1;
  }
  
  static int math_frexp(lua_State* L)
  {
  	int e;
  	lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
  	lua_pushinteger(L, e);
  	return 2;
  }
  
  static int math_ldexp(lua_State* L)
  {
  	lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
  	return 1;
  }
  
  #endif // #ifdef LUA_NUMBER_INTEGRAL
  
  static int math_min(lua_State* L)
  {
  	int n = lua_gettop(L);  /* number of arguments */
  	lua_Number dmin = luaL_checknumber(L, 1);
  	int i;
  
  	for(i = 2; i <= n; i++) {
  		lua_Number d = luaL_checknumber(L, i);
  
  		if(d < dmin)
  			dmin = d;
  	}
  
  	lua_pushnumber(L, dmin);
  	return 1;
  }
  
  
  static int math_max(lua_State* L)
  {
  	int n = lua_gettop(L);  /* number of arguments */
  	lua_Number dmax = luaL_checknumber(L, 1);
  	int i;
  
  	for(i = 2; i <= n; i++) {
  		lua_Number d = luaL_checknumber(L, i);
  
  		if(d > dmax)
  			dmax = d;
  	}
  
  	lua_pushnumber(L, dmax);
  	return 1;
  }
  
  
  #ifdef LUA_NUMBER_INTEGRAL
  
  static int math_random(lua_State* L)
  {
  	lua_Number r = (lua_Number)(rand() % RAND_MAX);
  
  	switch(lua_gettop(L)) {   /* check number of arguments */
  		case 0: {  /* no arguments */
  			lua_pushnumber(L, 0);  /* Number between 0 and 1 - always 0 with ints */
  			break;
  		}
  
  		case 1: {  /* only upper limit */
  			int u = luaL_checkint(L, 1);
  			luaL_argcheck(L, 1 <= u, 1, "interval is empty");
  			lua_pushnumber(L, (r % u) + 1); /* int between 1 and `u' */
  			break;
  		}
  
  		case 2: {  /* lower and upper limits */
  			int l = luaL_checkint(L, 1);
  			int u = luaL_checkint(L, 2);
  			luaL_argcheck(L, l <= u, 2, "interval is empty");
  			lua_pushnumber(L, (r % (u - l + 1)) + l); /* int between `l' and `u' */
  			break;
  		}
  
  		default:
  			return luaL_error(L, "wrong number of arguments");
  	}
  
  	return 1;
  }
  
  #else
  
  static int math_random(lua_State* L)
  {
  	/* the `%' avoids the (rare) case of r==1, and is needed also because on
  	   some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
  	lua_Number r = (lua_Number)(rand() % RAND_MAX) / (lua_Number)RAND_MAX;
  
  	switch(lua_gettop(L)) {   /* check number of arguments */
  		case 0: {  /* no arguments */
  			lua_pushnumber(L, r);  /* Number between 0 and 1 */
  			break;
  		}
  
  		case 1: {  /* only upper limit */
  			int u = luaL_checkint(L, 1);
  			luaL_argcheck(L, 1 <= u, 1, "interval is empty");
  			lua_pushnumber(L, floor(r * u) + 1); /* int between 1 and `u' */
  			break;
  		}
  
  		case 2: {  /* lower and upper limits */
  			int l = luaL_checkint(L, 1);
  			int u = luaL_checkint(L, 2);
  			luaL_argcheck(L, l <= u, 2, "interval is empty");
  			lua_pushnumber(L, floor(r * (u - l + 1)) + l); /* int between `l' and `u' */
  			break;
  		}
  
  		default:
  			return luaL_error(L, "wrong number of arguments");
  	}
  
  	return 1;
  }
  
  #endif
  
  
  static int math_randomseed(lua_State* L)
  {
  	srand(luaL_checkint(L, 1));
  	return 0;
  }
  
  #define MIN_OPT_LEVEL 1
  #include "lrodefs.h"
  const LUA_REG_TYPE math_map[] = {
  #ifdef LUA_NUMBER_INTEGRAL
  	{LSTRKEY("abs"),   LFUNCVAL(math_abs)},
  	{LSTRKEY("ceil"),  LFUNCVAL(math_identity)},
  	{LSTRKEY("floor"), LFUNCVAL(math_identity)},
  	{LSTRKEY("max"),   LFUNCVAL(math_max)},
  	{LSTRKEY("min"),   LFUNCVAL(math_min)},
  	{LSTRKEY("pow"),   LFUNCVAL(math_pow)},
  	{LSTRKEY("random"),     LFUNCVAL(math_random)},
  	{LSTRKEY("randomseed"), LFUNCVAL(math_randomseed)},
  	{LSTRKEY("sqrt"),  LFUNCVAL(math_sqrt)},
  #if LUA_OPTIMIZE_MEMORY > 0
  	{LSTRKEY("huge"),  LNUMVAL(LONG_MAX)},
  #endif
  #else
  	{LSTRKEY("abs"),   LFUNCVAL(math_abs)},
  	{LSTRKEY("acos"),  LFUNCVAL(math_acos)},
  	{LSTRKEY("asin"),  LFUNCVAL(math_asin)},
  	{LSTRKEY("atan2"), LFUNCVAL(math_atan2)},
  	{LSTRKEY("atan"),  LFUNCVAL(math_atan)},
  	{LSTRKEY("ceil"),  LFUNCVAL(math_ceil)},
  	{LSTRKEY("cosh"),  LFUNCVAL(math_cosh)},
  	{LSTRKEY("cos"),   LFUNCVAL(math_cos)},
  	{LSTRKEY("deg"),   LFUNCVAL(math_deg)},
  	{LSTRKEY("exp"),   LFUNCVAL(math_exp)},
  	{LSTRKEY("floor"), LFUNCVAL(math_floor)},
  	{LSTRKEY("fmod"),  LFUNCVAL(math_fmod)},
  #if LUA_OPTIMIZE_MEMORY > 0 && defined(LUA_COMPAT_MOD)
  	{LSTRKEY("mod"),   LFUNCVAL(math_fmod)},
  #endif
  	{LSTRKEY("frexp"), LFUNCVAL(math_frexp)},
  	{LSTRKEY("ldexp"), LFUNCVAL(math_ldexp)},
  	{LSTRKEY("log10"), LFUNCVAL(math_log10)},
  	{LSTRKEY("log"),   LFUNCVAL(math_log)},
  	{LSTRKEY("max"),   LFUNCVAL(math_max)},
  	{LSTRKEY("min"),   LFUNCVAL(math_min)},
  	{LSTRKEY("modf"),   LFUNCVAL(math_modf)},
  	{LSTRKEY("pow"),   LFUNCVAL(math_pow)},
  	{LSTRKEY("rad"),   LFUNCVAL(math_rad)},
  	{LSTRKEY("random"),     LFUNCVAL(math_random)},
  	{LSTRKEY("randomseed"), LFUNCVAL(math_randomseed)},
  	{LSTRKEY("sinh"),   LFUNCVAL(math_sinh)},
  	{LSTRKEY("sin"),   LFUNCVAL(math_sin)},
  	{LSTRKEY("sqrt"),  LFUNCVAL(math_sqrt)},
  	{LSTRKEY("tanh"),   LFUNCVAL(math_tanh)},
  	{LSTRKEY("tan"),   LFUNCVAL(math_tan)},
  #if LUA_OPTIMIZE_MEMORY > 0
  	{LSTRKEY("pi"),    LNUMVAL(PI)},
  	{LSTRKEY("huge"),  LNUMVAL(HUGE_VAL)},
  #endif // #if LUA_OPTIMIZE_MEMORY > 0
  #endif // #ifdef LUA_NUMBER_INTEGRAL
  	{LNILKEY, LNILVAL}
  };
  
  
  /*
  ** Open math library
  */
  
  #if defined LUA_NUMBER_INTEGRAL
  	#include <limits.h>		/* for LONG_MAX */
  #endif
  
  LUALIB_API int luaopen_math(lua_State* L)
  {
  #if LUA_OPTIMIZE_MEMORY > 0
  	return 0;
  #else
  	luaL_register(L, LUA_MATHLIBNAME, math_map);
  # if defined LUA_NUMBER_INTEGRAL
  	lua_pushnumber(L, LONG_MAX);
  	lua_setfield(L, -2, "huge");
  # else
  	lua_pushnumber(L, PI);
  	lua_setfield(L, -2, "pi");
  	lua_pushnumber(L, HUGE_VAL);
  	lua_setfield(L, -2, "huge");
  #  if defined(LUA_COMPAT_MOD)
  	lua_getfield(L, -1, "fmod");
  	lua_setfield(L, -2, "mod");
  #  endif
  # endif
  	return 1;
  #endif
  }
  