/* lmpfrlib.c */
/* */
/* Lua API for the GNU MPFR Library */
/* */
/* Written 2016-01-23, Version 2018-04-24, 2023-05-29 */
/* */
/* Copyright (C) 2016--2023 Hartmut Henkel */
/* E-Mail: hartmut_henkel@gmx.de */
/* Homepage: http://www.hhenkel.de/lmpfrlib/ */
/* */
/* This program is free software: you can redistribute it and/or modify */
/* it under the terms of the GNU Lesser Public License as published by */
/* the Free Software Foundation, either version 3 of the License, or */
/* (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Lesser Public License for more details. */
/* */
/* You should have received a copy of the GNU Lesser Public License */
/* along with this program. If not, see . */
/*************************************************************************/
#include
#include
#include
#include
#include
#include
#define M_mpfr_t "mpfr_t"
#define M_mpfr_exp_t "mpfr_exp_t"
#define M_mpfr_prec_t "mpfr_prec_t"
#define M_mpfr_rnd_t "mpfr_rnd_t"
/**********************************************************************/
#define NOT_IMPLEMENTED(NAME) \
int l_##NAME(lua_State * L) \
{ \
luaL_error(L, #NAME "() not implemented yet"); \
return 0; \
}
#define USE_INSTEAD(NAME1, NAME2) \
int l_##NAME1(lua_State * L) \
{ \
luaL_error(L, #NAME1 "() not implemented yet," \
" use " #NAME2 "() instead"); \
return 0; \
}
#define DEPRECATED_NEW(NAME1, NAME2) \
int l_##NAME1(lua_State * L) \
{ \
luaL_error(L, #NAME1 "() deprecated," \
" use " #NAME2 "() instead"); \
return 0; \
}
#define l_mpfr_specfun(NAME) \
int l_##NAME(lua_State * L) \
{ \
mpfr_t *rop, *op; \
mpfr_rnd_t rnd; \
int top, ret; \
top = lua_gettop(L); \
if (top == 1) { \
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t); \
rop = new_mpfr_t(L); \
mpfr_init(*rop); \
rnd = mpfr_get_default_rounding_mode(); \
(void) NAME(*rop, *op, rnd); \
} else { \
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);\
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t); \
rnd = get_rounding_mode(L, 3); \
ret = NAME(*rop, *op, rnd); \
lua_pushinteger(L, ret); \
} \
return 1; \
}
#define l_mpfr_specfun2(NAME) \
int l_##NAME(lua_State * L) \
{ \
mpfr_t *rop, *op1, *op2; \
mpfr_rnd_t rnd; \
int top, ret; \
top = lua_gettop(L); \
if (top == 2) { \
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t); \
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t); \
rop = new_mpfr_t(L); \
mpfr_init(*rop); \
rnd = mpfr_get_default_rounding_mode(); \
(void) NAME(*rop, *op1, *op2, rnd); \
} else { \
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t); \
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t); \
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t); \
rnd = get_rounding_mode(L, 3); \
ret = NAME(*rop, *op1, *op2, rnd); \
lua_pushinteger(L, ret); \
} \
return 1; \
}
#define l_mpfr_const(NAME) \
int l_##NAME(lua_State * L) \
{ \
mpfr_t *rop; \
mpfr_rnd_t rnd; \
int top, ret; \
top = lua_gettop(L); \
if (top == 0) { \
rop = new_mpfr_t(L); \
mpfr_init(*rop); \
rnd = mpfr_get_default_rounding_mode(); \
(void) NAME(*rop, rnd); \
} else { \
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);\
rnd = get_rounding_mode(L, 2); \
ret = NAME(*rop, rnd); \
lua_pushinteger(L, ret); \
} \
return 1; \
}
#define l_mpfr_fits(NAME) \
int l_##NAME(lua_State * L) \
{ \
mpfr_t *op; \
mpfr_rnd_t rnd; \
int ret; \
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);\
rnd = get_rounding_mode(L, 2); \
ret = NAME(*op, rnd); \
lua_pushinteger(L, ret); \
return 1; \
}
/**********************************************************************/
mpfr_rnd_t get_rounding_mode(lua_State * L, int spos)
{
mpfr_rnd_t rnd;
const char *s;
char c;
size_t len;
int pos, top;
top = lua_gettop(L);
if (top >= spos) {
s = luaL_checklstring(L, spos, &len);
switch (len) {
case 1:
pos = 0;
break;
case 4:
pos = 3;
if (strncmp("RND", s, pos) != 0)
luaL_error(L,
"mpfr_set_default_rounding_mode(): wrong rounding mode (1)");
break;
case 9:
pos = 8;
if (strncmp("MPFR_RND", s, pos) != 0)
luaL_error(L,
"mpfr_set_default_rounding_mode(): wrong rounding mode (2)");
break;
default:
luaL_error(L,
"mpfr_set_default_rounding_mode(): wrong rounding mode (3)");
}
c = s[pos];
switch (c) {
case 'N':
rnd = MPFR_RNDN;
break;
case 'D':
rnd = MPFR_RNDD;
break;
case 'U':
rnd = MPFR_RNDU;
break;
case 'Z':
rnd = MPFR_RNDZ;
break;
case 'A':
rnd = MPFR_RNDA;
break;
case 'F':
rnd = MPFR_RNDF;
break;
default:
luaL_error(L,
"mpfr_set_default_rounding_mode(): wrong rounding mode (4)");
}
} else
rnd = mpfr_get_default_rounding_mode();
return rnd;
}
mpfr_t *new_mpfr_t(lua_State * L)
{
mpfr_t *a;
a = (mpfr_t *) lua_newuserdata(L, sizeof(mpfr_t)); /* mpfr_t ... */
luaL_getmetatable(L, M_mpfr_t); /* m mpfr_t ... */
lua_setmetatable(L, -2); /* mpfr_t ... */
return a;
}
/**********************************************************************/
/* 5.1 Initialization Functions */
int l_mpfr_num(lua_State * L)
{
mpfr_t *rop, *op;
int base, ltype, top;
size_t l;
const char *s;
lua_Number n;
lua_Integer i;
mpfr_rnd_t rnd;
top = lua_gettop(L);
if (top == 0) {
rop = new_mpfr_t(L);
mpfr_init(*rop);
} else {
ltype = lua_type(L, 1);
switch (ltype) {
case LUA_TUSERDATA:
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
rnd = get_rounding_mode(L, 2);
rop = new_mpfr_t(L);
(void) mpfr_init_set(*rop, *op, rnd);
break;
case LUA_TNUMBER:
n = luaL_checknumber(L, 1);
rnd = get_rounding_mode(L, 2);
if (lua_isinteger(L, 1)) {
(void) lua_numbertointeger(n, &i);
rop = new_mpfr_t(L);
(void) mpfr_init_set_si(*rop, i, rnd);
} else {
rop = new_mpfr_t(L);
(void) mpfr_init_set_d(*rop, n, rnd);
}
break;
case LUA_TSTRING:
s = luaL_checklstring(L, 1, &l);
if (top >= 2)
base = (int) luaL_checkinteger(L, 2);
else
base = 0; /* auto-detect */
rnd = get_rounding_mode(L, 3);
rop = new_mpfr_t(L);
(void) mpfr_init_set_str(*rop, s, base, rnd);
break;
}
}
return 1;
}
int l_mpfr_init2(lua_State * L)
{
mpfr_t *a;
mpfr_prec_t prec;
prec = (mpfr_prec_t) luaL_checkinteger(L, 1);
a = new_mpfr_t(L);
mpfr_init2(*a, prec);
return 1;
}
NOT_IMPLEMENTED(mpfr_inits2);
int l_mpfr_clear(lua_State * L)
{
mpfr_t *x;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
mpfr_clear(*x);
return 0;
}
int l_mpfr_clears(lua_State * L)
{
mpfr_t *x;
int i, top;
top = lua_gettop(L);
for (i = 1; i <= top; i++) {
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
mpfr_clear(*x);
}
return 0;
}
int l_mpfr_init(lua_State * L)
{
mpfr_t *a;
a = new_mpfr_t(L);
mpfr_init(*a);
return 1;
}
NOT_IMPLEMENTED(mpfr_inits);
int l_mpfr_set_default_prec(lua_State * L)
{
mpfr_prec_t prec;
prec = (mpfr_prec_t) luaL_checkinteger(L, 1);
mpfr_set_default_prec(prec);
return 0;
}
int l_mpfr_get_default_prec(lua_State * L)
{
mpfr_prec_t prec;
prec = mpfr_get_default_prec();
lua_pushinteger(L, prec);
return 1;
}
int l_mpfr_set_prec(lua_State * L)
{
mpfr_t *op;
mpfr_prec_t prec;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
prec = (mpfr_prec_t) luaL_checkinteger(L, 2);
mpfr_set_prec(*op, prec);
return 0;
}
int l_mpfr_get_prec(lua_State * L)
{
mpfr_t *op;
mpfr_prec_t prec;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
prec = mpfr_get_prec(*op);
lua_pushinteger(L, prec);
return 1;
}
/**********************************************************************/
/* 5.2 Assignment Functions */
l_mpfr_specfun(mpfr_set);
USE_INSTEAD(mpfr_set_ui, mpfr_set_si);
int l_mpfr_set_si(lua_State * L)
{
mpfr_t *rop;
lua_Integer op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = luaL_checkinteger(L, 2);
rnd = get_rounding_mode(L, 3);
ret = mpfr_set_si(*rop, (long int) op, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_set_uj);
NOT_IMPLEMENTED(mpfr_set_sj);
NOT_IMPLEMENTED(mpfr_set_flt);
int l_mpfr_set_d(lua_State * L)
{
mpfr_t *rop;
lua_Number op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = luaL_checknumber(L, 2);
rnd = get_rounding_mode(L, 3);
ret = mpfr_set_d(*rop, op, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_set_ld);
NOT_IMPLEMENTED(mpfr_set_float128);
NOT_IMPLEMENTED(mpfr_set_decimal64);
NOT_IMPLEMENTED(mpfr_set_decimal128);
NOT_IMPLEMENTED(mpfr_set_z);
NOT_IMPLEMENTED(mpfr_set_q);
NOT_IMPLEMENTED(mpfr_set_f);
NOT_IMPLEMENTED(mpfr_set_ui_2exp);
int l_mpfr_set_si_2exp(lua_State * L)
{
mpfr_t *rop;
lua_Integer op;
mpfr_exp_t e;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = luaL_checkinteger(L, 2);
e = (mpfr_exp_t) luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_set_si_2exp(*rop, op, e, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_set_uj_2exp);
NOT_IMPLEMENTED(mpfr_set_sj_2exp);
NOT_IMPLEMENTED(mpfr_set_z_2exp);
int l_mpfr_set_str(lua_State * L)
{
mpfr_t *rop;
const char *s;
mpfr_rnd_t rnd;
int base, ret;
size_t l;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
s = luaL_checklstring(L, 2, &l);
base = (int) luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_set_str(*rop, s, base, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_strtofr);
int l_mpfr_set_nan(lua_State * L)
{
mpfr_t *x;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
mpfr_set_nan(*x);
return 0;
}
int l_mpfr_set_inf(lua_State * L)
{
mpfr_t *x;
int sign;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
sign = (int) luaL_checkinteger(L, 2);
mpfr_set_inf(*x, sign);
return 0;
}
int l_mpfr_set_zero(lua_State * L)
{
mpfr_t *x;
int sign;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
sign = (int) luaL_checkinteger(L, 2);
mpfr_set_zero(*x, sign);
return 0;
}
int l_mpfr_swap(lua_State * L)
{
mpfr_t *x, *y;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
y = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
mpfr_swap(*x, *y);
return 0;
}
/**********************************************************************/
/* 5.3 Combined Initialization and Assignment Functions */
int l_mpfr_init_set(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
rnd = get_rounding_mode(L, 2);
rop = new_mpfr_t(L);
ret = mpfr_init_set(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 2;
}
USE_INSTEAD(mpfr_init_set_ui, mpfr_init_set_si);
int l_mpfr_init_set_si(lua_State * L)
{
mpfr_t *rop;
lua_Integer op;
mpfr_rnd_t rnd;
int ret;
op = luaL_checkinteger(L, 1);
rnd = get_rounding_mode(L, 2);
rop = new_mpfr_t(L);
ret = mpfr_init_set_si(*rop, op, rnd);
lua_pushinteger(L, ret);
return 2;
}
int l_mpfr_init_set_d(lua_State * L)
{
mpfr_t *rop;
lua_Number op;
mpfr_rnd_t rnd;
int ret;
op = luaL_checknumber(L, 1);
rnd = get_rounding_mode(L, 2);
rop = new_mpfr_t(L);
ret = mpfr_init_set_d(*rop, op, rnd);
lua_pushinteger(L, ret);
return 2;
}
NOT_IMPLEMENTED(mpfr_init_set_ld);
NOT_IMPLEMENTED(mpfr_init_set_z);
NOT_IMPLEMENTED(mpfr_init_set_q);
NOT_IMPLEMENTED(mpfr_init_set_f);
int l_mpfr_init_set_str(lua_State * L)
{
mpfr_t *x;
const char *s;
mpfr_rnd_t rnd;
int base, top, ret;
size_t l;
s = luaL_checklstring(L, 1, &l);
top = lua_gettop(L);
if (top >= 2)
base = (int) luaL_checkinteger(L, 2);
else
base = 0; /* auto-detect */
rnd = get_rounding_mode(L, 3);
x = new_mpfr_t(L);
ret = mpfr_init_set_str(*x, s, base, rnd);
lua_pushinteger(L, ret);
return 2;
}
/**********************************************************************/
/* 5.4 Conversion Functions */
NOT_IMPLEMENTED(mpfr_get_flt);
int l_mpfr_get_d(lua_State * L)
{
mpfr_t *op;
mpfr_rnd_t rnd;
double x;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
rnd = get_rounding_mode(L, 2);
x = mpfr_get_d(*op, rnd);
lua_pushnumber(L, x);
return 1;
}
NOT_IMPLEMENTED(mpfr_get_ld);
NOT_IMPLEMENTED(mpfr_get_float128);
NOT_IMPLEMENTED(mpfr_get_decimal64);
NOT_IMPLEMENTED(mpfr_get_decimal128);
int l_mpfr_get_si(lua_State * L)
{
mpfr_t *op;
mpfr_rnd_t rnd;
long x;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
rnd = get_rounding_mode(L, 2);
x = mpfr_get_si(*op, rnd);
lua_pushinteger(L, x);
return 1;
}
USE_INSTEAD(mpfr_get_ui, mpfr_get_si);
NOT_IMPLEMENTED(mpfr_get_sj);
NOT_IMPLEMENTED(mpfr_get_uj);
int l_mpfr_get_d_2exp(lua_State * L)
{
mpfr_t *op;
mpfr_rnd_t rnd;
long exp;
double d;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
rnd = get_rounding_mode(L, 2);
d = mpfr_get_d_2exp(&exp, *op, rnd);
lua_pushnumber(L, d);
lua_pushinteger(L, exp);
return 2;
}
NOT_IMPLEMENTED(mpfr_get_ld_2exp);
int l_mpfr_frexp(lua_State * L)
{
mpfr_t *x, *y;
mpfr_rnd_t rnd;
long exp;
int ret;
y = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
x = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_frexp(&exp, *y, *x, rnd);
lua_pushinteger(L, ret);
lua_pushinteger(L, exp);
return 1;
}
NOT_IMPLEMENTED(mpfr_get_z_2exp);
NOT_IMPLEMENTED(mpfr_get_z);
NOT_IMPLEMENTED(mpfr_get_f);
NOT_IMPLEMENTED(mpfr_get_str);
NOT_IMPLEMENTED(mpfr_free_str);
l_mpfr_fits(mpfr_fits_ulong_p);
l_mpfr_fits(mpfr_fits_slong_p);
l_mpfr_fits(mpfr_fits_uint_p);
l_mpfr_fits(mpfr_fits_sint_p);
l_mpfr_fits(mpfr_fits_ushort_p);
l_mpfr_fits(mpfr_fits_sshort_p);
l_mpfr_fits(mpfr_fits_uintmax_p);
l_mpfr_fits(mpfr_fits_intmax_p);
/**********************************************************************/
/* 5.5 Arithmetic Functions */
int l_mpfr_add(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_add(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
USE_INSTEAD(mpfr_add_ui, mpfr_add_si);
int l_mpfr_add_si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_add_si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_add_d(lua_State * L)
{
mpfr_t *rop, *op1;
double op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checknumber(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_add_d(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_add_z);
NOT_IMPLEMENTED(mpfr_add_q);
int l_mpfr_sub(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_sub(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
USE_INSTEAD(mpfr_ui_sub, mpfr_si_sub);
USE_INSTEAD(mpfr_sub_ui, mpfr_sub_si);
int l_mpfr_si_sub(lua_State * L)
{
mpfr_t *rop, *op2;
lua_Integer op1;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = luaL_checkinteger(L, 2);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_si_sub(*rop, op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_sub_si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_sub_si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_d_sub(lua_State * L)
{
mpfr_t *rop, *op2;
double op1;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = luaL_checknumber(L, 2);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_d_sub(*rop, op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_sub_d(lua_State * L)
{
mpfr_t *rop, *op1;
double op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checknumber(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_sub_d(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_z_sub);
NOT_IMPLEMENTED(mpfr_sub_z);
NOT_IMPLEMENTED(mpfr_sub_q);
int l_mpfr_mul(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_mul(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
USE_INSTEAD(mpfr_mul_ui, mpfr_mul_si);
int l_mpfr_mul_si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_mul_si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_mul_d(lua_State * L)
{
mpfr_t *rop, *op1;
double op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checknumber(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_mul_d(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_mul_z);
NOT_IMPLEMENTED(mpfr_mul_q);
l_mpfr_specfun(mpfr_sqr);
int l_mpfr_div(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_div(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
USE_INSTEAD(mpfr_ui_div, mpfr_si_div);
USE_INSTEAD(mpfr_div_ui, mpfr_div_si);
int l_mpfr_si_div(lua_State * L)
{
mpfr_t *rop, *op2;
lua_Integer op1;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = luaL_checkinteger(L, 2);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_si_div(*rop, op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_div_si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_div_si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_d_div(lua_State * L)
{
mpfr_t *rop, *op2;
double op1;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = luaL_checknumber(L, 2);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_d_div(*rop, op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_div_d(lua_State * L)
{
mpfr_t *rop, *op1;
double op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checknumber(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_div_d(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_div_z);
NOT_IMPLEMENTED(mpfr_div_q);
l_mpfr_specfun(mpfr_sqrt);
USE_INSTEAD(mpfr_sqrt_ui, mpfr_sqrt_si);
l_mpfr_specfun(mpfr_rec_sqrt);
l_mpfr_specfun(mpfr_cbrt);
int l_mpfr_root(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
lua_Integer k;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
k = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_rootn_ui(*rop, *op, k, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_pow(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_pow(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
USE_INSTEAD(mpfr_pow_ui, mpfr_pow_si);
int l_mpfr_pow_si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_pow_si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_pow_z);
int l_mpfr_ui_pow_ui(lua_State * L)
{
mpfr_t *rop;
lua_Integer op1, op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = luaL_checkinteger(L, 2);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_ui_pow_ui(*rop, op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_ui_pow(lua_State * L)
{
mpfr_t *rop, *op2;
lua_Integer op1;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = luaL_checkinteger(L, 2);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_ui_pow(*rop, op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
l_mpfr_specfun(mpfr_neg);
l_mpfr_specfun(mpfr_abs);
int l_mpfr_dim(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_dim(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_mul_2ui);
int l_mpfr_mul_2si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_mul_2si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_div_2ui);
int l_mpfr_div_2si(lua_State * L)
{
mpfr_t *rop, *op1;
lua_Integer op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_div_2si(*rop, *op1, op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
/**********************************************************************/
/* 5.6 Comparison Functions */
int l_mpfr_cmp(lua_State * L)
{
mpfr_t *op1, *op2;
int ret;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_cmp(*op1, *op2);
lua_pushinteger(L, ret);
return 1;
}
USE_INSTEAD(mpfr_cmp_ui, mpfr_cmp_si);
int l_mpfr_cmp_si(lua_State * L)
{
mpfr_t *op1;
lua_Integer op2;
int ret;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = luaL_checkinteger(L, 2);
ret = mpfr_cmp_si(*op1, op2);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_cmp_d(lua_State * L)
{
mpfr_t *op1;
double op2;
int ret;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = luaL_checknumber(L, 2);
ret = mpfr_cmp_d(*op1, op2);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_cmp_ld);
NOT_IMPLEMENTED(mpfr_cmp_z);
NOT_IMPLEMENTED(mpfr_cmp_q);
NOT_IMPLEMENTED(mpfr_cmp_f);
USE_INSTEAD(mpfr_cmp_ui_2exp, mpfr_cmp_si_2exp);
int l_mpfr_cmp_si_2exp(lua_State * L)
{
mpfr_t *op1;
lua_Integer op2;
mpfr_exp_t e;
int ret;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = luaL_checkinteger(L, 2);
e = luaL_checkinteger(L, 3);
ret = mpfr_cmp_si_2exp(*op1, op2, e);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_cmpabs(lua_State * L)
{
mpfr_t *op1, *op2;
int ret;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_cmpabs(*op1, *op2);
lua_pushinteger(L, ret);
return 1;
}
#define l_mpfr_number_is(NAME) \
int l_mpfr_##NAME(lua_State * L) \
{ \
mpfr_t *op; \
int i; \
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);\
i = mpfr_##NAME(*op); \
lua_pushinteger(L, i); \
return 1; \
}
l_mpfr_number_is(nan_p);
l_mpfr_number_is(inf_p);
l_mpfr_number_is(number_p);
l_mpfr_number_is(zero_p);
l_mpfr_number_is(regular_p);
l_mpfr_number_is(sgn);
#define l_mpfr_compare_numbers(NAME) \
int l_mpfr_##NAME(lua_State * L) \
{ \
mpfr_t *op1, *op2; \
int i; \
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t); \
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t); \
i = mpfr_##NAME(*op1, *op2); \
lua_pushinteger(L, i); \
return 1; \
}
l_mpfr_compare_numbers(greater_p);
l_mpfr_compare_numbers(greaterequal_p);
l_mpfr_compare_numbers(less_p);
l_mpfr_compare_numbers(lessequal_p);
l_mpfr_compare_numbers(equal_p);
l_mpfr_compare_numbers(lessgreater_p);
l_mpfr_compare_numbers(unordered_p);
/**********************************************************************/
/* 5.7 Transcendental Functions */
l_mpfr_specfun(mpfr_log);
l_mpfr_specfun(mpfr_log2);
l_mpfr_specfun(mpfr_log10);
l_mpfr_specfun(mpfr_exp);
l_mpfr_specfun(mpfr_exp2);
l_mpfr_specfun(mpfr_exp10);
l_mpfr_specfun(mpfr_cos);
l_mpfr_specfun(mpfr_sin);
l_mpfr_specfun(mpfr_tan);
int l_mpfr_sin_cos(lua_State * L)
{
mpfr_t *sop, *cop, *op;
mpfr_rnd_t rnd;
int ret;
sop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
cop = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_sin_cos(*sop, *cop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
l_mpfr_specfun(mpfr_sec);
l_mpfr_specfun(mpfr_csc);
l_mpfr_specfun(mpfr_cot);
l_mpfr_specfun(mpfr_acos);
l_mpfr_specfun(mpfr_asin);
l_mpfr_specfun(mpfr_atan);
l_mpfr_specfun2(mpfr_atan2);
l_mpfr_specfun(mpfr_cosh);
l_mpfr_specfun(mpfr_sinh);
l_mpfr_specfun(mpfr_tanh);
int l_mpfr_sinh_cosh(lua_State * L)
{
mpfr_t *sop, *cop, *op;
mpfr_rnd_t rnd;
int ret;
sop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
cop = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_sinh_cosh(*sop, *cop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
l_mpfr_specfun(mpfr_sech);
l_mpfr_specfun(mpfr_csch);
l_mpfr_specfun(mpfr_coth);
l_mpfr_specfun(mpfr_acosh);
l_mpfr_specfun(mpfr_asinh);
l_mpfr_specfun(mpfr_atanh);
int l_mpfr_fac_ui(lua_State * L)
{
mpfr_t *rop;
lua_Integer op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = luaL_checkinteger(L, 2);
assert(op >= 0);
rnd = get_rounding_mode(L, 3);
ret = mpfr_fac_ui(*rop, op, rnd);
lua_pushinteger(L, ret);
return 1;
}
l_mpfr_specfun(mpfr_log1p);
l_mpfr_specfun(mpfr_expm1);
l_mpfr_specfun(mpfr_eint);
l_mpfr_specfun(mpfr_li2);
l_mpfr_specfun(mpfr_gamma);
l_mpfr_specfun(mpfr_lngamma);
int l_mpfr_lgamma(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret, sign;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_lgamma(*rop, &sign, *op, rnd);
lua_pushinteger(L, ret);
lua_pushinteger(L, sign);
return 2;
}
l_mpfr_specfun(mpfr_digamma);
l_mpfr_specfun(mpfr_zeta);
NOT_IMPLEMENTED(mpfr_zeta_ui);
l_mpfr_specfun(mpfr_erf);
l_mpfr_specfun(mpfr_erfc);
l_mpfr_specfun(mpfr_j0);
l_mpfr_specfun(mpfr_j1);
int l_mpfr_jn(lua_State * L)
{
mpfr_t *rop, *op;
long n;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n = luaL_checkinteger(L, 2);
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_jn(*rop, n, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
l_mpfr_specfun(mpfr_y0);
l_mpfr_specfun(mpfr_y1);
int l_mpfr_yn(lua_State * L)
{
mpfr_t *rop, *op;
long n;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n = luaL_checkinteger(L, 2);
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_yn(*rop, n, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_fma(lua_State * L)
{
mpfr_t *rop, *op1, *op2, *op3;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
op3 = (mpfr_t *) luaL_checkudata(L, 4, M_mpfr_t);
rnd = get_rounding_mode(L, 5);
ret = mpfr_fma(*rop, *op1, *op2, *op3, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_fms(lua_State * L)
{
mpfr_t *rop, *op1, *op2, *op3;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
op3 = (mpfr_t *) luaL_checkudata(L, 4, M_mpfr_t);
rnd = get_rounding_mode(L, 5);
ret = mpfr_fms(*rop, *op1, *op2, *op3, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_agm(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_agm(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_hypot(lua_State * L)
{
mpfr_t *rop, *x, *y;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
x = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
y = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_hypot(*rop, *x, *y, rnd);
lua_pushinteger(L, ret);
return 1;
}
l_mpfr_specfun(mpfr_ai);
l_mpfr_const(mpfr_const_log2);
l_mpfr_const(mpfr_const_pi);
l_mpfr_const(mpfr_const_euler);
l_mpfr_const(mpfr_const_catalan);
int l_mpfr_free_cache(lua_State * L)
{
mpfr_free_cache();
return 0;
}
int l_mpfr_sum(lua_State * L)
{
mpfr_t *rop;
mpfr_rnd_t rnd;
lua_Integer n;
lua_Integer i, ret;
mpfr_ptr *tab;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t); /* (rnd) t rop */
luaL_checktype(L, 2, LUA_TTABLE); /* (rnd) t rop */
rnd = get_rounding_mode(L, 3);
lua_len(L, 2); /* n (rnd) t rop */
n = lua_tointeger(L, -1);
lua_pop(L, 1); /* (rnd) t rop */
tab = (mpfr_ptr *) lua_newuserdata(L, n * sizeof(mpfr_ptr)); /* tab (rnd) t rop */
for (i = 1; i <= n; i++) {
lua_geti(L, 2, i); /* op tab (rnd) t rop */
tab[i - 1] = (mpfr_ptr) luaL_checkudata(L, -1, M_mpfr_t); /* op tab (rnd) t rop */
lua_pop(L, 1); /* tab (rnd) t rop */
}
ret = mpfr_sum(*rop, tab, n, rnd);
lua_pushinteger(L, ret);
return 1;
}
/**********************************************************************/
/* 5.8 Input and Output Functions */
int l_mpfr_out_str(lua_State * L)
{
mpfr_t *op;
int base;
size_t n;
mpfr_rnd_t rnd;
luaL_Stream *fh;
size_t ret;
fh = (luaL_Stream *) luaL_checkudata(L, 1, LUA_FILEHANDLE);
base = (int) luaL_checkinteger(L, 2);
n = luaL_checkinteger(L, 3);
op = (mpfr_t *) luaL_checkudata(L, 4, M_mpfr_t);
rnd = get_rounding_mode(L, 5);
ret = mpfr_out_str(fh->f, base, n, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_inp_str);
/**********************************************************************/
/* 5.9 Formatted Output Functions */
NOT_IMPLEMENTED(mpfr_fprintf);
NOT_IMPLEMENTED(mpfr_vfprintf);
int l_mpfr_printf(lua_State * L)
{
mpfr_t *rop, *op;
const char *fmt;
int ltype, ret = 0, top;
size_t l;
top = lua_gettop(L);
if (top > 0) {
ltype = lua_type(L, 1);
if (ltype == LUA_TUSERDATA) {
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
if (top >= 2) {
fmt = luaL_checklstring(L, 2, &l);
if (top >= 3) {
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
ret = mpfr_printf(fmt, op);
} else {
ret = mpfr_printf(fmt, rop);
}
}
} else {
fmt = luaL_checklstring(L, 1, &l);
if (top >= 2) {
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_printf(fmt, op);
}
}
}
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_vprintf);
int l_mpfr_sprintf(lua_State * L)
{
mpfr_t *rop, *op;
const char *fmt;
char *p, pos;
int ltype, ret = 0, top;
size_t l, n;
luaL_Buffer b;
top = lua_gettop(L);
if (top == 0) {
lua_pushnil(L);
} else {
pos = 1;
ltype = lua_type(L, pos);
if (ltype == LUA_TUSERDATA) {
rop = (mpfr_t *) luaL_checkudata(L, pos, M_mpfr_t);
pos++;
}
if (top >= pos) {
fmt = luaL_checklstring(L, pos, &l);
pos++;
if (top >= pos)
op = (mpfr_t *) luaL_checkudata(L, pos, M_mpfr_t);
else
op = rop;
n = mpfr_snprintf(NULL, 0, fmt, op);
if (n >= 0) {
p = luaL_buffinitsize(L, &b, n + 1);
ret = mpfr_sprintf(p, fmt, op);
assert(ret == n);
luaL_pushresultsize(&b, n);
} else
lua_pushnil(L);
} else
lua_pushnil(L);
}
lua_pushinteger(L, ret);
return 2;
}
NOT_IMPLEMENTED(mpfr_vsprintf);
int l_mpfr_snprintf(lua_State * L)
{
mpfr_t *rop, *op;
const char *fmt;
char *p;
int ltype, ret = 0, sz, top;
size_t l, n;
luaL_Buffer b;
top = lua_gettop(L);
if (top == 0) {
lua_pushnil(L);
} else {
ltype = lua_type(L, 1);
if (ltype == LUA_TUSERDATA) {
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
if (top >= 2) {
n = luaL_checkinteger(L, 2);
if (top >= 3) {
fmt = luaL_checklstring(L, 3, &l);
p = luaL_buffinitsize(L, &b, n + 1);
if (top >= 4) {
op = (mpfr_t *) luaL_checkudata(L, 4, M_mpfr_t);
ret = mpfr_snprintf(p, n, fmt, op);
if (ret > (n - 1))
sz = n - 1;
else
sz = ret;
luaL_pushresultsize(&b, sz);
} else {
ret = mpfr_snprintf(p, n, fmt, rop);
if (ret > (n - 1))
sz = n - 1;
else
sz = ret;
luaL_pushresultsize(&b, sz);
}
} else
lua_pushnil(L);
} else
lua_pushnil(L);
} else {
n = luaL_checkinteger(L, 1);
if (top >= 2) {
fmt = luaL_checklstring(L, 2, &l);
if (top >= 3) {
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
p = luaL_buffinitsize(L, &b, n + 1);
ret = mpfr_snprintf(p, n, fmt, op);
if (ret > (n - 1))
sz = n - 1;
else
sz = ret;
luaL_pushresultsize(&b, sz);
}
} else
lua_pushnil(L);
}
}
lua_pushinteger(L, ret);
return 2;
}
NOT_IMPLEMENTED(mpfr_vsnprintf);
NOT_IMPLEMENTED(mpfr_asprintf);
NOT_IMPLEMENTED(mpfr_vasprintf);
/**********************************************************************/
/* 5.10 Integer and Remainder Related Functions */
int l_mpfr_rint(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_rint(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_ceil(lua_State * L)
{
mpfr_t *rop, *op;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_ceil(*rop, *op);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_floor(lua_State * L)
{
mpfr_t *rop, *op;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_floor(*rop, *op);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_round(lua_State * L)
{
mpfr_t *rop, *op;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_round(*rop, *op);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_trunc(lua_State * L)
{
mpfr_t *rop, *op;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
ret = mpfr_trunc(*rop, *op);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_rint_ceil(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_rint_ceil(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_rint_floor(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_rint_floor(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_rint_round(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_rint_round(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_rint_trunc(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_rint_trunc(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_frac(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
rnd = get_rounding_mode(L, 3);
ret = mpfr_frac(*rop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_modf(lua_State * L)
{
mpfr_t *iop, *fop, *op;
mpfr_rnd_t rnd;
int ret;
iop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
fop = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_modf(*iop, *fop, *op, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_fmod(lua_State * L)
{
mpfr_t *r, *x, *y;
mpfr_rnd_t rnd;
int ret;
r = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
x = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
y = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_fmod(*r, *x, *y, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_remainder(lua_State * L)
{
mpfr_t *r, *x, *y;
mpfr_rnd_t rnd;
int ret;
r = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
x = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
y = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_remainder(*r, *x, *y, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_remquo(lua_State * L)
{
mpfr_t *r, *x, *y;
mpfr_rnd_t rnd;
int ret;
long q;
r = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
x = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
y = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_remquo(*r, &q, *x, *y, rnd);
lua_pushinteger(L, ret);
lua_pushinteger(L, q);
return 2;
}
int l_mpfr_integer_p(lua_State * L)
{
mpfr_t *op;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
int i = mpfr_integer_p(*op);
lua_pushinteger(L, i);
return 1;
}
/**********************************************************************/
/* 5.11 Rounding-Related Functions */
int l_mpfr_set_default_rounding_mode(lua_State * L)
{
mpfr_rnd_t rnd;
rnd = get_rounding_mode(L, 1);
mpfr_set_default_rounding_mode(rnd);
return 0;
}
int l_mpfr_get_default_rounding_mode(lua_State * L)
{
mpfr_rnd_t rnd;
rnd = mpfr_get_default_rounding_mode();
switch (rnd) {
case MPFR_RNDN:
lua_pushstring(L, "MPFR_RNDN");
break;
case MPFR_RNDD:
lua_pushstring(L, "MPFR_RNDD");
break;
case MPFR_RNDU:
lua_pushstring(L, "MPFR_RNDU");
break;
case MPFR_RNDZ:
lua_pushstring(L, "MPFR_RNDZ");
break;
case MPFR_RNDA:
lua_pushstring(L, "MPFR_RNDA");
break;
case MPFR_RNDF:
lua_pushstring(L, "MPFR_RNDF");
break;
default:
assert(0);
}
return 1;
}
int l_mpfr_prec_round(lua_State * L)
{
mpfr_t *x;
mpfr_prec_t prec;
mpfr_rnd_t rnd;
int ret;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
prec = (mpfr_prec_t) luaL_checkinteger(L, 2);
rnd = get_rounding_mode(L, 3);
if ((prec < MPFR_PREC_MIN) || (prec > MPFR_PREC_MAX))
luaL_error(L, "precision outside MPFR_PREC_MIN...MPFR_PREX_MAX");
ret = mpfr_prec_round(*x, prec, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_can_round);
int l_mpfr_min_prec(lua_State * L)
{
mpfr_t *x;
int ret;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
ret = mpfr_min_prec(*x);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_print_rnd_mode);
/**********************************************************************/
/* 5.12 Miscellaneous Functions */
int l_mpfr_nexttoward(lua_State * L)
{
mpfr_t *x, *y;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
y = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
mpfr_nexttoward(*x, *y);
return 0;
}
int l_mpfr_nextabove(lua_State * L)
{
mpfr_t *x;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
mpfr_nextabove(*x);
return 0;
}
int l_mpfr_nextbelow(lua_State * L)
{
mpfr_t *x;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
mpfr_nextbelow(*x);
return 0;
}
int l_mpfr_min(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_min(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_max(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_max(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_urandomb);
NOT_IMPLEMENTED(mpfr_urandom);
NOT_IMPLEMENTED(mpfr_grandom);
int l_mpfr_get_exp(lua_State * L)
{
mpfr_t *x;
mpfr_exp_t e;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
e = mpfr_get_exp(*x);
lua_pushinteger(L, (lua_Integer) e);
return 1;
}
int l_mpfr_set_exp(lua_State * L)
{
mpfr_t *x;
lua_Integer e;
int ret;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
e = luaL_checkinteger(L, 2);
ret = mpfr_set_exp(*x, (mpfr_exp_t) e);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_signbit(lua_State * L)
{
mpfr_t *op;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
int i = mpfr_signbit(*op);
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_setsign(lua_State * L)
{
mpfr_t *rop, *op;
lua_Integer s;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
s = luaL_checkinteger(L, 3);
rnd = get_rounding_mode(L, 4);
ret = mpfr_setsign(*rop, *op, s, rnd);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_copysign(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
mpfr_rnd_t rnd;
int ret;
rop = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op1 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 3, M_mpfr_t);
rnd = get_rounding_mode(L, 4);
ret = mpfr_copysign(*rop, *op1, *op2, rnd);
lua_pushinteger(L, ret);
return 1;
}
NOT_IMPLEMENTED(mpfr_get_version);
NOT_IMPLEMENTED(mpfr_get_patches);
int l_mpfr_buildopt_tls_p(lua_State * L)
{
int i;
i = mpfr_buildopt_tls_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_buildopt_decimal_p(lua_State * L)
{
int i;
i = mpfr_buildopt_decimal_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_buildopt_gmpinternals_p(lua_State * L)
{
int i;
i = mpfr_buildopt_gmpinternals_p();
lua_pushinteger(L, i);
return 1;
}
NOT_IMPLEMENTED(mpfr_buildopt_tune_case);
/**********************************************************************/
/* 5.13 Exception Related Functions */
int l_mpfr_get_emin(lua_State * L)
{
mpfr_exp_t i;
i = mpfr_get_emin();
lua_pushinteger(L, (lua_Integer) i);
return 1;
}
int l_mpfr_get_emax(lua_State * L)
{
mpfr_exp_t i;
i = mpfr_get_emax();
lua_pushinteger(L, (lua_Integer) i);
return 1;
}
int l_mpfr_set_emin(lua_State * L)
{
lua_Integer e;
int ret;
e = luaL_checkinteger(L, 1);
ret = mpfr_set_emin((mpfr_exp_t) e);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_set_emax(lua_State * L)
{
lua_Integer e;
int ret;
e = luaL_checkinteger(L, 1);
ret = mpfr_set_emax((mpfr_exp_t) e);
lua_pushinteger(L, ret);
return 1;
}
int l_mpfr_get_emin_min(lua_State * L)
{
mpfr_exp_t i;
i = mpfr_get_emin_min();
lua_pushinteger(L, (lua_Integer) i);
return 1;
}
int l_mpfr_get_emin_max(lua_State * L)
{
mpfr_exp_t i;
i = mpfr_get_emin_max();
lua_pushinteger(L, (lua_Integer) i);
return 1;
}
int l_mpfr_get_emax_min(lua_State * L)
{
mpfr_exp_t i;
i = mpfr_get_emax_min();
lua_pushinteger(L, (lua_Integer) i);
return 1;
}
int l_mpfr_get_emax_max(lua_State * L)
{
mpfr_exp_t i;
i = mpfr_get_emax_max();
lua_pushinteger(L, (lua_Integer) i);
return 1;
}
NOT_IMPLEMENTED(mpfr_check_range);
NOT_IMPLEMENTED(mpfr_subnormalize);
int l_mpfr_clear_underflow(lua_State * L)
{
mpfr_clear_underflow();
return 0;
}
int l_mpfr_clear_overflow(lua_State * L)
{
mpfr_clear_overflow();
return 0;
}
int l_mpfr_clear_divby0(lua_State * L)
{
mpfr_clear_divby0();
return 0;
}
int l_mpfr_clear_nanflag(lua_State * L)
{
mpfr_clear_nanflag();
return 0;
}
int l_mpfr_clear_inexflag(lua_State * L)
{
mpfr_clear_inexflag();
return 0;
}
int l_mpfr_clear_erangeflag(lua_State * L)
{
mpfr_clear_erangeflag();
return 0;
}
int l_mpfr_set_underflow(lua_State * L)
{
mpfr_set_underflow();
return 0;
}
int l_mpfr_set_overflow(lua_State * L)
{
mpfr_set_overflow();
return 0;
}
int l_mpfr_set_divby0(lua_State * L)
{
mpfr_set_divby0();
return 0;
}
int l_mpfr_set_nanflag(lua_State * L)
{
mpfr_set_nanflag();
return 0;
}
int l_mpfr_set_inexflag(lua_State * L)
{
mpfr_set_inexflag();
return 0;
}
int l_mpfr_set_erangeflag(lua_State * L)
{
mpfr_set_erangeflag();
return 0;
}
int l_mpfr_clear_flags(lua_State * L)
{
mpfr_clear_flags();
return 0;
}
int l_mpfr_underflow_p(lua_State * L)
{
int i = mpfr_underflow_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_overflow_p(lua_State * L)
{
int i = mpfr_overflow_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_divby0_p(lua_State * L)
{
int i = mpfr_divby0_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_nanflag_p(lua_State * L)
{
int i = mpfr_nanflag_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_inexflag_p(lua_State * L)
{
int i = mpfr_inexflag_p();
lua_pushinteger(L, i);
return 1;
}
int l_mpfr_erangeflag_p(lua_State * L)
{
int i = mpfr_erangeflag_p();
lua_pushinteger(L, i);
return 1;
}
/**********************************************************************/
/* 5.14 Memory Handling Functions */
/**********************************************************************/
/* 5.15 Compatibility With MPF */
NOT_IMPLEMENTED(mpfr_set_prec_raw);
NOT_IMPLEMENTED(mpfr_eq);
NOT_IMPLEMENTED(mpfr_reldiff);
NOT_IMPLEMENTED(mpfr_mul_2exp);
NOT_IMPLEMENTED(mpfr_div_2exp);
/**********************************************************************/
/* 5.16 Custom Interface */
NOT_IMPLEMENTED(mpfr_custom_get_size);
NOT_IMPLEMENTED(mpfr_custom_init);
NOT_IMPLEMENTED(mpfr_custom_init_set);
NOT_IMPLEMENTED(mpfr_custom_get_kind);
NOT_IMPLEMENTED(mpfr_custom_get_significand);
NOT_IMPLEMENTED(mpfr_custom_get_exp);
NOT_IMPLEMENTED(mpfr_custom_move);
/**********************************************************************/
/* 5.17 Internals */
/**********************************************************************/
static const struct luaL_Reg libmpfr_t_f[] = {
/* 5.1 Initialization Functions */
{"num", l_mpfr_num}, /* not part of MPFR */
{"init2", l_mpfr_init2},
{"inits2", l_mpfr_inits2},
{"clear", l_mpfr_clear},
{"clears", l_mpfr_clears},
{"init", l_mpfr_init},
{"inits", l_mpfr_inits},
{"set_default_prec", l_mpfr_set_default_prec},
{"get_default_prec", l_mpfr_get_default_prec},
{"set_prec", l_mpfr_set_prec},
{"get_prec", l_mpfr_get_prec},
/* 5.2 Assignment Functions */
{"set", l_mpfr_set},
{"set_ui", l_mpfr_set_ui},
{"set_si", l_mpfr_set_si},
{"set_uj", l_mpfr_set_uj},
{"set_sj", l_mpfr_set_sj},
{"set_flt", l_mpfr_set_flt},
{"set_d", l_mpfr_set_d},
{"set_ld", l_mpfr_set_ld},
{"set_decimal64", l_mpfr_set_decimal64},
{"set_float128", l_mpfr_set_float128},
{"set_decimal64", l_mpfr_set_decimal64},
{"set_decimal128", l_mpfr_set_decimal128},
{"set_z", l_mpfr_set_z},
{"set_q", l_mpfr_set_q},
{"set_f", l_mpfr_set_f},
{"set_ui_2exp", l_mpfr_set_ui_2exp},
{"set_si_2exp", l_mpfr_set_si_2exp},
{"set_uj_2exp", l_mpfr_set_uj_2exp},
{"set_sj_2exp", l_mpfr_set_sj_2exp},
{"set_z_2exp", l_mpfr_set_z_2exp},
{"set_str", l_mpfr_set_str},
{"set_strtofr", l_mpfr_strtofr},
{"set_nan", l_mpfr_set_nan},
{"set_inf", l_mpfr_set_inf},
{"set_zero", l_mpfr_set_zero},
{"swap", l_mpfr_swap},
/* 5.3 Combined Initialization and Assignment Functions */
{"init_set", l_mpfr_init_set},
{"init_set_ui", l_mpfr_init_set_ui},
{"init_set_si", l_mpfr_init_set_si},
{"init_set_d", l_mpfr_init_set_d},
{"init_set_ld", l_mpfr_init_set_ld},
{"init_set_z", l_mpfr_init_set_z},
{"init_set_q", l_mpfr_init_set_q},
{"init_set_f", l_mpfr_init_set_f},
{"init_set_str", l_mpfr_init_set_str},
/* 5.4 Conversion Functions */
{"get_flt", l_mpfr_get_flt},
{"get_d", l_mpfr_get_d},
{"get_ld", l_mpfr_get_ld},
{"get_float128", l_mpfr_get_float128},
{"get_decimal64", l_mpfr_get_decimal64},
{"get_decimal128", l_mpfr_get_decimal128},
{"get_si", l_mpfr_get_si},
{"get_ui", l_mpfr_get_ui},
{"get_sj", l_mpfr_get_sj},
{"get_sj", l_mpfr_get_uj},
{"get_d_2exp", l_mpfr_get_d_2exp},
{"get_ld_2exp", l_mpfr_get_ld_2exp},
{"frexp", l_mpfr_frexp},
{"get_z_2exp", l_mpfr_get_z_2exp},
{"get_z", l_mpfr_get_z},
{"get_f", l_mpfr_get_f},
{"get_str", l_mpfr_get_str},
{"free_str", l_mpfr_free_str},
{"fits_ulong_p", l_mpfr_fits_ulong_p},
{"fits_slong_p", l_mpfr_fits_slong_p},
{"fits_uint_p", l_mpfr_fits_uint_p},
{"fits_sint_p", l_mpfr_fits_sint_p},
{"fits_ushort_p", l_mpfr_fits_ushort_p},
{"fits_sshort_p", l_mpfr_fits_sshort_p},
{"fits_uintmax_p", l_mpfr_fits_uintmax_p},
{"fits_intmax_p", l_mpfr_fits_intmax_p},
/* 5.5 Basic Arithmetic Functions */
{"add", l_mpfr_add},
{"add_ui", l_mpfr_add_ui},
{"add_si", l_mpfr_add_si},
{"add_d", l_mpfr_add_d},
{"add_z", l_mpfr_add_z},
{"add_q", l_mpfr_add_q},
{"sub", l_mpfr_sub},
{"ui_sub", l_mpfr_ui_sub},
{"sub_ui", l_mpfr_sub_ui},
{"si_sub", l_mpfr_si_sub},
{"sub_si", l_mpfr_sub_si},
{"d_sub", l_mpfr_d_sub},
{"sub_d", l_mpfr_sub_d},
{"z_sub", l_mpfr_z_sub},
{"sub_z", l_mpfr_sub_z},
{"sub_q", l_mpfr_sub_q},
{"mul", l_mpfr_mul},
{"mul_ui", l_mpfr_mul_ui},
{"mul_si", l_mpfr_mul_si},
{"mul_d", l_mpfr_mul_d},
{"mul_z", l_mpfr_mul_z},
{"mul_q", l_mpfr_mul_q},
{"sqr", l_mpfr_sqr},
{"div", l_mpfr_div},
{"ui_div", l_mpfr_ui_div},
{"div_ui", l_mpfr_div_ui},
{"si_div", l_mpfr_si_div},
{"div_si", l_mpfr_div_si},
{"div_d", l_mpfr_div_d},
{"div_z", l_mpfr_div_z},
{"div_q", l_mpfr_div_q},
{"sqrt", l_mpfr_sqrt},
{"sqrt_ui", l_mpfr_sqrt_ui},
{"rec_sqrt", l_mpfr_rec_sqrt},
{"cbrt", l_mpfr_cbrt},
{"root", l_mpfr_root},
{"pow", l_mpfr_pow},
{"pow_ui", l_mpfr_pow_ui},
{"pow_si", l_mpfr_pow_si},
{"pow_z", l_mpfr_pow_z},
{"ui_pow_ui", l_mpfr_ui_pow_ui},
{"ui_pow", l_mpfr_ui_pow},
{"neg", l_mpfr_neg},
{"abs", l_mpfr_abs},
{"dim", l_mpfr_dim},
{"mul_2ui", l_mpfr_mul_2ui},
{"mul_2si", l_mpfr_mul_2si},
{"div_2ui", l_mpfr_div_2ui},
{"div_2si", l_mpfr_div_2si},
/* 5.6 Comparison Functions */
{"cmp", l_mpfr_cmp},
{"cmp_ui", l_mpfr_cmp_ui},
{"cmp_si", l_mpfr_cmp_si},
{"cmp_d", l_mpfr_cmp_d},
{"cmp_ld", l_mpfr_cmp_ld},
{"cmp_z", l_mpfr_cmp_z},
{"cmp_q", l_mpfr_cmp_q},
{"cmp_f", l_mpfr_cmp_f},
{"cmp_ui_2exp", l_mpfr_cmp_ui_2exp},
{"cmp_si_2exp", l_mpfr_cmp_si_2exp},
{"cmpabs", l_mpfr_cmpabs},
{"nan_p", l_mpfr_nan_p},
{"inf_p", l_mpfr_inf_p},
{"number_p", l_mpfr_number_p},
{"zero_p", l_mpfr_zero_p},
{"regular_p", l_mpfr_regular_p},
{"sgn", l_mpfr_sgn},
{"greater_p", l_mpfr_greater_p},
{"greaterequal_p", l_mpfr_greaterequal_p},
{"less_p", l_mpfr_less_p},
{"lessequal_p", l_mpfr_lessequal_p},
{"equal_p", l_mpfr_equal_p},
{"lessgreater_p", l_mpfr_lessgreater_p},
{"unordered_p", l_mpfr_unordered_p},
/* 5.7 Special Functions */
{"log", l_mpfr_log},
{"log2", l_mpfr_log2},
{"log10", l_mpfr_log10},
{"exp", l_mpfr_exp},
{"exp2", l_mpfr_exp2},
{"exp10", l_mpfr_exp10},
{"cos", l_mpfr_cos},
{"sin", l_mpfr_sin},
{"tan", l_mpfr_tan},
{"sin_cos", l_mpfr_sin_cos},
{"sec", l_mpfr_sec},
{"csc", l_mpfr_csc},
{"cot", l_mpfr_cot},
{"acos", l_mpfr_acos},
{"asin", l_mpfr_asin},
{"atan", l_mpfr_atan},
{"atan2", l_mpfr_atan2},
{"cosh", l_mpfr_cosh},
{"sinh", l_mpfr_sinh},
{"tanh", l_mpfr_tanh},
{"sinh_cosh", l_mpfr_sinh_cosh},
{"sech", l_mpfr_sech},
{"csch", l_mpfr_csch},
{"coth", l_mpfr_coth},
{"acosh", l_mpfr_acosh},
{"asinh", l_mpfr_asinh},
{"atanh", l_mpfr_atanh},
{"fac_ui", l_mpfr_fac_ui},
{"log1p", l_mpfr_log1p},
{"expm1", l_mpfr_expm1},
{"eint", l_mpfr_eint},
{"li2", l_mpfr_li2},
{"gamma", l_mpfr_gamma},
{"lngamma", l_mpfr_lngamma},
{"lgamma", l_mpfr_lgamma},
{"digamma", l_mpfr_digamma},
{"zeta", l_mpfr_zeta},
{"zeta_ui", l_mpfr_zeta_ui},
{"erf", l_mpfr_erf},
{"erfc", l_mpfr_erfc},
{"j0", l_mpfr_j0},
{"j1", l_mpfr_j1},
{"jn", l_mpfr_jn},
{"y0", l_mpfr_y0},
{"y1", l_mpfr_y1},
{"yn", l_mpfr_yn},
{"fma", l_mpfr_fma},
{"fms", l_mpfr_fms},
{"agm", l_mpfr_agm},
{"hypot", l_mpfr_hypot},
{"ai", l_mpfr_ai},
{"const_log2", l_mpfr_const_log2},
{"const_pi", l_mpfr_const_pi},
{"const_euler", l_mpfr_const_euler},
{"const_catalan", l_mpfr_const_catalan},
{"free_cache", l_mpfr_free_cache},
{"sum", l_mpfr_sum},
/* 5.8 Input and Output Functions */
{"out_str", l_mpfr_out_str},
{"inp_str", l_mpfr_inp_str},
/* 5.9 Formatted Output Functions */
{"fprintf", l_mpfr_fprintf},
{"vfprintf", l_mpfr_vfprintf},
{"printf", l_mpfr_printf},
{"vprintf", l_mpfr_vprintf},
{"sprintf", l_mpfr_sprintf},
{"vsprintf", l_mpfr_vsprintf},
{"snprintf", l_mpfr_snprintf},
{"vsnprintf", l_mpfr_vsnprintf},
{"asprintf", l_mpfr_asprintf},
{"vasprintf", l_mpfr_vasprintf},
/* 5.10 Integer and Remainder Related Functions */
{"rint", l_mpfr_rint},
{"ceil", l_mpfr_ceil},
{"floor", l_mpfr_floor},
{"round", l_mpfr_round},
{"trunc", l_mpfr_trunc},
{"rint_ceil", l_mpfr_rint_ceil},
{"rint_floor", l_mpfr_rint_floor},
{"rint_round", l_mpfr_rint_round},
{"rint_trunc", l_mpfr_rint_trunc},
{"frac", l_mpfr_frac},
{"modf", l_mpfr_modf},
{"fmod", l_mpfr_fmod},
{"remainder", l_mpfr_remainder},
{"remquo", l_mpfr_remquo},
{"integer_p", l_mpfr_integer_p},
/* 5.11 Rounding Related Functions */
{"set_default_rounding_mode", l_mpfr_set_default_rounding_mode},
{"prec_round", l_mpfr_prec_round},
{"can_round", l_mpfr_can_round},
{"min_prec", l_mpfr_min_prec},
{"print_rnd_mode", l_mpfr_print_rnd_mode},
/* 5.12 Miscellaneous Functions */
{"nexttoward", l_mpfr_nexttoward},
{"nextabove", l_mpfr_nextabove},
{"nextbelow", l_mpfr_nextbelow},
{"min", l_mpfr_min},
{"max", l_mpfr_max},
{"urandomb", l_mpfr_urandomb},
{"urandom", l_mpfr_urandom},
{"grandom", l_mpfr_grandom},
{"get_exp", l_mpfr_get_exp},
{"set_exp", l_mpfr_set_exp},
{"signbit", l_mpfr_signbit},
{"setsign", l_mpfr_setsign},
{"copysign", l_mpfr_copysign},
{"get_version", l_mpfr_get_version},
{"get_patches", l_mpfr_get_patches},
{"buildopt_tls_p", l_mpfr_buildopt_tls_p},
{"buildopt_decimal_p", l_mpfr_buildopt_decimal_p},
{"buildopt_gmpinternals_p", l_mpfr_buildopt_gmpinternals_p},
{"buildopt_tune_case", l_mpfr_buildopt_tune_case},
/* 5.13 Exception Related Functions */
{"get_emin", l_mpfr_get_emin},
{"get_emax", l_mpfr_get_emax},
{"set_emin", l_mpfr_set_emin},
{"set_emax", l_mpfr_set_emax},
{"get_emin_min", l_mpfr_get_emin_min},
{"get_emin_max", l_mpfr_get_emin_max},
{"get_emax_min", l_mpfr_get_emax_min},
{"get_emax_max", l_mpfr_get_emax_max},
{"check_range", l_mpfr_check_range},
{"subnormalize", l_mpfr_subnormalize},
{"clear_underflow", l_mpfr_clear_underflow},
{"clear_overflow", l_mpfr_clear_overflow},
{"clear_divby0", l_mpfr_clear_divby0},
{"clear_nanflag", l_mpfr_clear_nanflag},
{"clear_inexflag", l_mpfr_clear_inexflag},
{"clear_erangeflag", l_mpfr_clear_erangeflag},
{"set_underflow", l_mpfr_set_underflow},
{"set_overflow", l_mpfr_set_overflow},
{"set_divby0", l_mpfr_set_divby0},
{"set_nanflag", l_mpfr_set_nanflag},
{"set_inexflag", l_mpfr_set_inexflag},
{"set_erangeflag", l_mpfr_set_erangeflag},
{"clear_flags", l_mpfr_clear_flags},
{"underflow_p", l_mpfr_underflow_p},
{"overflow_p", l_mpfr_overflow_p},
{"divby0_p", l_mpfr_divby0_p},
{"nanflag_p", l_mpfr_nanflag_p},
{"inexflag_p", l_mpfr_inexflag_p},
{"erangeflag_p", l_mpfr_erangeflag_p},
/* 5.14 Compatibility With MPF */
{"set_prec_raw", l_mpfr_set_prec_raw},
{"eq", l_mpfr_eq},
{"reldiff", l_mpfr_reldiff},
{"mul_2exp", l_mpfr_mul_2exp},
{"div_2exp", l_mpfr_div_2exp},
/* 5.15 Custom Interface */
{"custom_get_size", l_mpfr_custom_get_size},
{"custom_init", l_mpfr_custom_init},
{"custom_init_set", l_mpfr_custom_init_set},
{"custom_get_kind", l_mpfr_custom_get_kind},
{"custom_get_significand", l_mpfr_custom_get_significand},
{"custom_get_exp", l_mpfr_custom_get_exp},
{"custom_move", l_mpfr_custom_move},
{NULL, NULL} /* sentinel */
};
/**********************************************************************/
static int m__add(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
lua_Number n1, n2;
lua_Integer i1, i2;
int t1, t2;
mpfr_rnd_t rnd;
rop = new_mpfr_t(L);
mpfr_init(*rop);
rnd = mpfr_get_default_rounding_mode();
t1 = lua_type(L, 1);
t2 = lua_type(L, 2);
if ((t1 == LUA_TUSERDATA) && (t2 == LUA_TUSERDATA)) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
(void) mpfr_add(*rop, *op1, *op2, rnd);
} else if (t1 == LUA_TUSERDATA) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n2 = luaL_checknumber(L, 2);
if (lua_isinteger(L, 2)) {
(void) lua_numbertointeger(n2, &i2);
(void) mpfr_add_si(*rop, *op1, i2, rnd);
} else
(void) mpfr_add_d(*rop, *op1, n2, rnd);
} else if (t2 == LUA_TUSERDATA) {
n1 = luaL_checknumber(L, 1);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
if (lua_isinteger(L, 1)) {
(void) lua_numbertointeger(n1, &i1);
(void) mpfr_add_si(*rop, *op2, i1, rnd);
} else
(void) mpfr_add_d(*rop, *op2, n1, rnd);
} else
assert(0);
return 1;
}
static int m__sub(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
lua_Number n1, n2;
lua_Integer i1, i2;
int t1, t2;
mpfr_rnd_t rnd;
rop = new_mpfr_t(L);
mpfr_init(*rop);
rnd = mpfr_get_default_rounding_mode();
t1 = lua_type(L, 1);
t2 = lua_type(L, 2);
if ((t1 == LUA_TUSERDATA) && (t2 == LUA_TUSERDATA)) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
(void) mpfr_sub(*rop, *op1, *op2, rnd);
} else if (t1 == LUA_TUSERDATA) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n2 = luaL_checknumber(L, 2);
if (lua_isinteger(L, 2)) {
(void) lua_numbertointeger(n2, &i2);
(void) mpfr_sub_si(*rop, *op1, i2, rnd);
} else
(void) mpfr_sub_d(*rop, *op1, n2, rnd);
} else if (t2 == LUA_TUSERDATA) {
n1 = luaL_checknumber(L, 1);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
if (lua_isinteger(L, 1)) {
(void) lua_numbertointeger(n1, &i1);
(void) mpfr_si_sub(*rop, i1, *op2, rnd);
} else
(void) mpfr_d_sub(*rop, n1, *op2, rnd);
} else
assert(0);
return 1;
}
static int m__mul(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
lua_Number n1, n2;
lua_Integer i1, i2;
int t1, t2;
mpfr_rnd_t rnd;
rop = new_mpfr_t(L);
mpfr_init(*rop);
rnd = mpfr_get_default_rounding_mode();
t1 = lua_type(L, 1);
t2 = lua_type(L, 2);
if ((t1 == LUA_TUSERDATA) && (t2 == LUA_TUSERDATA)) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
(void) mpfr_mul(*rop, *op1, *op2, rnd);
} else if (t1 == LUA_TUSERDATA) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n2 = luaL_checknumber(L, 2);
if (lua_isinteger(L, 2)) {
(void) lua_numbertointeger(n2, &i2);
(void) mpfr_mul_si(*rop, *op1, i2, rnd);
} else
(void) mpfr_mul_d(*rop, *op1, n2, rnd);
} else if (t2 == LUA_TUSERDATA) {
n1 = luaL_checknumber(L, 1);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
if (lua_isinteger(L, 1)) {
(void) lua_numbertointeger(n1, &i1);
(void) mpfr_mul_si(*rop, *op2, i1, rnd);
} else
(void) mpfr_mul_d(*rop, *op2, n1, rnd);
} else
assert(0);
return 1;
}
static int m__div(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
lua_Number n1, n2;
lua_Integer i1, i2;
int t1, t2;
mpfr_rnd_t rnd;
rop = new_mpfr_t(L);
mpfr_init(*rop);
rnd = mpfr_get_default_rounding_mode();
t1 = lua_type(L, 1);
t2 = lua_type(L, 2);
if ((t1 == LUA_TUSERDATA) && (t2 == LUA_TUSERDATA)) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
(void) mpfr_div(*rop, *op1, *op2, rnd);
} else if (t1 == LUA_TUSERDATA) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n2 = luaL_checknumber(L, 2);
if (lua_isinteger(L, 2)) {
(void) lua_numbertointeger(n2, &i2);
(void) mpfr_div_si(*rop, *op1, i2, rnd);
} else
(void) mpfr_div_d(*rop, *op1, n2, rnd);
} else if (t2 == LUA_TUSERDATA) {
n1 = luaL_checknumber(L, 1);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
if (lua_isinteger(L, 1)) {
(void) lua_numbertointeger(n1, &i1);
(void) mpfr_si_div(*rop, i1, *op2, rnd);
} else
(void) mpfr_d_div(*rop, n1, *op2, rnd);
} else
assert(0);
return 1;
}
static int m__pow(lua_State * L)
{
mpfr_t *rop, *op1, *op2;
lua_Number n2;
lua_Integer i2;
int t1, t2;
mpfr_rnd_t rnd;
rop = new_mpfr_t(L);
mpfr_init(*rop);
rnd = mpfr_get_default_rounding_mode();
t1 = lua_type(L, 1);
t2 = lua_type(L, 2);
if ((t1 == LUA_TUSERDATA) && (t2 == LUA_TUSERDATA)) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
(void) mpfr_pow(*rop, *op1, *op2, rnd);
} else if (t1 == LUA_TUSERDATA) {
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
n2 = luaL_checknumber(L, 2);
if (lua_isinteger(L, 2)) {
(void) lua_numbertointeger(n2, &i2);
(void) mpfr_pow_si(*rop, *op1, i2, rnd);
} else
luaL_error(L, "not implemented yet");
} else
luaL_error(L, "not implemented yet");
return 1;
}
static int m__unm(lua_State * L)
{
mpfr_t *rop, *op;
mpfr_rnd_t rnd;
op = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t); /* op */
rop = new_mpfr_t(L);
mpfr_init(*rop);
rnd = mpfr_get_default_rounding_mode();
(void) mpfr_neg(*rop, *op, rnd); /* rop op */
return 1;
}
static int m__eq(lua_State * L)
{
mpfr_t *op1, *op2;
int i;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
i = mpfr_equal_p(*op1, *op2);
lua_pushboolean(L, i);
return 1;
}
static int m__lt(lua_State * L)
{
mpfr_t *op1, *op2;
int i;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
i = mpfr_less_p(*op1, *op2);
lua_pushboolean(L, i);
return 1;
}
static int m__le(lua_State * L)
{
mpfr_t *op1, *op2;
int i;
op1 = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
op2 = (mpfr_t *) luaL_checkudata(L, 2, M_mpfr_t);
i = mpfr_lessequal_p(*op1, *op2);
lua_pushboolean(L, i);
return 1;
}
static int m__gc(lua_State * L)
{
mpfr_t *x;
x = (mpfr_t *) luaL_checkudata(L, 1, M_mpfr_t);
mpfr_clear(*x);
return 0;
}
static const struct luaL_Reg libmpfr_t_m[] = {
/* 5.1 Initialization Functions */
{"clear", l_mpfr_clear},
/* 5.2 Assignment Functions */
{"set", l_mpfr_set},
{"set_ui", l_mpfr_set_ui},
{"set_si", l_mpfr_set_si},
{"set_uj", l_mpfr_set_uj},
{"set_sj", l_mpfr_set_sj},
{"set_flt", l_mpfr_set_flt},
{"set_d", l_mpfr_set_d},
{"set_ld", l_mpfr_set_ld},
{"set_decimal64", l_mpfr_set_decimal64},
{"set_z", l_mpfr_set_z},
{"set_q", l_mpfr_set_q},
{"set_f", l_mpfr_set_f},
{"set_ui_2exp", l_mpfr_set_ui_2exp},
{"set_si_2exp", l_mpfr_set_si_2exp},
{"set_uj_2exp", l_mpfr_set_uj_2exp},
{"set_sj_2exp", l_mpfr_set_sj_2exp},
{"set_z_2exp", l_mpfr_set_z_2exp},
{"set_str", l_mpfr_set_str},
{"set_strtofr", l_mpfr_strtofr},
{"set_nan", l_mpfr_set_nan},
{"set_inf", l_mpfr_set_inf},
{"set_zero", l_mpfr_set_zero},
{"swap", l_mpfr_swap},
/* 5.3 Combined Initialization and Assignment Functions */
/* 5.4 Conversion Functions */
{"get_flt", l_mpfr_get_flt},
{"get_d", l_mpfr_get_d},
{"get_ld", l_mpfr_get_ld},
{"get_decimal64", l_mpfr_get_decimal64},
{"get_si", l_mpfr_get_si},
{"get_ui", l_mpfr_get_ui},
{"get_sj", l_mpfr_get_sj},
{"get_sj", l_mpfr_get_uj},
{"get_d_2exp", l_mpfr_get_d_2exp},
{"get_ld_2exp", l_mpfr_get_ld_2exp},
{"frexp", l_mpfr_frexp},
{"get_z_2exp", l_mpfr_get_z_2exp},
{"get_z", l_mpfr_get_z},
{"get_f", l_mpfr_get_f},
{"get_str", l_mpfr_get_str},
{"free_str", l_mpfr_free_str},
{"fits_ulong_p", l_mpfr_fits_ulong_p},
{"fits_slong_p", l_mpfr_fits_slong_p},
{"fits_uint_p", l_mpfr_fits_uint_p},
{"fits_sint_p", l_mpfr_fits_sint_p},
{"fits_ushort_p", l_mpfr_fits_ushort_p},
{"fits_sshort_p", l_mpfr_fits_sshort_p},
{"fits_uintmax_p", l_mpfr_fits_uintmax_p},
{"fits_intmax_p", l_mpfr_fits_intmax_p},
/* 5.5 Basic Arithmetic Functions */
{"add", l_mpfr_add},
{"add_ui", l_mpfr_add_ui},
{"add_si", l_mpfr_add_si},
{"add_d", l_mpfr_add_d},
{"add_z", l_mpfr_add_z},
{"add_q", l_mpfr_add_q},
{"sub", l_mpfr_sub},
{"ui_sub", l_mpfr_ui_sub},
{"sub_ui", l_mpfr_sub_ui},
{"si_sub", l_mpfr_si_sub},
{"sub_si", l_mpfr_sub_si},
{"d_sub", l_mpfr_d_sub},
{"sub_d", l_mpfr_sub_d},
{"z_sub", l_mpfr_z_sub},
{"sub_z", l_mpfr_sub_z},
{"sub_q", l_mpfr_sub_q},
{"mul", l_mpfr_mul},
{"mul_ui", l_mpfr_mul_ui},
{"mul_si", l_mpfr_mul_si},
{"mul_d", l_mpfr_mul_d},
{"mul_z", l_mpfr_mul_z},
{"mul_q", l_mpfr_mul_q},
{"sqr", l_mpfr_sqr},
{"div", l_mpfr_div},
{"ui_div", l_mpfr_ui_div},
{"div_ui", l_mpfr_div_ui},
{"si_div", l_mpfr_si_div},
{"div_si", l_mpfr_div_si},
{"div_d", l_mpfr_div_d},
{"div_z", l_mpfr_div_z},
{"div_q", l_mpfr_div_q},
{"sqrt", l_mpfr_sqrt},
{"sqrt_ui", l_mpfr_sqrt_ui},
{"rec_sqrt", l_mpfr_rec_sqrt},
{"cbrt", l_mpfr_cbrt},
{"root", l_mpfr_root},
{"pow", l_mpfr_pow},
{"pow_ui", l_mpfr_pow_ui},
{"pow_si", l_mpfr_pow_si},
{"pow_z", l_mpfr_pow_z},
{"ui_pow_ui", l_mpfr_ui_pow_ui},
{"ui_pow", l_mpfr_ui_pow},
{"neg", l_mpfr_neg},
{"abs", l_mpfr_abs},
{"dim", l_mpfr_dim},
{"mul_2ui", l_mpfr_mul_2ui},
{"mul_2si", l_mpfr_mul_2si},
{"div_2ui", l_mpfr_div_2ui},
{"div_2si", l_mpfr_div_2si},
/* 5.5 Basic Arithmetic Functions */
{"add", l_mpfr_add},
{"add_ui", l_mpfr_add_ui},
{"add_si", l_mpfr_add_si},
{"add_d", l_mpfr_add_d},
{"add_z", l_mpfr_add_z},
{"add_q", l_mpfr_add_q},
{"sub", l_mpfr_sub},
{"ui_sub", l_mpfr_ui_sub},
{"sub_ui", l_mpfr_sub_ui},
{"si_sub", l_mpfr_si_sub},
{"sub_si", l_mpfr_sub_si},
{"d_sub", l_mpfr_d_sub},
{"sub_d", l_mpfr_sub_d},
{"z_sub", l_mpfr_z_sub},
{"sub_z", l_mpfr_sub_z},
{"sub_q", l_mpfr_sub_q},
{"mul", l_mpfr_mul},
{"mul_ui", l_mpfr_mul_ui},
{"mul_si", l_mpfr_mul_si},
{"mul_d", l_mpfr_mul_d},
{"mul_z", l_mpfr_mul_z},
{"mul_q", l_mpfr_mul_q},
{"sqr", l_mpfr_sqr},
{"div", l_mpfr_div},
{"ui_div", l_mpfr_ui_div},
{"div_ui", l_mpfr_div_ui},
{"si_div", l_mpfr_si_div},
{"div_si", l_mpfr_div_si},
{"div_d", l_mpfr_div_d},
{"div_z", l_mpfr_div_z},
{"div_q", l_mpfr_div_q},
{"sqrt", l_mpfr_sqrt},
{"sqrt_ui", l_mpfr_sqrt_ui},
{"rec_sqrt", l_mpfr_rec_sqrt},
{"cbrt", l_mpfr_cbrt},
{"root", l_mpfr_root},
{"pow", l_mpfr_pow},
{"pow_ui", l_mpfr_pow_ui},
{"pow_si", l_mpfr_pow_si},
{"pow_z", l_mpfr_pow_z},
{"ui_pow_ui", l_mpfr_ui_pow_ui},
{"ui_pow", l_mpfr_ui_pow},
{"neg", l_mpfr_neg},
{"abs", l_mpfr_abs},
{"dim", l_mpfr_dim},
{"mul_2ui", l_mpfr_mul_2ui},
{"mul_2si", l_mpfr_mul_2si},
{"div_2ui", l_mpfr_div_2ui},
{"div_2si", l_mpfr_div_2si},
/* 5.6 Comparison Functions */
{"cmp", l_mpfr_cmp},
{"cmp_ui", l_mpfr_cmp_ui},
{"cmp_si", l_mpfr_cmp_si},
{"cmp_d", l_mpfr_cmp_d},
{"cmp_ld", l_mpfr_cmp_ld},
{"cmp_z", l_mpfr_cmp_z},
{"cmp_q", l_mpfr_cmp_q},
{"cmp_f", l_mpfr_cmp_f},
{"cmp_ui_2exp", l_mpfr_cmp_ui_2exp},
{"cmp_si_2exp", l_mpfr_cmp_si_2exp},
{"cmpabs", l_mpfr_cmpabs},
{"nan_p", l_mpfr_nan_p},
{"inf_p", l_mpfr_inf_p},
{"number_p", l_mpfr_number_p},
{"zero_p", l_mpfr_zero_p},
{"regular_p", l_mpfr_regular_p},
{"sgn", l_mpfr_sgn},
{"greater_p", l_mpfr_greater_p},
{"greaterequal_p", l_mpfr_greaterequal_p},
{"less_p", l_mpfr_less_p},
{"lessequal_p", l_mpfr_lessequal_p},
{"equal_p", l_mpfr_equal_p},
{"lessgreater_p", l_mpfr_lessgreater_p},
{"unordered_p", l_mpfr_unordered_p},
/* 5.7 Special Functions */
{"log", l_mpfr_log},
{"log2", l_mpfr_log2},
{"log10", l_mpfr_log10},
{"exp", l_mpfr_exp},
{"exp2", l_mpfr_exp2},
{"exp10", l_mpfr_exp10},
{"cos", l_mpfr_cos},
{"sin", l_mpfr_sin},
{"tan", l_mpfr_tan},
/* {"sin_cos", l_mpfr_sin_cos}, */
{"sec", l_mpfr_sec},
{"csc", l_mpfr_csc},
{"cot", l_mpfr_cot},
{"acos", l_mpfr_acos},
{"asin", l_mpfr_asin},
{"atan", l_mpfr_atan},
{"atan2", l_mpfr_atan2},
{"cosh", l_mpfr_cosh},
{"sinh", l_mpfr_sinh},
{"tanh", l_mpfr_tanh},
/* {"sinh_cosh", l_mpfr_sinh_cosh}, */
{"sech", l_mpfr_sech},
{"csch", l_mpfr_csch},
{"coth", l_mpfr_coth},
{"acosh", l_mpfr_acosh},
{"asinh", l_mpfr_asinh},
{"atanh", l_mpfr_atanh},
{"fac_ui", l_mpfr_fac_ui},
{"log1p", l_mpfr_log1p},
{"expm1", l_mpfr_expm1},
{"eint", l_mpfr_eint},
{"li2", l_mpfr_li2},
{"gamma", l_mpfr_gamma},
{"lngamma", l_mpfr_lngamma},
{"lgamma", l_mpfr_lgamma},
{"digamma", l_mpfr_digamma},
{"zeta", l_mpfr_zeta},
{"zeta_ui", l_mpfr_zeta_ui},
{"erf", l_mpfr_erf},
{"erfc", l_mpfr_erfc},
{"j0", l_mpfr_j0},
{"j1", l_mpfr_j1},
{"jn", l_mpfr_jn},
{"y0", l_mpfr_y0},
{"y1", l_mpfr_y1},
{"yn", l_mpfr_yn},
{"fma", l_mpfr_fma},
{"fms", l_mpfr_fms},
{"agm", l_mpfr_agm},
{"hypot", l_mpfr_hypot},
{"ai", l_mpfr_ai},
{"const_log2", l_mpfr_const_log2},
{"const_pi", l_mpfr_const_pi},
{"const_euler", l_mpfr_const_euler},
{"const_catalan", l_mpfr_const_catalan},
/* {"free_cache", l_mpfr_free_cache}, */
{"sum", l_mpfr_sum},
/* 5.8 Input and Output Functions */
/* 5.9 Formatted Output Functions */
{"printf", l_mpfr_printf},
{"snprintf", l_mpfr_snprintf},
/* 5.10 Integer and Remainder Related Functions */
{"rint", l_mpfr_rint},
{"ceil", l_mpfr_ceil},
{"floor", l_mpfr_floor},
{"round", l_mpfr_round},
{"trunc", l_mpfr_trunc},
{"rint_ceil", l_mpfr_rint_ceil},
{"rint_floor", l_mpfr_rint_floor},
{"rint_round", l_mpfr_rint_round},
{"rint_trunc", l_mpfr_rint_trunc},
{"frac", l_mpfr_frac},
{"modf", l_mpfr_modf},
{"fmod", l_mpfr_fmod},
{"remainder", l_mpfr_remainder},
{"remquo", l_mpfr_remquo},
{"integer_p", l_mpfr_integer_p},
/* 5.11 Rounding Related Functions */
/* 5.12 Miscellaneous Functions */
/* 5.13 Exception Related Functions */
/* 5.14 Compatibility With MPF */
/* 5.15 Custom Interface */
{"__add", m__add},
{"__sub", m__sub},
{"__mul", m__mul},
{"__div", m__div},
{"__pow", m__pow},
{"__unm", m__unm},
{"__eq", m__eq},
{"__lt", m__lt},
{"__le", m__le},
{"__gc", m__gc},
{NULL, NULL} /* sentinel */
};
/**********************************************************************/
int luaopen_lmpfrlib(lua_State * L)
{
luaL_newmetatable(L, M_mpfr_t);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
lua_pushstring(L, "no user access");
lua_setfield(L, -2, "__metatable");
luaL_setfuncs(L, libmpfr_t_m, 0);
luaL_newlib(L, libmpfr_t_f);
return 1;
}