1 /* Primitive operations on floating point for GNU Emacs Lisp interpreter.
2 Copyright (C) 1988, 1993 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* ANSI C requires only these float functions:
22 acos, asin, atan, atan2, ceil, cos, cosh, exp, fabs, floor, fmod,
23 frexp, ldexp, log, log10, modf, pow, sin, sinh, sqrt, tan, tanh.
25 Define HAVE_INVERSE_HYPERBOLIC if you have acosh, asinh, and atanh.
26 Define HAVE_CBRT if you have cbrt.
27 Define HAVE_RINT if you have rint.
28 If you don't define these, then the appropriate routines will be simulated.
30 Define HAVE_MATHERR if on a system supporting the SysV matherr callback.
31 (This should happen automatically.)
33 Define FLOAT_CHECK_ERRNO if the float library routines set errno.
34 This has no effect if HAVE_MATHERR is defined.
36 Define FLOAT_CATCH_SIGILL if the float library routines signal SIGILL.
37 (What systems actually do this? Please let us know.)
39 Define FLOAT_CHECK_DOMAIN if the float library doesn't handle errors by
40 either setting errno, or signalling SIGFPE/SIGILL. Otherwise, domain and
41 range checking will happen before calling the float routines. This has
42 no effect if HAVE_MATHERR is defined (since matherr will be called when
43 a domain error occurs.)
50 #include "syssignal.h"
52 Lisp_Object Qarith_error
;
54 #ifdef LISP_FLOAT_TYPE
58 /* These declarations are omitted on some systems, like Ultrix. */
59 extern double logb ();
61 #if defined(DOMAIN) && defined(SING) && defined(OVERFLOW)
62 /* If those are defined, then this is probably a `matherr' machine. */
73 # ifdef FLOAT_CHECK_ERRNO
74 # undef FLOAT_CHECK_ERRNO
76 # ifdef FLOAT_CHECK_DOMAIN
77 # undef FLOAT_CHECK_DOMAIN
81 #ifndef NO_FLOAT_CHECK_ERRNO
82 #define FLOAT_CHECK_ERRNO
85 #ifdef FLOAT_CHECK_ERRNO
91 /* Avoid traps on VMS from sinh and cosh.
92 All the other functions set errno instead. */
97 #define cosh(x) ((exp(x)+exp(-x))*0.5)
98 #define sinh(x) ((exp(x)-exp(-x))*0.5)
102 #define rint(x) (floor((x)+0.5))
105 static SIGTYPE
float_error ();
107 /* Nonzero while executing in floating point.
108 This tells float_error what to do. */
112 /* If an argument is out of range for a mathematical function,
113 here is the actual argument value to use in the error message. */
115 static Lisp_Object float_error_arg
, float_error_arg2
;
117 static char *float_error_fn_name
;
119 /* Evaluate the floating point expression D, recording NUM
120 as the original argument for error messages.
121 D is normally an assignment expression.
122 Handle errors which may result in signals or may set errno.
124 Note that float_error may be declared to return void, so you can't
125 just cast the zero after the colon to (SIGTYPE) to make the types
128 #ifdef FLOAT_CHECK_ERRNO
129 #define IN_FLOAT(d, name, num) \
131 float_error_arg = num; \
132 float_error_fn_name = name; \
133 in_float = 1; errno = 0; (d); in_float = 0; \
136 case EDOM: domain_error (float_error_fn_name, float_error_arg); \
137 case ERANGE: range_error (float_error_fn_name, float_error_arg); \
138 default: arith_error (float_error_fn_name, float_error_arg); \
141 #define IN_FLOAT2(d, name, num, num2) \
143 float_error_arg = num; \
144 float_error_arg2 = num2; \
145 float_error_fn_name = name; \
146 in_float = 1; errno = 0; (d); in_float = 0; \
149 case EDOM: domain_error (float_error_fn_name, float_error_arg); \
150 case ERANGE: range_error (float_error_fn_name, float_error_arg); \
151 default: arith_error (float_error_fn_name, float_error_arg); \
155 #define IN_FLOAT2(d, name, num, num2) (in_float = 1, (d), in_float = 0)
158 #define arith_error(op,arg) \
159 Fsignal (Qarith_error, Fcons (build_string ((op)), Fcons ((arg), Qnil)))
160 #define range_error(op,arg) \
161 Fsignal (Qrange_error, Fcons (build_string ((op)), Fcons ((arg), Qnil)))
162 #define domain_error(op,arg) \
163 Fsignal (Qdomain_error, Fcons (build_string ((op)), Fcons ((arg), Qnil)))
164 #define domain_error2(op,a1,a2) \
165 Fsignal (Qdomain_error, Fcons (build_string ((op)), Fcons ((a1), Fcons ((a2), Qnil))))
167 /* Extract a Lisp number as a `double', or signal an error. */
173 CHECK_NUMBER_OR_FLOAT (num
, 0);
175 if (XTYPE (num
) == Lisp_Float
)
176 return XFLOAT (num
)->data
;
177 return (double) XINT (num
);
180 /* Trig functions. */
182 DEFUN ("acos", Facos
, Sacos
, 1, 1, 0,
183 "Return the inverse cosine of ARG.")
185 register Lisp_Object arg
;
187 double d
= extract_float (arg
);
188 #ifdef FLOAT_CHECK_DOMAIN
189 if (d
> 1.0 || d
< -1.0)
190 domain_error ("acos", arg
);
192 IN_FLOAT (d
= acos (d
), "acos", arg
);
193 return make_float (d
);
196 DEFUN ("asin", Fasin
, Sasin
, 1, 1, 0,
197 "Return the inverse sine of ARG.")
199 register Lisp_Object arg
;
201 double d
= extract_float (arg
);
202 #ifdef FLOAT_CHECK_DOMAIN
203 if (d
> 1.0 || d
< -1.0)
204 domain_error ("asin", arg
);
206 IN_FLOAT (d
= asin (d
), "asin", arg
);
207 return make_float (d
);
210 DEFUN ("atan", Fatan
, Satan
, 1, 1, 0,
211 "Return the inverse tangent of ARG.")
213 register Lisp_Object arg
;
215 double d
= extract_float (arg
);
216 IN_FLOAT (d
= atan (d
), "atan", arg
);
217 return make_float (d
);
220 DEFUN ("cos", Fcos
, Scos
, 1, 1, 0,
221 "Return the cosine of ARG.")
223 register Lisp_Object arg
;
225 double d
= extract_float (arg
);
226 IN_FLOAT (d
= cos (d
), "cos", arg
);
227 return make_float (d
);
230 DEFUN ("sin", Fsin
, Ssin
, 1, 1, 0,
231 "Return the sine of ARG.")
233 register Lisp_Object arg
;
235 double d
= extract_float (arg
);
236 IN_FLOAT (d
= sin (d
), "sin", arg
);
237 return make_float (d
);
240 DEFUN ("tan", Ftan
, Stan
, 1, 1, 0,
241 "Return the tangent of ARG.")
243 register Lisp_Object arg
;
245 double d
= extract_float (arg
);
247 #ifdef FLOAT_CHECK_DOMAIN
249 domain_error ("tan", arg
);
251 IN_FLOAT (d
= sin (d
) / c
, "tan", arg
);
252 return make_float (d
);
255 #if 0 /* Leave these out unless we find there's a reason for them. */
257 DEFUN ("bessel-j0", Fbessel_j0
, Sbessel_j0
, 1, 1, 0,
258 "Return the bessel function j0 of ARG.")
260 register Lisp_Object arg
;
262 double d
= extract_float (arg
);
263 IN_FLOAT (d
= j0 (d
), "bessel-j0", arg
);
264 return make_float (d
);
267 DEFUN ("bessel-j1", Fbessel_j1
, Sbessel_j1
, 1, 1, 0,
268 "Return the bessel function j1 of ARG.")
270 register Lisp_Object arg
;
272 double d
= extract_float (arg
);
273 IN_FLOAT (d
= j1 (d
), "bessel-j1", arg
);
274 return make_float (d
);
277 DEFUN ("bessel-jn", Fbessel_jn
, Sbessel_jn
, 2, 2, 0,
278 "Return the order N bessel function output jn of ARG.\n\
279 The first arg (the order) is truncated to an integer.")
281 register Lisp_Object arg1
, arg2
;
283 int i1
= extract_float (arg1
);
284 double f2
= extract_float (arg2
);
286 IN_FLOAT (f2
= jn (i1
, f2
), "bessel-jn", arg1
);
287 return make_float (f2
);
290 DEFUN ("bessel-y0", Fbessel_y0
, Sbessel_y0
, 1, 1, 0,
291 "Return the bessel function y0 of ARG.")
293 register Lisp_Object arg
;
295 double d
= extract_float (arg
);
296 IN_FLOAT (d
= y0 (d
), "bessel-y0", arg
);
297 return make_float (d
);
300 DEFUN ("bessel-y1", Fbessel_y1
, Sbessel_y1
, 1, 1, 0,
301 "Return the bessel function y1 of ARG.")
303 register Lisp_Object arg
;
305 double d
= extract_float (arg
);
306 IN_FLOAT (d
= y1 (d
), "bessel-y0", arg
);
307 return make_float (d
);
310 DEFUN ("bessel-yn", Fbessel_yn
, Sbessel_yn
, 2, 2, 0,
311 "Return the order N bessel function output yn of ARG.\n\
312 The first arg (the order) is truncated to an integer.")
314 register Lisp_Object arg1
, arg2
;
316 int i1
= extract_float (arg1
);
317 double f2
= extract_float (arg2
);
319 IN_FLOAT (f2
= yn (i1
, f2
), "bessel-yn", arg1
);
320 return make_float (f2
);
325 #if 0 /* Leave these out unless we see they are worth having. */
327 DEFUN ("erf", Ferf
, Serf
, 1, 1, 0,
328 "Return the mathematical error function of ARG.")
330 register Lisp_Object arg
;
332 double d
= extract_float (arg
);
333 IN_FLOAT (d
= erf (d
), "erf", arg
);
334 return make_float (d
);
337 DEFUN ("erfc", Ferfc
, Serfc
, 1, 1, 0,
338 "Return the complementary error function of ARG.")
340 register Lisp_Object arg
;
342 double d
= extract_float (arg
);
343 IN_FLOAT (d
= erfc (d
), "erfc", arg
);
344 return make_float (d
);
347 DEFUN ("log-gamma", Flog_gamma
, Slog_gamma
, 1, 1, 0,
348 "Return the log gamma of ARG.")
350 register Lisp_Object arg
;
352 double d
= extract_float (arg
);
353 IN_FLOAT (d
= lgamma (d
), "log-gamma", arg
);
354 return make_float (d
);
357 DEFUN ("cube-root", Fcube_root
, Scube_root
, 1, 1, 0,
358 "Return the cube root of ARG.")
360 register Lisp_Object arg
;
362 double d
= extract_float (arg
);
364 IN_FLOAT (d
= cbrt (d
), "cube-root", arg
);
367 IN_FLOAT (d
= pow (d
, 1.0/3.0), "cube-root", arg
);
369 IN_FLOAT (d
= -pow (-d
, 1.0/3.0), "cube-root", arg
);
371 return make_float (d
);
376 DEFUN ("exp", Fexp
, Sexp
, 1, 1, 0,
377 "Return the exponential base e of ARG.")
379 register Lisp_Object arg
;
381 double d
= extract_float (arg
);
382 #ifdef FLOAT_CHECK_DOMAIN
383 if (d
> 709.7827) /* Assume IEEE doubles here */
384 range_error ("exp", arg
);
386 return make_float (0.0);
389 IN_FLOAT (d
= exp (d
), "exp", arg
);
390 return make_float (d
);
393 DEFUN ("expt", Fexpt
, Sexpt
, 2, 2, 0,
394 "Return the exponential X ** Y.")
396 register Lisp_Object arg1
, arg2
;
400 CHECK_NUMBER_OR_FLOAT (arg1
, 0);
401 CHECK_NUMBER_OR_FLOAT (arg2
, 0);
402 if ((XTYPE (arg1
) == Lisp_Int
) && /* common lisp spec */
403 (XTYPE (arg2
) == Lisp_Int
)) /* don't promote, if both are ints */
404 { /* this can be improved by pre-calculating */
405 int acc
, x
, y
; /* some binary powers of x then acumulating */
406 /* these, therby saving some time. -wsr */
416 acc
= (y
& 1) ? -1 : 1;
428 y
= (unsigned)y
>> 1;
431 XSET (x
, Lisp_Int
, acc
);
434 f1
= (XTYPE (arg1
) == Lisp_Float
) ? XFLOAT (arg1
)->data
: XINT (arg1
);
435 f2
= (XTYPE (arg2
) == Lisp_Float
) ? XFLOAT (arg2
)->data
: XINT (arg2
);
436 /* Really should check for overflow, too */
437 if (f1
== 0.0 && f2
== 0.0)
439 #ifdef FLOAT_CHECK_DOMAIN
440 else if ((f1
== 0.0 && f2
< 0.0) || (f1
< 0 && f2
!= floor(f2
)))
441 domain_error2 ("expt", arg1
, arg2
);
443 IN_FLOAT (f1
= pow (f1
, f2
), "expt", arg1
);
444 return make_float (f1
);
447 DEFUN ("log", Flog
, Slog
, 1, 2, 0,
448 "Return the natural logarithm of ARG.\n\
449 If second optional argument BASE is given, return log ARG using that base.")
451 register Lisp_Object arg
, base
;
453 double d
= extract_float (arg
);
455 #ifdef FLOAT_CHECK_DOMAIN
457 domain_error2 ("log", arg
, base
);
460 IN_FLOAT (d
= log (d
), "log", arg
);
463 double b
= extract_float (base
);
465 #ifdef FLOAT_CHECK_DOMAIN
466 if (b
<= 0.0 || b
== 1.0)
467 domain_error2 ("log", arg
, base
);
470 IN_FLOAT2 (d
= log10 (d
), "log", arg
, base
);
472 IN_FLOAT2 (d
= log (arg
) / log (b
), "log", arg
, base
);
474 return make_float (d
);
477 DEFUN ("log10", Flog10
, Slog10
, 1, 1, 0,
478 "Return the logarithm base 10 of ARG.")
480 register Lisp_Object arg
;
482 double d
= extract_float (arg
);
483 #ifdef FLOAT_CHECK_DOMAIN
485 domain_error ("log10", arg
);
487 IN_FLOAT (d
= log10 (d
), "log10", arg
);
488 return make_float (d
);
491 DEFUN ("sqrt", Fsqrt
, Ssqrt
, 1, 1, 0,
492 "Return the square root of ARG.")
494 register Lisp_Object arg
;
496 double d
= extract_float (arg
);
497 #ifdef FLOAT_CHECK_DOMAIN
499 domain_error ("sqrt", arg
);
501 IN_FLOAT (d
= sqrt (d
), "sqrt", arg
);
502 return make_float (d
);
505 #if 0 /* Not clearly worth adding. */
507 DEFUN ("acosh", Facosh
, Sacosh
, 1, 1, 0,
508 "Return the inverse hyperbolic cosine of ARG.")
510 register Lisp_Object arg
;
512 double d
= extract_float (arg
);
513 #ifdef FLOAT_CHECK_DOMAIN
515 domain_error ("acosh", arg
);
517 #ifdef HAVE_INVERSE_HYPERBOLIC
518 IN_FLOAT (d
= acosh (d
), "acosh", arg
);
520 IN_FLOAT (d
= log (d
+ sqrt (d
*d
- 1.0)), "acosh", arg
);
522 return make_float (d
);
525 DEFUN ("asinh", Fasinh
, Sasinh
, 1, 1, 0,
526 "Return the inverse hyperbolic sine of ARG.")
528 register Lisp_Object arg
;
530 double d
= extract_float (arg
);
531 #ifdef HAVE_INVERSE_HYPERBOLIC
532 IN_FLOAT (d
= asinh (d
), "asinh", arg
);
534 IN_FLOAT (d
= log (d
+ sqrt (d
*d
+ 1.0)), "asinh", arg
);
536 return make_float (d
);
539 DEFUN ("atanh", Fatanh
, Satanh
, 1, 1, 0,
540 "Return the inverse hyperbolic tangent of ARG.")
542 register Lisp_Object arg
;
544 double d
= extract_float (arg
);
545 #ifdef FLOAT_CHECK_DOMAIN
546 if (d
>= 1.0 || d
<= -1.0)
547 domain_error ("atanh", arg
);
549 #ifdef HAVE_INVERSE_HYPERBOLIC
550 IN_FLOAT (d
= atanh (d
), "atanh", arg
);
552 IN_FLOAT (d
= 0.5 * log ((1.0 + d
) / (1.0 - d
)), "atanh", arg
);
554 return make_float (d
);
557 DEFUN ("cosh", Fcosh
, Scosh
, 1, 1, 0,
558 "Return the hyperbolic cosine of ARG.")
560 register Lisp_Object arg
;
562 double d
= extract_float (arg
);
563 #ifdef FLOAT_CHECK_DOMAIN
564 if (d
> 710.0 || d
< -710.0)
565 range_error ("cosh", arg
);
567 IN_FLOAT (d
= cosh (d
), "cosh", arg
);
568 return make_float (d
);
571 DEFUN ("sinh", Fsinh
, Ssinh
, 1, 1, 0,
572 "Return the hyperbolic sine of ARG.")
574 register Lisp_Object arg
;
576 double d
= extract_float (arg
);
577 #ifdef FLOAT_CHECK_DOMAIN
578 if (d
> 710.0 || d
< -710.0)
579 range_error ("sinh", arg
);
581 IN_FLOAT (d
= sinh (d
), "sinh", arg
);
582 return make_float (d
);
585 DEFUN ("tanh", Ftanh
, Stanh
, 1, 1, 0,
586 "Return the hyperbolic tangent of ARG.")
588 register Lisp_Object arg
;
590 double d
= extract_float (arg
);
591 IN_FLOAT (d
= tanh (d
), "tanh", arg
);
592 return make_float (d
);
596 DEFUN ("abs", Fabs
, Sabs
, 1, 1, 0,
597 "Return the absolute value of ARG.")
599 register Lisp_Object arg
;
601 CHECK_NUMBER_OR_FLOAT (arg
, 0);
603 if (XTYPE (arg
) == Lisp_Float
)
604 IN_FLOAT (arg
= make_float (fabs (XFLOAT (arg
)->data
)), "abs", arg
);
605 else if (XINT (arg
) < 0)
606 XSETINT (arg
, - XFASTINT (arg
));
611 DEFUN ("float", Ffloat
, Sfloat
, 1, 1, 0,
612 "Return the floating point number equal to ARG.")
614 register Lisp_Object arg
;
616 CHECK_NUMBER_OR_FLOAT (arg
, 0);
618 if (XTYPE (arg
) == Lisp_Int
)
619 return make_float ((double) XINT (arg
));
620 else /* give 'em the same float back */
624 DEFUN ("logb", Flogb
, Slogb
, 1, 1, 0,
625 "Returns the integer not greater than the base 2 log of the magnitude of ARG.\n\
626 This is the same as the exponent of a float.")
632 double f
= extract_float (arg
);
638 IN_FLOAT (frexp (f
, &exp
), "logb", arg
);
639 XSET (val
, Lisp_Int
, exp
-1);
642 IN_FLOAT (value
= logb (f
), "logb", arg
);
643 XSET (val
, Lisp_Int
, value
);
649 /* the rounding functions */
651 DEFUN ("ceiling", Fceiling
, Sceiling
, 1, 1, 0,
652 "Return the smallest integer no less than ARG. (Round toward +inf.)")
654 register Lisp_Object arg
;
656 CHECK_NUMBER_OR_FLOAT (arg
, 0);
658 if (XTYPE (arg
) == Lisp_Float
)
659 IN_FLOAT (XSET (arg
, Lisp_Int
, ceil (XFLOAT (arg
)->data
)), "celing", arg
);
664 DEFUN ("floor", Ffloor
, Sfloor
, 1, 1, 0,
665 "Return the largest integer no greater than ARG. (Round towards -inf.)")
667 register Lisp_Object arg
;
669 CHECK_NUMBER_OR_FLOAT (arg
, 0);
671 if (XTYPE (arg
) == Lisp_Float
)
672 IN_FLOAT (XSET (arg
, Lisp_Int
, floor (XFLOAT (arg
)->data
)), "floor", arg
);
677 DEFUN ("round", Fround
, Sround
, 1, 1, 0,
678 "Return the nearest integer to ARG.")
680 register Lisp_Object arg
;
682 CHECK_NUMBER_OR_FLOAT (arg
, 0);
684 if (XTYPE (arg
) == Lisp_Float
)
685 /* Screw the prevailing rounding mode. */
686 IN_FLOAT (XSET (arg
, Lisp_Int
, rint (XFLOAT (arg
)->data
)), "round", arg
);
691 DEFUN ("truncate", Ftruncate
, Struncate
, 1, 1, 0,
692 "Truncate a floating point number to an int.\n\
693 Rounds the value toward zero.")
695 register Lisp_Object arg
;
697 CHECK_NUMBER_OR_FLOAT (arg
, 0);
699 if (XTYPE (arg
) == Lisp_Float
)
700 XSET (arg
, Lisp_Int
, (int) XFLOAT (arg
)->data
);
706 /* It's not clear these are worth adding. */
708 DEFUN ("fceiling", Ffceiling
, Sfceiling
, 1, 1, 0,
709 "Return the smallest integer no less than ARG, as a float.\n\
710 \(Round toward +inf.\)")
712 register Lisp_Object arg
;
714 double d
= extract_float (arg
);
715 IN_FLOAT (d
= ceil (d
), "fceiling", arg
);
716 return make_float (d
);
719 DEFUN ("ffloor", Fffloor
, Sffloor
, 1, 1, 0,
720 "Return the largest integer no greater than ARG, as a float.\n\
721 \(Round towards -inf.\)")
723 register Lisp_Object arg
;
725 double d
= extract_float (arg
);
726 IN_FLOAT (d
= floor (d
), "ffloor", arg
);
727 return make_float (d
);
730 DEFUN ("fround", Ffround
, Sfround
, 1, 1, 0,
731 "Return the nearest integer to ARG, as a float.")
733 register Lisp_Object arg
;
735 double d
= extract_float (arg
);
736 IN_FLOAT (d
= rint (XFLOAT (arg
)->data
), "fround", arg
);
737 return make_float (d
);
740 DEFUN ("ftruncate", Fftruncate
, Sftruncate
, 1, 1, 0,
741 "Truncate a floating point number to an integral float value.\n\
742 Rounds the value toward zero.")
744 register Lisp_Object arg
;
746 double d
= extract_float (arg
);
748 IN_FLOAT (d
= floor (d
), "ftruncate", arg
);
750 IN_FLOAT (d
= ceil (d
), arg
);
751 return make_float (d
);
755 #ifdef FLOAT_CATCH_SIGILL
761 fatal_error_signal (signo
);
766 #else /* not BSD4_1 */
767 sigsetmask (SIGEMPTYMASK
);
768 #endif /* not BSD4_1 */
770 /* Must reestablish handler each time it is called. */
771 signal (SIGILL
, float_error
);
776 Fsignal (Qarith_error
, Fcons (float_error_arg
, Qnil
));
779 /* Another idea was to replace the library function `infnan'
780 where SIGILL is signaled. */
782 #endif /* FLOAT_CATCH_SIGILL */
791 /* Not called from emacs-lisp float routines; do the default thing. */
793 if (!strcmp (x
->name
, "pow"))
797 = Fcons (build_string (x
->name
),
798 Fcons (make_float (x
->arg1
),
799 ((!strcmp (x
->name
, "log") || !strcmp (x
->name
, "pow"))
800 ? Fcons (make_float (x
->arg2
), Qnil
)
804 case DOMAIN
: Fsignal (Qdomain_error
, args
); break;
805 case SING
: Fsignal (Qsingularity_error
, args
); break;
806 case OVERFLOW
: Fsignal (Qoverflow_error
, args
); break;
807 case UNDERFLOW
: Fsignal (Qunderflow_error
, args
); break;
808 default: Fsignal (Qarith_error
, args
); break;
810 return (1); /* don't set errno or print a message */
812 #endif /* HAVE_MATHERR */
816 #ifdef FLOAT_CATCH_SIGILL
817 signal (SIGILL
, float_error
);
837 defsubr (&Sbessel_y0
);
838 defsubr (&Sbessel_y1
);
839 defsubr (&Sbessel_yn
);
840 defsubr (&Sbessel_j0
);
841 defsubr (&Sbessel_j1
);
842 defsubr (&Sbessel_jn
);
845 defsubr (&Slog_gamma
);
846 defsubr (&Scube_root
);
847 defsubr (&Sfceiling
);
850 defsubr (&Sftruncate
);
864 defsubr (&Struncate
);
867 #else /* not LISP_FLOAT_TYPE */
875 #endif /* not LISP_FLOAT_TYPE */