/* Primitive operations on floating point for GNU Emacs Lisp interpreter.
Copyright (C) 1988, 1993-1994, 1999, 2001-2020 Free Software Foundation,
Inc.
Author: Wolfgang Rupprecht (according to ack.texi)
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
GNU Emacs 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
/* C89 requires only the following math.h functions, and Emacs omits
the starred functions since we haven't found a use for them:
acos, asin, atan, atan2, ceil, cos, *cosh, exp, fabs, floor, fmod,
frexp, ldexp, log, log10 [via (log X 10)], *modf, pow, sin, *sinh,
sqrt, tan, *tanh.
C99 and C11 require the following math.h functions in addition to
the C89 functions. Of these, Emacs currently exports only the
starred ones to Lisp, since we haven't found a use for the others:
acosh, atanh, cbrt, *copysign, erf, erfc, exp2, expm1, fdim, fma,
fmax, fmin, fpclassify, hypot, ilogb, isfinite, isgreater,
isgreaterequal, isinf, isless, islessequal, islessgreater, *isnan,
isnormal, isunordered, lgamma, log1p, *log2 [via (log X 2)], *logb
(approximately), lrint/llrint, lround/llround, nan, nearbyint,
nextafter, nexttoward, remainder, remquo, *rint, round, scalbln,
scalbn, signbit, tgamma, *trunc.
*/
#include <config.h>
#include "lisp.h"
#include "bignum.h"
#include <math.h>
#include <count-leading-zeros.h>
/* Emacs needs proper handling of +/-inf; correct printing as well as
important packages depend on it. Make sure the user didn't specify
-ffinite-math-only, either directly or implicitly with -Ofast or
-ffast-math. */
#if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__
#error Emacs cannot be built with -ffinite-math-only
#endif
/* Check that X is a floating point number. */
static void
CHECK_FLOAT (Lisp_Object x)
{
CHECK_TYPE (FLOATP (x), Qfloatp, x);
}
/* Extract a Lisp number as a `double', or signal an error. */
double
extract_float (Lisp_Object num)
{
CHECK_NUMBER (num);
return XFLOATINT (num);
}
/* Trig functions. */
DEFUN ("acos", Facos, Sacos, 1, 1, 0,
doc: /* Return the inverse cosine of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = acos (d);
return make_float (d);
}
DEFUN ("asin", Fasin, Sasin, 1, 1, 0,
doc: /* Return the inverse sine of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = asin (d);
return make_float (d);
}
DEFUN ("atan", Fatan, Satan, 1, 2, 0,
doc: /* Return the inverse tangent of the arguments.
If only one argument Y is given, return the inverse tangent of Y.
If two arguments Y and X are given, return the inverse tangent of Y
divided by X, i.e. the angle in radians between the vector (X, Y)
and the x-axis. */)
(Lisp_Object y, Lisp_Object x)
{
double d = extract_float (y);
if (NILP (x))
d = atan (d);
else
{
double d2 = extract_float (x);
d = atan2 (d, d2);
}
return make_float (d);
}
DEFUN ("cos", Fcos, Scos, 1, 1, 0,
doc: /* Return the cosine of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = cos (d);
return make_float (d);
}
DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
doc: /* Return the sine of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = sin (d);
return make_float (d);
}
DEFUN ("tan", Ftan, Stan, 1, 1, 0,
doc: /* Return the tangent of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = tan (d);
return make_float (d);
}
DEFUN ("isnan", Fisnan, Sisnan, 1, 1, 0,
doc: /* Return non-nil if argument X is a NaN. */)
(Lisp_Object x)
{
CHECK_FLOAT (x);
return isnan (XFLOAT_DATA (x)) ? Qt : Qnil;
}
/* Although the substitute does not work on NaNs, it is good enough
for platforms lacking the signbit macro. */
#ifndef signbit
# define signbit(x) ((x) < 0 || (IEEE_FLOATING_POINT && !(x) && 1 / (x) < 0))
#endif
DEFUN ("copysign", Fcopysign, Scopysign, 2, 2, 0,
doc: /* Copy sign of X2 to value of X1, and return the result.
Cause an error if X1 or X2 is not a float. */)
(Lisp_Object x1, Lisp_Object x2)
{
double f1, f2;
CHECK_FLOAT (x1);
CHECK_FLOAT (x2);
f1 = XFLOAT_DATA (x1);
f2 = XFLOAT_DATA (x2);
/* Use signbit instead of copysign, to avoid calling make_float when
the result is X1. */
return signbit (f1) != signbit (f2) ? make_float (-f1) : x1;
}
DEFUN ("frexp", Ffrexp, Sfrexp, 1, 1, 0,
doc: /* Get significand and exponent of a floating point number.
Breaks the floating point number X into its binary significand SGNFCAND
\(a floating point value between 0.5 (included) and 1.0 (excluded))
and an integral exponent EXP for 2, such that:
X = SGNFCAND * 2^EXP
The function returns the cons cell (SGNFCAND . EXP).
If X is zero, both parts (SGNFCAND and EXP) are zero. */)
(Lisp_Object x)
{
double f = extract_float (x);
int exponent;
double sgnfcand = frexp (f, &exponent);
return Fcons (make_float (sgnfcand), make_fixnum (exponent));
}
DEFUN ("ldexp", Fldexp, Sldexp, 2, 2, 0,
doc: /* Return SGNFCAND * 2**EXPONENT, as a floating point number.
EXPONENT must be an integer. */)
(Lisp_Object sgnfcand, Lisp_Object exponent)
{
CHECK_FIXNUM (exponent);
int e = min (max (INT_MIN, XFIXNUM (exponent)), INT_MAX);
return make_float (ldexp (extract_float (sgnfcand), e));
}
DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
doc: /* Return the exponential base e of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = exp (d);
return make_float (d);
}
DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
doc: /* Return the exponential ARG1 ** ARG2. */)
(Lisp_Object arg1, Lisp_Object arg2)
{
CHECK_NUMBER (arg1);
CHECK_NUMBER (arg2);
/* Common Lisp spec: don't promote if both are integers, and if the
result is not fractional. */
if (INTEGERP (arg1) && !NILP (Fnatnump (arg2)))
return expt_integer (arg1, arg2);
return make_float (pow (XFLOATINT (arg1), XFLOATINT (arg2)));
}
DEFUN ("log", Flog, Slog, 1, 2, 0,
doc: /* Return the natural logarithm of ARG.
If the optional argument BASE is given, return log ARG using that base. */)
(Lisp_Object arg, Lisp_Object base)
{
double d = extract_float (arg);
if (NILP (base))
d = log (d);
else
{
double b = extract_float (base);
if (b == 10.0)
d = log10 (d);
#if HAVE_LOG2
else if (b == 2.0)
d = log2 (d);
#endif
else
d = log (d) / log (b);
}
return make_float (d);
}
DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
doc: /* Return the square root of ARG. */)
(Lisp_Object arg)
{
double d = extract_float (arg);
d = sqrt (d);
return make_float (d);
}
DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
doc: /* Return the absolute value of ARG. */)
(Lisp_Object arg)
{
CHECK_NUMBER (arg);
if (FIXNUMP (arg))
{
if (XFIXNUM (arg) < 0)
arg = make_int (-XFIXNUM (arg));
}
else if (FLOATP (arg))
{
if (signbit (XFLOAT_DATA (arg)))
arg = make_float (- XFLOAT_DATA (arg));
}
else
{
if (mpz_sgn (*xbignum_val (arg)) < 0)
{
mpz_neg (mpz[0], *xbignum_val (arg));
arg = make_integer_mpz ();
}
}
return arg;
}
DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
doc: /* Return the floating point number equal to ARG. */)
(register Lisp_Object arg)
{
CHECK_NUMBER (arg);
/* If ARG is a float, give 'em the same float back. */
return FLOATP (arg) ? arg : make_float (XFLOATINT (arg));
}
static int
ecount_leading_zeros (EMACS_UINT x)
{
return (EMACS_UINT_WIDTH == UINT_WIDTH ? count_leading_zeros (x)
: EMACS_UINT_WIDTH == ULONG_WIDTH ? count_leading_zeros_l (x)
: count_leading_zeros_ll (x));
}
DEFUN ("logb", Flogb, Slogb, 1, 1, 0,
doc: /* Returns largest integer <= the base 2 log of the magnitude of ARG.
This is the same as the exponent of a float. */)
(Lisp_Object arg)
{
EMACS_INT value;
CHECK_NUMBER (arg);
if (FLOATP (arg))
{
double f = XFLOAT_DATA (arg);
if (f == 0)
return make_float (-HUGE_VAL);
if (!isfinite (f))
return f < 0 ? make_float (-f) : arg;
int ivalue;
frexp (f, &ivalue);
value = ivalue - 1;
}
else if (!FIXNUMP (arg))
value = mpz_sizeinbase (*xbignum_val (arg), 2) - 1;
else
{
EMACS_INT i = XFIXNUM (arg);
if (i == 0)
return make_float (-HUGE_VAL);
value = EMACS_UINT_WIDTH - 1 - ecount_leading_zeros (eabs (i));
}
return make_fixnum (value);
}
/* Return the integer exponent E such that D * FLT_RADIX**E (i.e.,
scalbn (D, E)) is an integer that has precision equal to D and is
representable as a double.
Return DBL_MANT_DIG - DBL_MIN_EXP (the maximum possible valid
scale) if D is zero or tiny. Return one greater than that if
D is infinite, and two greater than that if D is a NaN. */
int
double_integer_scale (double d)
{
int exponent = ilogb (d);
return (DBL_MIN_EXP - 1 <= exponent && exponent < INT_MAX
? DBL_MANT_DIG - 1 - exponent
: (DBL_MANT_DIG - DBL_MIN_EXP
+ (isnan (d) ? 2 : exponent == INT_MAX)));
}
/* Convert the Lisp number N to an integer and return a pointer to the
converted integer, represented as an mpz_t *. Use *T as a
temporary; the returned value might be T. Scale N by the maximum
of NSCALE and DSCALE while converting. If NSCALE is nonzero, N
must be a float; signal an overflow if NSCALE is greater than
DBL_MANT_DIG - DBL_MIN_EXP, otherwise scalbn (XFLOAT_DATA (N), NSCALE)
must return an integer value, without rounding or overflow. */
static mpz_t const *
rescale_for_division (Lisp_Object n, mpz_t *t, int nscale, int dscale)
{
mpz_t const *pn;
if (FLOATP (n))
{
if (DBL_MANT_DIG - DBL_MIN_EXP < nscale)
overflow_error ();
mpz_set_d (*t, scalbn (XFLOAT_DATA (n), nscale));
pn = t;
}
else
pn = bignum_integer (t, n);
if (nscale < dscale)
{
emacs_mpz_mul_2exp (*t, *pn, (dscale - nscale) * LOG2_FLT_RADIX);
pn = t;
}
return pn;
}
/* the rounding functions */
static Lisp_Object
rounding_driver (Lisp_Object n, Lisp_Object d,
double (*double_round) (double),
void (*int_divide) (mpz_t, mpz_t const, mpz_t const),
EMACS_INT (*fixnum_divide) (EMACS_INT, EMACS_INT))
{
CHECK_NUMBER (n);
if (NILP (d))
return FLOATP (n) ? double_to_integer (double_round (XFLOAT_DATA (n))) : n;
CHECK_NUMBER (d);
int dscale = 0;
if (FIXNUMP (d))
{
if (XFIXNUM (d) == 0)
xsignal0 (Qarith_error);
/* Divide fixnum by fixnum specially, for speed. */
if (FIXNUMP (n))
return make_int (fixnum_divide (XFIXNUM (n), XFIXNUM (d)));
}
else if (FLOATP (d))
{
if (XFLOAT_DATA (d) == 0)
xsignal0 (Qarith_error);
dscale = double_integer_scale (XFLOAT_DATA (d));
}
int nscale = FLOATP (n) ? double_integer_scale (XFLOAT_DATA (n)) : 0;
/* If the numerator is finite and the denominator infinite, the
quotient is zero and there is no need to try the impossible task
of rescaling the denominator. */
if (dscale == DBL_MANT_DIG - DBL_MIN_EXP + 1 && nscale < dscale)
return make_fixnum (0);
int_divide (mpz[0],
*rescale_for_division (n, &mpz[0], nscale, dscale),
*rescale_for_division (d, &mpz[1], dscale, nscale));
return make_integer_mpz ();
}
static EMACS_INT
ceiling2 (EMACS_INT n, EMACS_INT d)
{
return n / d + ((n % d != 0) & ((n < 0) == (d < 0)));
}
static EMACS_INT
floor2 (EMACS_INT n, EMACS_INT d)
{
return n / d - ((n % d != 0) & ((n < 0) != (d < 0)));
}
static EMACS_INT
truncate2 (EMACS_INT n, EMACS_INT d)
{
return n / d;
}
static EMACS_INT
round2 (EMACS_INT n, EMACS_INT d)
{
/* The C language's division operator gives us the remainder R
corresponding to truncated division, but we want the remainder R1
on the other side of 0 if R1 is closer to 0 than R is; because we
want to round to even, we also want R1 if R and R1 are the same
distance from 0 and if the truncated quotient is odd. */
EMACS_INT q = n / d;
EMACS_INT r = n % d;
bool neg_d = d < 0;
bool neg_r = r < 0;
EMACS_INT abs_r = eabs (r);
EMACS_INT abs_r1 = eabs (d) - abs_r;
if (abs_r1 < abs_r + (q & 1))
q += neg_d == neg_r ? 1 : -1;
return q;
}
static void
rounddiv_q (mpz_t q, mpz_t const n, mpz_t const d)
{
/* Mimic the source code of round2, using mpz_t instead of EMACS_INT. */
mpz_t *r = &mpz[2], *abs_r = r, *abs_r1 = &mpz[3];
mpz_tdiv_qr (q, *r, n, d);
bool neg_d = mpz_sgn (d) < 0;
bool neg_r = mpz_sgn (*r) < 0;
mpz_abs (*abs_r, *r);
mpz_abs (*abs_r1, d);
mpz_sub (*abs_r1, *abs_r1, *abs_r);
if (mpz_cmp (*abs_r1, *abs_r) < (mpz_odd_p (q) != 0))
(neg_d == neg_r ? mpz_add_ui : mpz_sub_ui) (q, q, 1);
}
/* The code uses emacs_rint, so that it works to undefine HAVE_RINT
if `rint' exists but does not work right. */
#ifdef HAVE_RINT
#define emacs_rint rint
#else
static double
emacs_rint (double d)
{
double d1 = d + 0.5;
double r = floor (d1);
return r - (r == d1 && fmod (r, 2) != 0);
}
#endif
#ifndef HAVE_TRUNC
double
trunc (double d)
{
return (d < 0 ? ceil : floor) (d);
}
#endif
DEFUN ("ceiling", Fceiling, Sceiling, 1, 2, 0,
doc: /* Return the smallest integer no less than ARG.
This rounds the value towards +inf.
With optional DIVISOR, return the smallest integer no less than ARG/DIVISOR. */)
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, ceil, mpz_cdiv_q, ceiling2);
}
DEFUN ("floor", Ffloor, Sfloor, 1, 2, 0,
doc: /* Return the largest integer no greater than ARG.
This rounds the value towards -inf.
With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR. */)
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, floor, mpz_fdiv_q, floor2);
}
DEFUN ("round", Fround, Sround, 1, 2, 0,
doc: /* Return the nearest integer to ARG.
With optional DIVISOR, return the nearest integer to ARG/DIVISOR.
Rounding a value equidistant between two integers may choose the
integer closer to zero, or it may prefer an even integer, depending on
your machine. For example, (round 2.5) can return 3 on some
systems, but 2 on others. */)
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, emacs_rint, rounddiv_q, round2);
}
/* Since rounding_driver truncates anyway, no need to call 'trunc'. */
static double
identity (double x)
{
return x;
}
DEFUN ("truncate", Ftruncate, Struncate, 1, 2, 0,
doc: /* Truncate a floating point number to an int.
Rounds ARG toward zero.
With optional DIVISOR, truncate ARG/DIVISOR. */)
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, identity, mpz_tdiv_q, truncate2);
}
Lisp_Object
fmod_float (Lisp_Object x, Lisp_Object y)
{
double f1 = XFLOATINT (x);
double f2 = XFLOATINT (y);
f1 = fmod (f1, f2);
/* If the "remainder" comes out with the wrong sign, fix it. */
if (f2 < 0 ? f1 > 0 : f1 < 0)
f1 += f2;
return make_float (f1);
}
DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
doc: /* Return the smallest integer no less than ARG, as a float.
\(Round toward +inf.) */)
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
double d = XFLOAT_DATA (arg);
d = ceil (d);
return make_float (d);
}
DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
doc: /* Return the largest integer no greater than ARG, as a float.
\(Round toward -inf.) */)
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
double d = XFLOAT_DATA (arg);
d = floor (d);
return make_float (d);
}
DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
doc: /* Return the nearest integer to ARG, as a float. */)
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
double d = XFLOAT_DATA (arg);
d = emacs_rint (d);
return make_float (d);
}
DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0,
doc: /* Truncate a floating point number to an integral float value.
\(Round toward zero.) */)
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
double d = XFLOAT_DATA (arg);
d = trunc (d);
return make_float (d);
}
void
syms_of_floatfns (void)
{
defsubr (&Sacos);
defsubr (&Sasin);
defsubr (&Satan);
defsubr (&Scos);
defsubr (&Ssin);
defsubr (&Stan);
defsubr (&Sisnan);
defsubr (&Scopysign);
defsubr (&Sfrexp);
defsubr (&Sldexp);
defsubr (&Sfceiling);
defsubr (&Sffloor);
defsubr (&Sfround);
defsubr (&Sftruncate);
defsubr (&Sexp);
defsubr (&Sexpt);
defsubr (&Slog);
defsubr (&Ssqrt);
defsubr (&Sabs);
defsubr (&Sfloat);
defsubr (&Slogb);
defsubr (&Sceiling);
defsubr (&Sfloor);
defsubr (&Sround);
defsubr (&Struncate);
}