xemacs-beta: src/floatfns.c comparison

comparison src/floatfns.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	376386a54a3c
children	4be1180a9e89

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 /* Trig functions.  */
 #ifdef LISP_FLOAT_TYPE
-DEFUN ("acos", Facos, Sacos, 1, 1, 0 /*
+DEFUN ("acos", Facos, 1, 1, 0, /*
 Return the inverse cosine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d > 1.0 || d < -1.0)
 domain_error ("acos", arg);
 #endif
 IN_FLOAT (d = acos (d), "acos", arg);
 return make_float (d);
 }
-DEFUN ("asin", Fasin, Sasin, 1, 1, 0 /*
+DEFUN ("asin", Fasin, 1, 1, 0, /*
 Return the inverse sine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d > 1.0 || d < -1.0)
 domain_error ("asin", arg);
 #endif
 IN_FLOAT (d = asin (d), "asin", arg);
 return make_float (d);
 }
-DEFUN ("atan", Fatan, Satan, 1, 2, 0 /*
+DEFUN ("atan", Fatan, 1, 2, 0, /*
 Return the inverse tangent of ARG.
-*/ )
+*/
-(arg1, arg2)
+(arg1, arg2))
-Lisp_Object arg1, arg2;
 {
 double d = extract_float (arg1);
 if (NILP (arg2))
 IN_FLOAT (d = atan (d), "atan", arg1);
 IN_FLOAT2 (d = atan2 (d, d2), "atan", arg1, arg2);
 }
 return make_float (d);
 }
-DEFUN ("cos", Fcos, Scos, 1, 1, 0 /*
+DEFUN ("cos", Fcos, 1, 1, 0, /*
 Return the cosine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = cos (d), "cos", arg);
 return make_float (d);
 }
-DEFUN ("sin", Fsin, Ssin, 1, 1, 0 /*
+DEFUN ("sin", Fsin, 1, 1, 0, /*
 Return the sine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = sin (d), "sin", arg);
 return make_float (d);
 }
-DEFUN ("tan", Ftan, Stan, 1, 1, 0 /*
+DEFUN ("tan", Ftan, 1, 1, 0, /*
 Return the tangent of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 double c = cos (d);
 #ifdef FLOAT_CHECK_DOMAIN
 if (c == 0.0)
 /* Bessel functions */
 #if 0 /* Leave these out unless we find there's a reason for them.  */
 /* #ifdef LISP_FLOAT_TYPE */
-DEFUN ("bessel-j0", Fbessel_j0, Sbessel_j0, 1, 1, 0 /*
+DEFUN ("bessel-j0", Fbessel_j0, 1, 1, 0, /*
 Return the bessel function j0 of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = j0 (d), "bessel-j0", arg);
 return make_float (d);
 }
-DEFUN ("bessel-j1", Fbessel_j1, Sbessel_j1, 1, 1, 0 /*
+DEFUN ("bessel-j1", Fbessel_j1, 1, 1, 0, /*
 Return the bessel function j1 of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = j1 (d), "bessel-j1", arg);
 return make_float (d);
 }
-DEFUN ("bessel-jn", Fbessel_jn, Sbessel_jn, 2, 2, 0 /*
+DEFUN ("bessel-jn", Fbessel_jn, 2, 2, 0, /*
 Return the order N bessel function output jn of ARG.
 The first arg (the order) is truncated to an integer.
-*/ )
+*/
-(arg1, arg2)
+(arg1, arg2))
-Lisp_Object arg1, arg2;
 {
 int i1 = extract_float (arg1);
 double f2 = extract_float (arg2);
 IN_FLOAT (f2 = jn (i1, f2), "bessel-jn", arg1);
 return make_float (f2);
 }
-DEFUN ("bessel-y0", Fbessel_y0, Sbessel_y0, 1, 1, 0 /*
+DEFUN ("bessel-y0", Fbessel_y0, 1, 1, 0, /*
 Return the bessel function y0 of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = y0 (d), "bessel-y0", arg);
 return make_float (d);
 }
-DEFUN ("bessel-y1", Fbessel_y1, Sbessel_y1, 1, 1, 0 /*
+DEFUN ("bessel-y1", Fbessel_y1, 1, 1, 0, /*
 Return the bessel function y1 of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = y1 (d), "bessel-y0", arg);
 return make_float (d);
 }
-DEFUN ("bessel-yn", Fbessel_yn, Sbessel_yn, 2, 2, 0 /*
+DEFUN ("bessel-yn", Fbessel_yn, 2, 2, 0, /*
 Return the order N bessel function output yn of ARG.
 The first arg (the order) is truncated to an integer.
-*/ )
+*/
-(arg1, arg2)
+(arg1, arg2))
-Lisp_Object arg1, arg2;
 {
 int i1 = extract_float (arg1);
 double f2 = extract_float (arg2);
 IN_FLOAT (f2 = yn (i1, f2), "bessel-yn", arg1);
 /* Error functions. */
 #if 0 /* Leave these out unless we see they are worth having.  */
 /* #ifdef LISP_FLOAT_TYPE */
-DEFUN ("erf", Ferf, Serf, 1, 1, 0 /*
+DEFUN ("erf", Ferf, 1, 1, 0, /*
 Return the mathematical error function of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = erf (d), "erf", arg);
 return make_float (d);
 }
-DEFUN ("erfc", Ferfc, Serfc, 1, 1, 0 /*
+DEFUN ("erfc", Ferfc, 1, 1, 0, /*
 Return the complementary error function of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = erfc (d), "erfc", arg);
 return make_float (d);
 }
-DEFUN ("log-gamma", Flog_gamma, Slog_gamma, 1, 1, 0 /*
+DEFUN ("log-gamma", Flog_gamma, 1, 1, 0, /*
 Return the log gamma of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = lgamma (d), "log-gamma", arg);
 return make_float (d);
 }
 /* Root and Log functions. */
 #ifdef LISP_FLOAT_TYPE
-DEFUN ("exp", Fexp, Sexp, 1, 1, 0 /*
+DEFUN ("exp", Fexp, 1, 1, 0, /*
 Return the exponential base e of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d > 709.7827)   /* Assume IEEE doubles here */
 range_error ("exp", arg);
 return make_float (d);
 }
 #endif /* LISP_FLOAT_TYPE */
-DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0 /*
+DEFUN ("expt", Fexpt, 2, 2, 0, /*
 Return the exponential ARG1 ** ARG2.
-*/ )
+*/
-(arg1, arg2)
+(arg1, arg2))
-Lisp_Object arg1, arg2;
 {
 double f1, f2;
 CHECK_INT_OR_FLOAT (arg1);
 CHECK_INT_OR_FLOAT (arg2);
 abort ();
 #endif /* LISP_FLOAT_TYPE */
 }
 #ifdef LISP_FLOAT_TYPE
-DEFUN ("log", Flog, Slog, 1, 2, 0 /*
+DEFUN ("log", Flog, 1, 2, 0, /*
 Return the natural logarithm of ARG.
 If second optional argument BASE is given, return log ARG using that base.
-*/ )
+*/
-(arg, base)
+(arg, base))
-Lisp_Object arg, base;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d <= 0.0)
 domain_error2 ("log", arg, base);
 }
 return make_float (d);
 }
-DEFUN ("log10", Flog10, Slog10, 1, 1, 0 /*
+DEFUN ("log10", Flog10, 1, 1, 0, /*
 Return the logarithm base 10 of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d <= 0.0)
 domain_error ("log10", arg);
 IN_FLOAT (d = log10 (d), "log10", arg);
 return make_float (d);
 }
-DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0 /*
+DEFUN ("sqrt", Fsqrt, 1, 1, 0, /*
 Return the square root of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d < 0.0)
 domain_error ("sqrt", arg);
 IN_FLOAT (d = sqrt (d), "sqrt", arg);
 return make_float (d);
 }
-DEFUN ("cube-root", Fcube_root, Scube_root, 1, 1, 0 /*
+DEFUN ("cube-root", Fcube_root, 1, 1, 0, /*
 Return the cube root of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef HAVE_CBRT
 IN_FLOAT (d = cbrt (d), "cube-root", arg);
 #else
 /* Inverse trig functions. */
 #ifdef LISP_FLOAT_TYPE
 /* #if 0  Not clearly worth adding...  */
-DEFUN ("acosh", Facosh, Sacosh, 1, 1, 0 /*
+DEFUN ("acosh", Facosh, 1, 1, 0, /*
 Return the inverse hyperbolic cosine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d < 1.0)
 domain_error ("acosh", arg);
 IN_FLOAT (d = log (d + sqrt (d*d - 1.0)), "acosh", arg);
 #endif
 return make_float (d);
 }
-DEFUN ("asinh", Fasinh, Sasinh, 1, 1, 0 /*
+DEFUN ("asinh", Fasinh, 1, 1, 0, /*
 Return the inverse hyperbolic sine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef HAVE_INVERSE_HYPERBOLIC
 IN_FLOAT (d = asinh (d), "asinh", arg);
 #else
 IN_FLOAT (d = log (d + sqrt (d*d + 1.0)), "asinh", arg);
 #endif
 return make_float (d);
 }
-DEFUN ("atanh", Fatanh, Satanh, 1, 1, 0 /*
+DEFUN ("atanh", Fatanh, 1, 1, 0, /*
 Return the inverse hyperbolic tangent of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d >= 1.0 || d <= -1.0)
 domain_error ("atanh", arg);
 IN_FLOAT (d = 0.5 * log ((1.0 + d) / (1.0 - d)), "atanh", arg);
 #endif
 return make_float (d);
 }
-DEFUN ("cosh", Fcosh, Scosh, 1, 1, 0 /*
+DEFUN ("cosh", Fcosh, 1, 1, 0, /*
 Return the hyperbolic cosine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d > 710.0 || d < -710.0)
 range_error ("cosh", arg);
 #endif
 IN_FLOAT (d = cosh (d), "cosh", arg);
 return make_float (d);
 }
-DEFUN ("sinh", Fsinh, Ssinh, 1, 1, 0 /*
+DEFUN ("sinh", Fsinh, 1, 1, 0, /*
 Return the hyperbolic sine of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
 if (d > 710.0 || d < -710.0)
 range_error ("sinh", arg);
 #endif
 IN_FLOAT (d = sinh (d), "sinh", arg);
 return make_float (d);
 }
-DEFUN ("tanh", Ftanh, Stanh, 1, 1, 0 /*
+DEFUN ("tanh", Ftanh, 1, 1, 0, /*
 Return the hyperbolic tangent of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = tanh (d), "tanh", arg);
 return make_float (d);
 }
 #endif /* LISP_FLOAT_TYPE (inverse trig functions) */
 /* Rounding functions */
-DEFUN ("abs", Fabs, Sabs, 1, 1, 0 /*
+DEFUN ("abs", Fabs, 1, 1, 0, /*
 Return the absolute value of ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 CHECK_INT_OR_FLOAT (arg);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (arg))
 else
 return (arg);
 }
 #ifdef LISP_FLOAT_TYPE
-DEFUN ("float", Ffloat, Sfloat, 1, 1, 0 /*
+DEFUN ("float", Ffloat, 1, 1, 0, /*
 Return the floating point number equal to ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 CHECK_INT_OR_FLOAT (arg);
 if (INTP (arg))
 return make_float ((double) XINT (arg));
 }
 #endif /* LISP_FLOAT_TYPE */
 #ifdef LISP_FLOAT_TYPE
-DEFUN ("logb", Flogb, Slogb, 1, 1, 0 /*
+DEFUN ("logb", Flogb, 1, 1, 0, /*
 Return largest integer <= the base 2 log of the magnitude of ARG.
 This is the same as the exponent of a float.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double f = extract_float (arg);
 if (f == 0.0)
 return (make_int (- (((EMACS_UINT) 1) << (VALBITS - 1)))); /* most-negative-fixnum */
 #endif /* ! HAVE_LOGB */
 }
 #endif /* LISP_FLOAT_TYPE */
-DEFUN ("ceiling", Fceiling, Sceiling, 1, 1, 0 /*
+DEFUN ("ceiling", Fceiling, 1, 1, 0, /*
 Return the smallest integer no less than ARG.  (Round toward +inf.)
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 CHECK_INT_OR_FLOAT (arg);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (arg))
 return arg;
 }
-DEFUN ("floor", Ffloor, Sfloor, 1, 2, 0 /*
+DEFUN ("floor", Ffloor, 1, 2, 0, /*
 Return the largest integer no greater than ARG.  (Round towards -inf.)
 With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR.
-*/ )
+*/
-(arg, divisor)
+(arg, divisor))
-Lisp_Object arg, divisor;
 {
 CHECK_INT_OR_FLOAT (arg);
 if (! NILP (divisor))
 {
 #endif /* LISP_FLOAT_TYPE */
 return arg;
 }
-DEFUN ("round", Fround, Sround, 1, 1, 0 /*
+DEFUN ("round", Fround, 1, 1, 0, /*
 Return the nearest integer to ARG.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 CHECK_INT_OR_FLOAT (arg);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (arg))
 #endif /* LISP_FLOAT_TYPE */
 return arg;
 }
-DEFUN ("truncate", Ftruncate, Struncate, 1, 1, 0 /*
+DEFUN ("truncate", Ftruncate, 1, 1, 0, /*
 Truncate a floating point number to an integer.
 Rounds the value toward zero.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 CHECK_INT_OR_FLOAT (arg);
 #ifdef LISP_FLOAT_TYPE
 if (FLOATP (arg))
 /* Float-rounding functions. */
 #ifdef LISP_FLOAT_TYPE
 /* #if 1  It's not clear these are worth adding... */
-DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0 /*
+DEFUN ("fceiling", Ffceiling, 1, 1, 0, /*
 Return the smallest integer no less than ARG, as a float.
 \(Round toward +inf.\)
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = ceil (d), "fceiling", arg);
 return make_float (d);
 }
-DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0 /*
+DEFUN ("ffloor", Fffloor, 1, 1, 0, /*
 Return the largest integer no greater than ARG, as a float.
 \(Round towards -inf.\)
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = floor (d), "ffloor", arg);
 return make_float (d);
 }
-DEFUN ("fround", Ffround, Sfround, 1, 1, 0 /*
+DEFUN ("fround", Ffround, 1, 1, 0, /*
 Return the nearest integer to ARG, as a float.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 IN_FLOAT (d = rint (d), "fround", arg);
 return make_float (d);
 }
-DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0 /*
+DEFUN ("ftruncate", Fftruncate, 1, 1, 0, /*
 Truncate a floating point number to an integral float value.
 Rounds the value toward zero.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 double d = extract_float (arg);
 if (d >= 0.0)
 IN_FLOAT (d = floor (d), "ftruncate", arg);
 else
 {
 /* Trig functions.  */
 #ifdef LISP_FLOAT_TYPE
-defsubr (&Sacos);
+DEFSUBR (Facos);
-defsubr (&Sasin);
+DEFSUBR (Fasin);
-defsubr (&Satan);
+DEFSUBR (Fatan);
-defsubr (&Scos);
+DEFSUBR (Fcos);
-defsubr (&Ssin);
+DEFSUBR (Fsin);
-defsubr (&Stan);
+DEFSUBR (Ftan);
 #endif /* LISP_FLOAT_TYPE */
 /* Bessel functions */
 #if 0
-defsubr (&Sbessel_y0);
+DEFSUBR (Fbessel_y0);
-defsubr (&Sbessel_y1);
+DEFSUBR (Fbessel_y1);
-defsubr (&Sbessel_yn);
+DEFSUBR (Fbessel_yn);
-defsubr (&Sbessel_j0);
+DEFSUBR (Fbessel_j0);
-defsubr (&Sbessel_j1);
+DEFSUBR (Fbessel_j1);
-defsubr (&Sbessel_jn);
+DEFSUBR (Fbessel_jn);
 #endif /* 0 */
 /* Error functions. */
 #if 0
-defsubr (&Serf);
+DEFSUBR (Ferf);
-defsubr (&Serfc);
+DEFSUBR (Ferfc);
-defsubr (&Slog_gamma);
+DEFSUBR (Flog_gamma);
 #endif /* 0 */
 /* Root and Log functions. */
 #ifdef LISP_FLOAT_TYPE
-defsubr (&Sexp);
+DEFSUBR (Fexp);
 #endif /* LISP_FLOAT_TYPE */
-defsubr (&Sexpt);
+DEFSUBR (Fexpt);
 #ifdef LISP_FLOAT_TYPE
-defsubr (&Slog);
+DEFSUBR (Flog);
-defsubr (&Slog10);
+DEFSUBR (Flog10);
-defsubr (&Ssqrt);
+DEFSUBR (Fsqrt);
-defsubr (&Scube_root);
+DEFSUBR (Fcube_root);
 #endif /* LISP_FLOAT_TYPE */
 /* Inverse trig functions. */
 #ifdef LISP_FLOAT_TYPE
-defsubr (&Sacosh);
+DEFSUBR (Facosh);
-defsubr (&Sasinh);
+DEFSUBR (Fasinh);
-defsubr (&Satanh);
+DEFSUBR (Fatanh);
-defsubr (&Scosh);
+DEFSUBR (Fcosh);
-defsubr (&Ssinh);
+DEFSUBR (Fsinh);
-defsubr (&Stanh);
+DEFSUBR (Ftanh);
 #endif /* LISP_FLOAT_TYPE */
 /* Rounding functions */
-defsubr (&Sabs);
+DEFSUBR (Fabs);
 #ifdef LISP_FLOAT_TYPE
-defsubr (&Sfloat);
+DEFSUBR (Ffloat);
-defsubr (&Slogb);
+DEFSUBR (Flogb);
 #endif /* LISP_FLOAT_TYPE */
-defsubr (&Sceiling);
+DEFSUBR (Fceiling);
-defsubr (&Sfloor);
+DEFSUBR (Ffloor);
-defsubr (&Sround);
+DEFSUBR (Fround);
-defsubr (&Struncate);
+DEFSUBR (Ftruncate);
 /* Float-rounding functions. */
 #ifdef LISP_FLOAT_TYPE
-defsubr (&Sfceiling);
+DEFSUBR (Ffceiling);
-defsubr (&Sffloor);
+DEFSUBR (Fffloor);
-defsubr (&Sfround);
+DEFSUBR (Ffround);
-defsubr (&Sftruncate);
+DEFSUBR (Fftruncate);
 #endif /* LISP_FLOAT_TYPE */
 }
 void
 vars_of_floatfns (void)

Mercurial > hg > xemacs-beta

comparison src/floatfns.c @ 20:859a2309aef8 r19-15b93