Mercurial > emacs
comparison src/floatfns.c @ 9129:b2d1d925d5cc
(extract_float, Fexpt, Fabs, Ffloat, Fceiling, Ffloor, Fround, Ftruncate): Use
type test macros.
author | Karl Heuer <kwzh@gnu.org> |
---|---|
date | Tue, 27 Sep 1994 03:01:14 +0000 |
parents | 5e5f6d06fb5b |
children | 1b685d477c10 |
comparison
equal
deleted
inserted
replaced
9128:04a702d7f662 | 9129:b2d1d925d5cc |
---|---|
215 extract_float (num) | 215 extract_float (num) |
216 Lisp_Object num; | 216 Lisp_Object num; |
217 { | 217 { |
218 CHECK_NUMBER_OR_FLOAT (num, 0); | 218 CHECK_NUMBER_OR_FLOAT (num, 0); |
219 | 219 |
220 if (XTYPE (num) == Lisp_Float) | 220 if (FLOATP (num)) |
221 return XFLOAT (num)->data; | 221 return XFLOAT (num)->data; |
222 return (double) XINT (num); | 222 return (double) XINT (num); |
223 } | 223 } |
224 | 224 |
225 /* Trig functions. */ | 225 /* Trig functions. */ |
442 { | 442 { |
443 double f1, f2; | 443 double f1, f2; |
444 | 444 |
445 CHECK_NUMBER_OR_FLOAT (arg1, 0); | 445 CHECK_NUMBER_OR_FLOAT (arg1, 0); |
446 CHECK_NUMBER_OR_FLOAT (arg2, 0); | 446 CHECK_NUMBER_OR_FLOAT (arg2, 0); |
447 if (XTYPE (arg1) == Lisp_Int /* common lisp spec */ | 447 if (INTEGERP (arg1) /* common lisp spec */ |
448 && XTYPE (arg2) == Lisp_Int) /* don't promote, if both are ints */ | 448 && INTEGERP (arg2)) /* don't promote, if both are ints */ |
449 { /* this can be improved by pre-calculating */ | 449 { /* this can be improved by pre-calculating */ |
450 int acc, x, y; /* some binary powers of x then accumulating */ | 450 int acc, x, y; /* some binary powers of x then accumulating */ |
451 Lisp_Object val; | 451 Lisp_Object val; |
452 | 452 |
453 x = XINT (arg1); | 453 x = XINT (arg1); |
474 } | 474 } |
475 } | 475 } |
476 XSET (val, Lisp_Int, acc); | 476 XSET (val, Lisp_Int, acc); |
477 return val; | 477 return val; |
478 } | 478 } |
479 f1 = (XTYPE (arg1) == Lisp_Float) ? XFLOAT (arg1)->data : XINT (arg1); | 479 f1 = FLOATP (arg1) ? XFLOAT (arg1)->data : XINT (arg1); |
480 f2 = (XTYPE (arg2) == Lisp_Float) ? XFLOAT (arg2)->data : XINT (arg2); | 480 f2 = FLOATP (arg2) ? XFLOAT (arg2)->data : XINT (arg2); |
481 /* Really should check for overflow, too */ | 481 /* Really should check for overflow, too */ |
482 if (f1 == 0.0 && f2 == 0.0) | 482 if (f1 == 0.0 && f2 == 0.0) |
483 f1 = 1.0; | 483 f1 = 1.0; |
484 #ifdef FLOAT_CHECK_DOMAIN | 484 #ifdef FLOAT_CHECK_DOMAIN |
485 else if ((f1 == 0.0 && f2 < 0.0) || (f1 < 0 && f2 != floor(f2))) | 485 else if ((f1 == 0.0 && f2 < 0.0) || (f1 < 0 && f2 != floor(f2))) |
643 (arg) | 643 (arg) |
644 register Lisp_Object arg; | 644 register Lisp_Object arg; |
645 { | 645 { |
646 CHECK_NUMBER_OR_FLOAT (arg, 0); | 646 CHECK_NUMBER_OR_FLOAT (arg, 0); |
647 | 647 |
648 if (XTYPE (arg) == Lisp_Float) | 648 if (FLOATP (arg)) |
649 IN_FLOAT (arg = make_float (fabs (XFLOAT (arg)->data)), "abs", arg); | 649 IN_FLOAT (arg = make_float (fabs (XFLOAT (arg)->data)), "abs", arg); |
650 else if (XINT (arg) < 0) | 650 else if (XINT (arg) < 0) |
651 XSETINT (arg, - XFASTINT (arg)); | 651 XSETINT (arg, - XFASTINT (arg)); |
652 | 652 |
653 return arg; | 653 return arg; |
658 (arg) | 658 (arg) |
659 register Lisp_Object arg; | 659 register Lisp_Object arg; |
660 { | 660 { |
661 CHECK_NUMBER_OR_FLOAT (arg, 0); | 661 CHECK_NUMBER_OR_FLOAT (arg, 0); |
662 | 662 |
663 if (XTYPE (arg) == Lisp_Int) | 663 if (INTEGERP (arg)) |
664 return make_float ((double) XINT (arg)); | 664 return make_float ((double) XINT (arg)); |
665 else /* give 'em the same float back */ | 665 else /* give 'em the same float back */ |
666 return arg; | 666 return arg; |
667 } | 667 } |
668 | 668 |
720 (arg) | 720 (arg) |
721 register Lisp_Object arg; | 721 register Lisp_Object arg; |
722 { | 722 { |
723 CHECK_NUMBER_OR_FLOAT (arg, 0); | 723 CHECK_NUMBER_OR_FLOAT (arg, 0); |
724 | 724 |
725 if (XTYPE (arg) == Lisp_Float) | 725 if (FLOATP (arg)) |
726 { | 726 { |
727 double d; | 727 double d; |
728 | 728 |
729 IN_FLOAT (d = ceil (XFLOAT (arg)->data), "ceiling", arg); | 729 IN_FLOAT (d = ceil (XFLOAT (arg)->data), "ceiling", arg); |
730 FLOAT_TO_INT (d, arg, "ceiling", arg); | 730 FLOAT_TO_INT (d, arg, "ceiling", arg); |
749 int i1, i2; | 749 int i1, i2; |
750 | 750 |
751 CHECK_NUMBER_OR_FLOAT (divisor, 1); | 751 CHECK_NUMBER_OR_FLOAT (divisor, 1); |
752 | 752 |
753 #ifdef LISP_FLOAT_TYPE | 753 #ifdef LISP_FLOAT_TYPE |
754 if (XTYPE (arg) == Lisp_Float || XTYPE (divisor) == Lisp_Float) | 754 if (FLOATP (arg) || FLOATP (divisor)) |
755 { | 755 { |
756 double f1, f2; | 756 double f1, f2; |
757 | 757 |
758 f1 = XTYPE (arg) == Lisp_Float ? XFLOAT (arg)->data : XINT (arg); | 758 f1 = FLOATP (arg) ? XFLOAT (arg)->data : XINT (arg); |
759 f2 = (XTYPE (divisor) == Lisp_Float | 759 f2 = (FLOATP (divisor) ? XFLOAT (divisor)->data : XINT (divisor)); |
760 ? XFLOAT (divisor)->data : XINT (divisor)); | |
761 if (f2 == 0) | 760 if (f2 == 0) |
762 Fsignal (Qarith_error, Qnil); | 761 Fsignal (Qarith_error, Qnil); |
763 | 762 |
764 IN_FLOAT2 (f1 = floor (f1 / f2), "floor", arg, divisor); | 763 IN_FLOAT2 (f1 = floor (f1 / f2), "floor", arg, divisor); |
765 FLOAT_TO_INT2 (f1, arg, "floor", arg, divisor); | 764 FLOAT_TO_INT2 (f1, arg, "floor", arg, divisor); |
782 XSET (arg, Lisp_Int, i1); | 781 XSET (arg, Lisp_Int, i1); |
783 return arg; | 782 return arg; |
784 } | 783 } |
785 | 784 |
786 #ifdef LISP_FLOAT_TYPE | 785 #ifdef LISP_FLOAT_TYPE |
787 if (XTYPE (arg) == Lisp_Float) | 786 if (FLOATP (arg)) |
788 { | 787 { |
789 double d; | 788 double d; |
790 IN_FLOAT (d = floor (XFLOAT (arg)->data), "floor", arg); | 789 IN_FLOAT (d = floor (XFLOAT (arg)->data), "floor", arg); |
791 FLOAT_TO_INT (d, arg, "floor", arg); | 790 FLOAT_TO_INT (d, arg, "floor", arg); |
792 } | 791 } |
802 (arg) | 801 (arg) |
803 register Lisp_Object arg; | 802 register Lisp_Object arg; |
804 { | 803 { |
805 CHECK_NUMBER_OR_FLOAT (arg, 0); | 804 CHECK_NUMBER_OR_FLOAT (arg, 0); |
806 | 805 |
807 if (XTYPE (arg) == Lisp_Float) | 806 if (FLOATP (arg)) |
808 { | 807 { |
809 double d; | 808 double d; |
810 | 809 |
811 /* Screw the prevailing rounding mode. */ | 810 /* Screw the prevailing rounding mode. */ |
812 IN_FLOAT (d = rint (XFLOAT (arg)->data), "round", arg); | 811 IN_FLOAT (d = rint (XFLOAT (arg)->data), "round", arg); |
822 (arg) | 821 (arg) |
823 register Lisp_Object arg; | 822 register Lisp_Object arg; |
824 { | 823 { |
825 CHECK_NUMBER_OR_FLOAT (arg, 0); | 824 CHECK_NUMBER_OR_FLOAT (arg, 0); |
826 | 825 |
827 if (XTYPE (arg) == Lisp_Float) | 826 if (FLOATP (arg)) |
828 { | 827 { |
829 double d; | 828 double d; |
830 | 829 |
831 d = XFLOAT (arg)->data; | 830 d = XFLOAT (arg)->data; |
832 FLOAT_TO_INT (d, arg, "truncate", arg); | 831 FLOAT_TO_INT (d, arg, "truncate", arg); |