xref: /netbsd-src/lib/lua/libm/libm.c (revision ecbe1e9db9fad3850893dc7888a128ce02d9b745)

/* $NetBSD: libm.c,v 1.2 2022/11/23 18:15:43 christos Exp $	*/

/*-
 * Copyright (c) 2022 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Phillip Rulon
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <sys/cdefs.h>
__RCSID("$NetBSD: libm.c,v 1.2 2022/11/23 18:15:43 christos Exp $");

#include <lua.h>
#include <lauxlib.h>
#include <math.h>

const char	badarg[] = "argument to libm function not a number";

/*-
 * The majority of libm functions fall into a few forms:
 *
 *   int func(double);
 *   double func(double);
 *   double func(double, double);
 * and,
 *   double func(int, double);
 *
 * Accordingly, this lends itself to systematic declaration of the lua
 * interface functions.  These macros set this up.
 */
#define BFUNC_DBL(fname)			\
static int					\
libm_##fname(lua_State *L)			\
{						\
	if (!lua_isnumber(L, 1))		\
		return luaL_error(L, badarg);	\
						\
	double x = lua_tonumber(L, 1);		\
	lua_pushboolean(L, fname(x));		\
	return 1;				\
}

#define DFUNC_DBL(fname)			\
static int					\
libm_##fname(lua_State *L)			\
{						\
	if (!lua_isnumber(L, 1)) 		\
    		return luaL_error(L, badarg);	\
						\
	double x = lua_tonumber(L, 1);		\
	lua_pushnumber(L, fname(x));		\
	return 1;				\
}

#define DFUNC_INT_DBL(fname)			\
static int					\
libm_##fname(lua_State *L)			\
{						\
	if (!lua_isinteger(L, 1) ||		\
	    !lua_isnumber(L, 2))		\
    		return luaL_error(L, badarg);	\
						\
	int i = (int)lua_tointeger(L, 1);	\
	double x = lua_tonumber(L, 2);		\
	lua_pushnumber(L, fname(i, x));		\
	return 1;				\
}

#define DFUNC_DBL_DBL(fname)			\
static int					\
libm_##fname(lua_State *L)			\
{						\
	if (!lua_isnumber(L, 1) ||		\
	    !lua_isnumber(L, 2))		\
    		return luaL_error(L, badarg);	\
	double x[] = {				\
	    lua_tonumber(L, 1),			\
	    lua_tonumber(L,2)			\
	};					\
	lua_pushnumber(L, fname(x[0], x[1]));   \
	return 1;				\
}

int	luaopen_libm(lua_State *);

DFUNC_DBL(acos)
DFUNC_DBL(acosh)
DFUNC_DBL(asin)
DFUNC_DBL(asinh)
DFUNC_DBL(atan)
DFUNC_DBL(atanh)
DFUNC_DBL_DBL(atan2)
DFUNC_DBL(cbrt)
DFUNC_DBL(ceil)
DFUNC_DBL_DBL(copysign)
DFUNC_DBL(cos)
DFUNC_DBL(cosh)
DFUNC_DBL(erf)
DFUNC_DBL(erfc)
DFUNC_DBL(exp)
DFUNC_DBL(exp2)
DFUNC_DBL(expm1)
DFUNC_DBL(fabs)
DFUNC_DBL_DBL(fdim)
BFUNC_DBL(finite)
DFUNC_DBL(floor)
DFUNC_DBL_DBL(fmax)
DFUNC_DBL_DBL(fmin)
DFUNC_DBL_DBL(fmod)
DFUNC_DBL(gamma)
DFUNC_DBL_DBL(hypot)
BFUNC_DBL(isfinite)
BFUNC_DBL(isnan)
BFUNC_DBL(isinf)
DFUNC_DBL(j0)
DFUNC_DBL(j1)
DFUNC_INT_DBL(jn)
DFUNC_DBL(lgamma)
DFUNC_DBL(log)
DFUNC_DBL(log10)
DFUNC_DBL(log1p)
#ifndef __vax__
DFUNC_DBL_DBL(nextafter)
#endif
DFUNC_DBL_DBL(pow)
DFUNC_DBL_DBL(remainder)
DFUNC_DBL(rint)
DFUNC_DBL(round)
DFUNC_DBL(sin)
DFUNC_DBL(sinh)
DFUNC_DBL(sqrt)
DFUNC_DBL(tan)
DFUNC_DBL(tanh)
DFUNC_DBL(trunc)
DFUNC_DBL(y0)
DFUNC_DBL(y1)
DFUNC_INT_DBL(yn)

/*
 * The following interface functions are special cases which do not lend
 * themseleves to the systematic declaration scheme above.
 */
static int
libm_fma(lua_State *L)
{
	if (!lua_isnumber(L, 1) ||
	    !lua_isnumber(L, 2) ||
	    !lua_isnumber(L, 3))
		return luaL_error(L, badarg);

	double	x[] = {
	    lua_tonumber(L, 1),
	    lua_tonumber(L, 2),
	    lua_tonumber(L, 3)
	};
	lua_pushnumber(L, fma(x[0], x[1], x[2]));
	return 1;
}

static int
libm_nan(lua_State *L)
{
	if (!lua_isstring(L, 1))
		return luaL_error(L, badarg);

	const char     *str = luaL_checkstring(L, 1);
	lua_pushnumber(L, nan(str));
	return 1;
}

static int
libm_scalbn(lua_State *L)
{
	if (!lua_isnumber(L, 1) || !lua_isinteger(L, 2))
		return luaL_error(L, badarg);

	double		x = lua_tonumber(L, 1);
	int		i = (int)lua_tointeger(L, 2);
	lua_pushnumber(L, scalbn(x, i));
	return 1;
}

static int
libm_ilogb(lua_State *L)
{
	if (!lua_isnumber(L, 1))
		return luaL_error(L, badarg);

	double		x = lua_tonumber(L, 1);
	lua_pushinteger(L, ilogb(x));
	return 1;
}

/*
 * set up a table for the math.h constants
 */
#define LIBM_CONST(K) {#K, K}
struct kv {
	const char     *k;
	double		v;
};

static const struct kv libm_const[] = {
	LIBM_CONST(M_E),
	LIBM_CONST(M_LOG2E),
	LIBM_CONST(M_LOG10E),
	LIBM_CONST(M_LN2),
	LIBM_CONST(M_LN10),
	LIBM_CONST(M_PI),
	LIBM_CONST(M_PI_2),
	LIBM_CONST(M_PI_4),
	LIBM_CONST(M_1_PI),
	LIBM_CONST(M_2_PI),
	LIBM_CONST(M_2_SQRTPI),
	LIBM_CONST(M_SQRT2),
	LIBM_CONST(M_SQRT1_2),
	{ NULL, 0 }
};


static const struct luaL_Reg lualibm[] = {
	{ "acos", libm_acos },
	{ "acosh", libm_acosh },
	{ "asin", libm_asin },
	{ "asinh", libm_asinh },
	{ "atan", libm_atan },
	{ "atanh", libm_atanh },
	{ "atan2", libm_atan2 },
	{ "cbrt", libm_cbrt },
	{ "ceil", libm_ceil },
	{ "copysign", libm_copysign },
	{ "cos", libm_cos },
	{ "cosh", libm_cosh },
	{ "erf", libm_erf },
	{ "erfc", libm_erfc },
	{ "exp", libm_exp },
	{ "exp2", libm_exp2 },
	{ "expm1", libm_expm1 },
	{ "fabs", libm_fabs },
	{ "fdim", libm_fdim },
	{ "finite", libm_finite },
	{ "floor", libm_floor },
	{ "fma", libm_fma },
	{ "fmax", libm_fmax },
	{ "fmin", libm_fmin },
	{ "fmod", libm_fmod },
	{ "gamma", libm_gamma },
	{ "hypot", libm_hypot },
	{ "ilogb", libm_ilogb },
	{ "isfinite", libm_isfinite },
	{ "isinf", libm_isinf },
	{ "isnan", libm_isnan },
	{ "j0", libm_j0 },
	{ "j1", libm_j1 },
	{ "jn", libm_jn },
	{ "lgamma", libm_lgamma },
	{ "log", libm_log },
	{ "log10", libm_log10 },
	{ "log1p", libm_log1p },
	{ "nan", libm_nan },
#ifndef __vax__
	{ "nextafter", libm_nextafter },
#endif
	{ "pow", libm_pow },
	{ "remainder", libm_remainder },
	{ "rint", libm_rint },
	{ "round", libm_round },
	{ "scalbn", libm_scalbn },
	{ "sin", libm_sin },
	{ "sinh", libm_sinh },
	{ "sqrt", libm_sqrt },
	{ "tan", libm_tan },
	{ "tanh", libm_tanh },
	{ "trunc", libm_trunc },
	{ "y0", libm_y0 },
	{ "y1", libm_y1 },
	{ "yn", libm_yn },
	{ NULL, NULL }
};

int
luaopen_libm(lua_State *L)
{
	const struct kv *kvp = libm_const;

	luaL_newlib(L, lualibm);

	/* integrate the math.h constants */
	while (kvp->k) {
		lua_pushnumber(L, kvp->v);
		lua_setfield(L, -2, kvp->k);
		kvp++;
	}

	return 1;
}