-/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc.
*
* Portions Copyright 1990, 1991, 1992, 1993 by AT&T Bell Laboratories
* and Bellcore. See scm_divide.
\f
-static SCM abs_most_negative_fixnum;
static mpz_t z_negative_one;
\f
-static const char s_bignum[] = "bignum";
-
SCM_C_INLINE_KEYWORD SCM
scm_i_mkbig ()
{
SCM
scm_make_ratio (SCM numerator, SCM denominator)
+#define FUNC_NAME "make-ratio"
{
-#if 0
- return scm_divide2real(numerator, denominator);
-#else
- #define FUNC_NAME "make-ratio"
+ /* First make sure the arguments are proper.
+ */
if (SCM_INUMP (denominator))
{
if (SCM_EQ_P (denominator, SCM_INUM0))
if (!(SCM_BIGP(denominator)))
SCM_WRONG_TYPE_ARG (2, denominator);
}
+ if (!SCM_INUMP (numerator) && !SCM_BIGP (numerator))
+ SCM_WRONG_TYPE_ARG (1, numerator);
+
+ /* Then flip signs so that the denominator is positive.
+ */
+ if (SCM_NFALSEP (scm_negative_p (denominator)))
+ {
+ numerator = scm_difference (numerator, SCM_UNDEFINED);
+ denominator = scm_difference (denominator, SCM_UNDEFINED);
+ }
+
+ /* Now consider for each of the four fixnum/bignum combinations
+ whether the rational number is really an integer.
+ */
if (SCM_INUMP (numerator))
{
+ long x = SCM_INUM (numerator);
if (SCM_EQ_P (numerator, SCM_INUM0))
return SCM_INUM0;
if (SCM_INUMP (denominator))
{
- long x, y;
- x = SCM_INUM (numerator);
+ long y;
y = SCM_INUM (denominator);
if (x == y)
return SCM_MAKINUM(1);
if ((x % y) == 0)
return SCM_MAKINUM (x / y);
- if (y < 0)
- return scm_double_cell (scm_tc16_fraction, (scm_t_bits)SCM_MAKINUM(-x), (scm_t_bits)SCM_MAKINUM(-y), 0);
- else return scm_double_cell (scm_tc16_fraction, (scm_t_bits)numerator, (scm_t_bits)denominator, 0);
}
else
- {
- /* I assume bignums are actually big, so here there's no point in looking for a integer */
- int sgn = mpz_sgn (SCM_I_BIG_MPZ (denominator));
- if (sgn < 0) /* if denominator negative, flip signs */
- return scm_double_cell (scm_tc16_fraction,
- (scm_t_bits)scm_difference (numerator, SCM_UNDEFINED),
- (scm_t_bits)scm_difference (denominator, SCM_UNDEFINED),
- 0);
- else return scm_double_cell (scm_tc16_fraction, (scm_t_bits)numerator, (scm_t_bits)denominator, 0);
-
- /* should this use SCM_UNPACK for the bignums? */
- }
+ {
+ /* When x == SCM_MOST_NEGATIVE_FIXNUM we could have the negative
+ of that value for the denominator, as a bignum. Apart from
+ that case, abs(bignum) > abs(inum) so inum/bignum is not an
+ integer. */
+ if (x == SCM_MOST_NEGATIVE_FIXNUM
+ && mpz_cmp_ui (SCM_I_BIG_MPZ (denominator),
+ - SCM_MOST_NEGATIVE_FIXNUM) == 0)
+ return SCM_MAKINUM(-1);
+ }
}
- else
+ else if (SCM_BIGP (numerator))
{
- if (SCM_BIGP (numerator))
+ if (SCM_INUMP (denominator))
{
- /* can't use scm_divide to find integer here */
- if (SCM_INUMP (denominator))
- {
- long yy = SCM_INUM (denominator);
- long abs_yy = yy < 0 ? -yy : yy;
- int divisible_p = mpz_divisible_ui_p (SCM_I_BIG_MPZ (numerator), abs_yy);
- if (divisible_p)
- return scm_divide(numerator, denominator);
- else return scm_double_cell (scm_tc16_fraction, (scm_t_bits)numerator, (scm_t_bits)denominator, 0);
- }
- else
- {
- /* both are bignums */
- if (SCM_EQ_P (numerator, denominator))
- return SCM_MAKINUM(1);
- int divisible_p = mpz_divisible_p (SCM_I_BIG_MPZ (numerator),
- SCM_I_BIG_MPZ (denominator));
- if (divisible_p)
- return scm_divide(numerator, denominator);
- else return scm_double_cell (scm_tc16_fraction, (scm_t_bits)numerator, (scm_t_bits)denominator, 0);
- }
+ long yy = SCM_INUM (denominator);
+ if (mpz_divisible_ui_p (SCM_I_BIG_MPZ (numerator), yy))
+ return scm_divide (numerator, denominator);
+ }
+ else
+ {
+ if (SCM_EQ_P (numerator, denominator))
+ return SCM_MAKINUM(1);
+ if (mpz_divisible_p (SCM_I_BIG_MPZ (numerator),
+ SCM_I_BIG_MPZ (denominator)))
+ return scm_divide(numerator, denominator);
}
- else SCM_WRONG_TYPE_ARG (1, numerator);
}
- return SCM_BOOL_F; /* won't happen */
- #undef FUNC_NAME
-#endif
+
+ /* No, it's a proper fraction.
+ */
+ return scm_double_cell (scm_tc16_fraction,
+ SCM_UNPACK (numerator),
+ SCM_UNPACK (denominator), 0);
}
+#undef FUNC_NAME
static void scm_i_fraction_reduce (SCM z)
{
/* Some version of gcc on some old version of Linux used to crash when
trying to make Inf and NaN. */
-#if defined (SCO)
- double tmp = 1.0;
- guile_Inf = 1.0 / (tmp - tmp);
-#elif defined (__alpha__) && ! defined (linux)
+#ifdef INFINITY
+ /* C99 INFINITY, when available.
+ FIXME: The standard allows for INFINITY to be something that overflows
+ at compile time. We ought to have a configure test to check for that
+ before trying to use it. (But in practice we believe this is not a
+ problem on any system guile is likely to target.) */
+ guile_Inf = INFINITY;
+#elif HAVE_DINFINITY
+ /* OSF */
extern unsigned int DINFINITY[2];
guile_Inf = (*(X_CAST(double *, DINFINITY)));
#else
#if defined (HAVE_ISNAN)
-#if defined (__alpha__) && ! defined (linux)
+#ifdef NAN
+ /* C99 NAN, when available */
+ guile_NaN = NAN;
+#elif HAVE_DQNAN
+ /* OSF */
extern unsigned int DQNAN[2];
guile_NaN = (*(X_CAST(double *, DQNAN)));
#else
return x;
}
else if (SCM_REALP (x))
- return scm_make_real (fabs (SCM_REAL_VALUE (x)));
+ {
+ /* note that if x is a NaN then xx<0 is false so we return x unchanged */
+ double xx = SCM_REAL_VALUE (x);
+ if (xx < 0.0)
+ return scm_make_real (-xx);
+ else
+ return x;
+ }
else if (SCM_FRACTIONP (x))
{
if (SCM_FALSEP (scm_negative_p (SCM_FRACTION_NUMERATOR (x))))
else if (SCM_BIGP (y))
{
if ((SCM_INUM (x) == SCM_MOST_NEGATIVE_FIXNUM)
- && (scm_i_bigcmp (abs_most_negative_fixnum, y) == 0))
- /* Special case: x == fixnum-min && y == abs (fixnum-min) */
- return SCM_MAKINUM (-1);
+ && (mpz_cmp_ui (SCM_I_BIG_MPZ (y),
+ - SCM_MOST_NEGATIVE_FIXNUM) == 0))
+ {
+ /* Special case: x == fixnum-min && y == abs (fixnum-min) */
+ scm_remember_upto_here_1 (y);
+ return SCM_MAKINUM (-1);
+ }
else
return SCM_MAKINUM (0);
}
else if (SCM_BIGP (y))
{
if ((SCM_INUM (x) == SCM_MOST_NEGATIVE_FIXNUM)
- && (scm_i_bigcmp (abs_most_negative_fixnum, y) == 0))
- /* Special case: x == fixnum-min && y == abs (fixnum-min) */
- return SCM_MAKINUM (0);
+ && (mpz_cmp_ui (SCM_I_BIG_MPZ (y),
+ - SCM_MOST_NEGATIVE_FIXNUM) == 0))
+ {
+ /* Special case: x == fixnum-min && y == abs (fixnum-min) */
+ scm_remember_upto_here_1 (y);
+ return SCM_MAKINUM (0);
+ }
else
return x;
}
else if (SCM_BIGP (y))
{
int sgn_y = mpz_sgn (SCM_I_BIG_MPZ (y));
-
- if (sgn_y == 0)
- scm_num_overflow (s_modulo);
- else
{
mpz_t z_x;
SCM result;
}
else if (SCM_BIGP (y))
{
- int sgn_y = mpz_sgn (SCM_I_BIG_MPZ (y));
- if (sgn_y == 0)
- scm_num_overflow (s_modulo);
- else
{
SCM result = scm_i_mkbig ();
int y_sgn = mpz_sgn (SCM_I_BIG_MPZ (y));
"@lisp\n"
"(logand) @result{} -1\n"
"(logand 7) @result{} 7\n"
- "(logand #b111 #b011 #\b001) @result{} 1\n"
+ "(logand #b111 #b011 #b001) @result{} 1\n"
"@end lisp")
#define FUNC_NAME s_scm_logand
{
}
#undef FUNC_NAME
+/* returns 0 if IN is not an integer. OUT must already be
+ initialized. */
+static int
+coerce_to_big (SCM in, mpz_t out)
+{
+ if (SCM_BIGP (in))
+ mpz_set (out, SCM_I_BIG_MPZ (in));
+ else if (SCM_INUMP (in))
+ mpz_set_si (out, SCM_INUM (in));
+ else
+ return 0;
+
+ return 1;
+}
+
+SCM_DEFINE (scm_modulo_expt, "modulo-expt", 3, 0, 0,
+ (SCM n, SCM k, SCM m),
+ "Return @var{n} raised to the integer exponent\n"
+ "@var{k}, modulo @var{m}.\n"
+ "\n"
+ "@lisp\n"
+ "(modulo-expt 2 3 5)\n"
+ " @result{} 3\n"
+ "@end lisp")
+#define FUNC_NAME s_scm_modulo_expt
+{
+ mpz_t n_tmp;
+ mpz_t k_tmp;
+ mpz_t m_tmp;
+
+ /* There are two classes of error we might encounter --
+ 1) Math errors, which we'll report by calling scm_num_overflow,
+ and
+ 2) wrong-type errors, which of course we'll report by calling
+ SCM_WRONG_TYPE_ARG.
+ We don't report those errors immediately, however; instead we do
+ some cleanup first. These variables tell us which error (if
+ any) we should report after cleaning up.
+ */
+ int report_overflow = 0;
+
+ int position_of_wrong_type = 0;
+ SCM value_of_wrong_type = SCM_INUM0;
+
+ SCM result = SCM_UNDEFINED;
+
+ mpz_init (n_tmp);
+ mpz_init (k_tmp);
+ mpz_init (m_tmp);
+
+ if (SCM_EQ_P (m, SCM_INUM0))
+ {
+ report_overflow = 1;
+ goto cleanup;
+ }
+
+ if (!coerce_to_big (n, n_tmp))
+ {
+ value_of_wrong_type = n;
+ position_of_wrong_type = 1;
+ goto cleanup;
+ }
+
+ if (!coerce_to_big (k, k_tmp))
+ {
+ value_of_wrong_type = k;
+ position_of_wrong_type = 2;
+ goto cleanup;
+ }
+
+ if (!coerce_to_big (m, m_tmp))
+ {
+ value_of_wrong_type = m;
+ position_of_wrong_type = 3;
+ goto cleanup;
+ }
+
+ /* if the exponent K is negative, and we simply call mpz_powm, we
+ will get a divide-by-zero exception when an inverse 1/n mod m
+ doesn't exist (or is not unique). Since exceptions are hard to
+ handle, we'll attempt the inversion "by hand" -- that way, we get
+ a simple failure code, which is easy to handle. */
+
+ if (-1 == mpz_sgn (k_tmp))
+ {
+ if (!mpz_invert (n_tmp, n_tmp, m_tmp))
+ {
+ report_overflow = 1;
+ goto cleanup;
+ }
+ mpz_neg (k_tmp, k_tmp);
+ }
+
+ result = scm_i_mkbig ();
+ mpz_powm (SCM_I_BIG_MPZ (result),
+ n_tmp,
+ k_tmp,
+ m_tmp);
+
+ if (mpz_sgn (m_tmp) < 0 && mpz_sgn (SCM_I_BIG_MPZ (result)) != 0)
+ mpz_add (SCM_I_BIG_MPZ (result), SCM_I_BIG_MPZ (result), m_tmp);
+
+ cleanup:
+ mpz_clear (m_tmp);
+ mpz_clear (k_tmp);
+ mpz_clear (n_tmp);
+
+ if (report_overflow)
+ scm_num_overflow (FUNC_NAME);
+
+ if (position_of_wrong_type)
+ SCM_WRONG_TYPE_ARG (position_of_wrong_type,
+ value_of_wrong_type);
+
+ return scm_i_normbig (result);
+}
+#undef FUNC_NAME
+
SCM_DEFINE (scm_integer_expt, "integer-expt", 2, 0, 0,
(SCM n, SCM k),
"Return @var{n} raised to the non-negative integer exponent\n"
else if (SCM_BIGP (k))
{
z_i2 = scm_i_clonebig (k, 1);
- mpz_init_set (SCM_I_BIG_MPZ (z_i2), SCM_I_BIG_MPZ (k));
scm_remember_upto_here_1 (k);
i2_is_big = 1;
}
if ((r > SCM_MOST_POSITIVE_FIXNUM) || (r < SCM_MOST_NEGATIVE_FIXNUM))
{
z_i2 = scm_i_mkbig ();
- mpz_init_set_d (SCM_I_BIG_MPZ (z_i2), r);
+ mpz_set_d (SCM_I_BIG_MPZ (z_i2), r);
i2_is_big = 1;
}
else
{
if (mpz_sgn(SCM_I_BIG_MPZ (z_i2)) == 0)
{
- mpz_clear (SCM_I_BIG_MPZ (z_i2));
return acc;
}
if (mpz_cmp_ui(SCM_I_BIG_MPZ (z_i2), 1) == 0)
{
- mpz_clear (SCM_I_BIG_MPZ (z_i2));
return scm_product (acc, n);
}
if (mpz_tstbit(SCM_I_BIG_MPZ (z_i2), 0))
#undef FUNC_NAME
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+
SCM_DEFINE (scm_bit_extract, "bit-extract", 3, 0, 0,
(SCM n, SCM start, SCM end),
"Return the integer composed of the @var{start} (inclusive)\n"
"@end lisp")
#define FUNC_NAME s_scm_bit_extract
{
- unsigned long int istart, iend;
+ unsigned long int istart, iend, bits;
SCM_VALIDATE_INUM_MIN_COPY (2, start,0, istart);
SCM_VALIDATE_INUM_MIN_COPY (3, end, 0, iend);
SCM_ASSERT_RANGE (3, end, (iend >= istart));
+ /* how many bits to keep */
+ bits = iend - istart;
+
if (SCM_INUMP (n))
{
long int in = SCM_INUM (n);
- unsigned long int bits = iend - istart;
+
+ /* When istart>=SCM_I_FIXNUM_BIT we can just limit the shift to
+ SCM_I_FIXNUM_BIT-1 to get either 0 or -1 per the sign of "in".
+ FIXME: This shift relies on signed right shifts being arithmetic,
+ which is not guaranteed by C99. */
+ in >>= MIN (istart, SCM_I_FIXNUM_BIT-1);
if (in < 0 && bits >= SCM_I_FIXNUM_BIT)
{
/* Since we emulate two's complement encoded numbers, this
* special case requires us to produce a result that has
- * more bits than can be stored in a fixnum. Thus, we fall
- * back to the more general algorithm that is used for
- * bignums.
+ * more bits than can be stored in a fixnum.
*/
- goto generalcase;
+ SCM result = scm_i_long2big (in);
+ mpz_fdiv_r_2exp (SCM_I_BIG_MPZ (result), SCM_I_BIG_MPZ (result),
+ bits);
+ return result;
}
- if (istart < SCM_I_FIXNUM_BIT)
- {
- in = in >> istart;
- if (bits < SCM_I_FIXNUM_BIT)
- return SCM_MAKINUM (in & ((1L << bits) - 1));
- else /* we know: in >= 0 */
- return SCM_MAKINUM (in);
- }
- else if (in < 0)
- return SCM_MAKINUM (-1L & ((1L << bits) - 1));
- else
- return SCM_MAKINUM (0);
+ /* mask down to requisite bits */
+ bits = MIN (bits, SCM_I_FIXNUM_BIT);
+ return SCM_MAKINUM (in & ((1L << bits) - 1));
}
else if (SCM_BIGP (n))
{
- generalcase:
- {
- SCM num1 = SCM_MAKINUM (1L);
- SCM num2 = SCM_MAKINUM (2L);
- SCM bits = SCM_MAKINUM (iend - istart);
- SCM mask = scm_difference (scm_integer_expt (num2, bits), num1);
- return scm_logand (mask, scm_ash (n, SCM_MAKINUM (-istart)));
- }
+ SCM result;
+ if (bits == 1)
+ {
+ result = SCM_MAKINUM (mpz_tstbit (SCM_I_BIG_MPZ (n), istart));
+ }
+ else
+ {
+ /* ENHANCE-ME: It'd be nice not to allocate a new bignum when
+ bits<SCM_I_FIXNUM_BIT. Would want some help from GMP to get
+ such bits into a ulong. */
+ result = scm_i_mkbig ();
+ mpz_fdiv_q_2exp (SCM_I_BIG_MPZ(result), SCM_I_BIG_MPZ(n), istart);
+ mpz_fdiv_r_2exp (SCM_I_BIG_MPZ(result), SCM_I_BIG_MPZ(result), bits);
+ result = scm_i_normbig (result);
+ }
+ scm_remember_upto_here_1 (n);
+ return result;
}
else
SCM_WRONG_TYPE_ARG (SCM_ARG1, n);
}
#undef FUNC_NAME
+
static const char scm_logtab[] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
};
{
scm_i_fraction_reduce (x);
scm_i_fraction_reduce (y);
- return SCM_BOOL (scm_equal_p (SCM_FRACTION_NUMERATOR (x), SCM_FRACTION_NUMERATOR (y))
- && scm_equal_p (SCM_FRACTION_DENOMINATOR (x), SCM_FRACTION_DENOMINATOR (y)));
+ if (SCM_FALSEP (scm_equal_p (SCM_FRACTION_NUMERATOR (x),
+ SCM_FRACTION_NUMERATOR (y)))
+ || SCM_FALSEP (scm_equal_p (SCM_FRACTION_DENOMINATOR (x),
+ SCM_FRACTION_DENOMINATOR (y))))
+ return SCM_BOOL_F;
+ else
+ return SCM_BOOL_T;
}
SCM
scm_num_eq_p (SCM x, SCM y)
{
+ again:
if (SCM_INUMP (x))
{
long xx = SCM_INUM (x);
return SCM_BOOL ((SCM_REAL_VALUE (x) == SCM_COMPLEX_REAL (y))
&& (0.0 == SCM_COMPLEX_IMAG (y)));
else if (SCM_FRACTIONP (y))
- return SCM_BOOL (SCM_REAL_VALUE (x) == scm_i_fraction2double (y));
+ {
+ double xx = SCM_REAL_VALUE (x);
+ if (xisnan (xx))
+ return SCM_BOOL_F;
+ if (xisinf (xx))
+ return SCM_BOOL (xx < 0.0);
+ x = scm_inexact_to_exact (x); /* with x as frac or int */
+ goto again;
+ }
else
SCM_WTA_DISPATCH_2 (g_eq_p, x, y, SCM_ARGn, s_eq_p);
}
return SCM_BOOL ((SCM_COMPLEX_REAL (x) == SCM_COMPLEX_REAL (y))
&& (SCM_COMPLEX_IMAG (x) == SCM_COMPLEX_IMAG (y)));
else if (SCM_FRACTIONP (y))
- return SCM_BOOL ((SCM_COMPLEX_REAL (x) == scm_i_fraction2double (y))
- && (SCM_COMPLEX_IMAG (x) == 0.0));
+ {
+ double xx;
+ if (SCM_COMPLEX_IMAG (x) != 0.0)
+ return SCM_BOOL_F;
+ xx = SCM_COMPLEX_REAL (x);
+ if (xisnan (xx))
+ return SCM_BOOL_F;
+ if (xisinf (xx))
+ return SCM_BOOL (xx < 0.0);
+ x = scm_inexact_to_exact (x); /* with x as frac or int */
+ goto again;
+ }
else
SCM_WTA_DISPATCH_2 (g_eq_p, x, y, SCM_ARGn, s_eq_p);
}
else if (SCM_BIGP (y))
return SCM_BOOL_F;
else if (SCM_REALP (y))
- return SCM_BOOL (scm_i_fraction2double (x) == SCM_REAL_VALUE (y));
+ {
+ double yy = SCM_REAL_VALUE (y);
+ if (xisnan (yy))
+ return SCM_BOOL_F;
+ if (xisinf (yy))
+ return SCM_BOOL (0.0 < yy);
+ y = scm_inexact_to_exact (y); /* with y as frac or int */
+ goto again;
+ }
else if (SCM_COMPLEXP (y))
- return SCM_BOOL ((scm_i_fraction2double (x) == SCM_COMPLEX_REAL (y))
- && (0.0 == SCM_COMPLEX_IMAG (y)));
+ {
+ double yy;
+ if (SCM_COMPLEX_IMAG (y) != 0.0)
+ return SCM_BOOL_F;
+ yy = SCM_COMPLEX_REAL (y);
+ if (xisnan (yy))
+ return SCM_BOOL_F;
+ if (xisinf (yy))
+ return SCM_BOOL (0.0 < yy);
+ y = scm_inexact_to_exact (y); /* with y as frac or int */
+ goto again;
+ }
else if (SCM_FRACTIONP (y))
return scm_i_fraction_equalp (x, y);
else
}
+/* OPTIMIZE-ME: For int/frac and frac/frac compares, the multiplications
+ done are good for inums, but for bignums an answer can almost always be
+ had by just examining a few high bits of the operands, as done by GMP in
+ mpq_cmp. flonum/frac compares likewise, but with the slight complication
+ of the float exponent to take into account. */
+
SCM_GPROC1 (s_less_p, "<", scm_tc7_rpsubr, scm_less_p, g_less_p);
/* "Return @code{#t} if the list of parameters is monotonically\n"
* "increasing."
SCM
scm_less_p (SCM x, SCM y)
{
+ again:
if (SCM_INUMP (x))
{
long xx = SCM_INUM (x);
else if (SCM_REALP (y))
return SCM_BOOL ((double) xx < SCM_REAL_VALUE (y));
else if (SCM_FRACTIONP (y))
- return SCM_BOOL ((double) xx < scm_i_fraction2double (y));
+ {
+ /* "x < a/b" becomes "x*b < a" */
+ int_frac:
+ x = scm_product (x, SCM_FRACTION_DENOMINATOR (y));
+ y = SCM_FRACTION_NUMERATOR (y);
+ goto again;
+ }
else
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
}
return SCM_BOOL (cmp < 0);
}
else if (SCM_FRACTIONP (y))
- {
- int cmp;
- cmp = xmpz_cmp_d (SCM_I_BIG_MPZ (x), scm_i_fraction2double (y));
- scm_remember_upto_here_1 (x);
- return SCM_BOOL (cmp < 0);
- }
+ goto int_frac;
else
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
}
else if (SCM_REALP (y))
return SCM_BOOL (SCM_REAL_VALUE (x) < SCM_REAL_VALUE (y));
else if (SCM_FRACTIONP (y))
- return SCM_BOOL (SCM_REAL_VALUE (x) < scm_i_fraction2double (y));
+ {
+ double xx = SCM_REAL_VALUE (x);
+ if (xisnan (xx))
+ return SCM_BOOL_F;
+ if (xisinf (xx))
+ return SCM_BOOL (xx < 0.0);
+ x = scm_inexact_to_exact (x); /* with x as frac or int */
+ goto again;
+ }
else
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
}
else if (SCM_FRACTIONP (x))
{
- if (SCM_INUMP (y))
- return SCM_BOOL (scm_i_fraction2double (x) < (double) SCM_INUM (y));
- else if (SCM_BIGP (y))
- {
- int cmp;
- if (xisnan (SCM_REAL_VALUE (x)))
- return SCM_BOOL_F;
- cmp = xmpz_cmp_d (SCM_I_BIG_MPZ (y), scm_i_fraction2double (x));
- scm_remember_upto_here_1 (y);
- return SCM_BOOL (cmp > 0);
- }
+ if (SCM_INUMP (y) || SCM_BIGP (y))
+ {
+ /* "a/b < y" becomes "a < y*b" */
+ y = scm_product (y, SCM_FRACTION_DENOMINATOR (x));
+ x = SCM_FRACTION_NUMERATOR (x);
+ goto again;
+ }
else if (SCM_REALP (y))
- return SCM_BOOL (scm_i_fraction2double (x) < SCM_REAL_VALUE (y));
+ {
+ double yy = SCM_REAL_VALUE (y);
+ if (xisnan (yy))
+ return SCM_BOOL_F;
+ if (xisinf (yy))
+ return SCM_BOOL (0.0 < yy);
+ y = scm_inexact_to_exact (y); /* with y as frac or int */
+ goto again;
+ }
else if (SCM_FRACTIONP (y))
- return SCM_BOOL (scm_i_fraction2double (x) < scm_i_fraction2double (y));
+ {
+ /* "a/b < c/d" becomes "a*d < c*b" */
+ SCM new_x = scm_product (SCM_FRACTION_NUMERATOR (x),
+ SCM_FRACTION_DENOMINATOR (y));
+ SCM new_y = scm_product (SCM_FRACTION_NUMERATOR (y),
+ SCM_FRACTION_DENOMINATOR (x));
+ x = new_x;
+ y = new_y;
+ goto again;
+ }
else
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
}
}
+/* scm_min and scm_max return an inexact when either argument is inexact, as
+ required by r5rs. On that basis, for exact/inexact combinations the
+ exact is converted to inexact to compare and possibly return. This is
+ unlike scm_less_p above which takes some trouble to preserve all bits in
+ its test, such trouble is not required for min and max. */
+
SCM_GPROC1 (s_max, "max", scm_tc7_asubr, scm_max, g_max);
/* "Return the maximum of all parameter values."
*/
{
if (SCM_UNBNDP (x))
SCM_WTA_DISPATCH_0 (g_max, s_max);
- else if (SCM_NUMBERP (x))
+ else if (SCM_INUMP(x) || SCM_BIGP(x) || SCM_REALP(x) || SCM_FRACTIONP(x))
return x;
else
SCM_WTA_DISPATCH_1 (g_max, x, SCM_ARG1, s_max);
}
else if (SCM_REALP (y))
{
- double yy = SCM_REAL_VALUE (y);
- int cmp;
- if (xisnan (yy))
- return y;
- cmp = xmpz_cmp_d (SCM_I_BIG_MPZ (x), yy);
- scm_remember_upto_here_1 (x);
- return (cmp > 0) ? x : y;
+ /* if y==NaN then xx>yy is false, so we return the NaN y */
+ double xx, yy;
+ big_real:
+ xx = scm_i_big2dbl (x);
+ yy = SCM_REAL_VALUE (y);
+ return (xx > yy ? scm_make_real (xx) : y);
}
else if (SCM_FRACTIONP (y))
{
}
else if (SCM_BIGP (y))
{
- double xx = SCM_REAL_VALUE (x);
- int cmp;
- if (xisnan (xx))
- return x;
- cmp = xmpz_cmp_d (SCM_I_BIG_MPZ (y), xx);
- scm_remember_upto_here_1 (y);
- return (cmp < 0) ? x : y;
+ SCM t = x; x = y; y = t;
+ goto big_real;
}
else if (SCM_REALP (y))
{
{
if (SCM_UNBNDP (x))
SCM_WTA_DISPATCH_0 (g_min, s_min);
- else if (SCM_NUMBERP (x))
+ else if (SCM_INUMP(x) || SCM_BIGP(x) || SCM_REALP(x) || SCM_FRACTIONP(x))
return x;
else
SCM_WTA_DISPATCH_1 (g_min, x, SCM_ARG1, s_min);
}
else if (SCM_REALP (y))
{
- double yy = SCM_REAL_VALUE (y);
- int cmp;
- if (xisnan (yy))
- return y;
- cmp = xmpz_cmp_d (SCM_I_BIG_MPZ (x), yy);
- scm_remember_upto_here_1 (x);
- return (cmp > 0) ? y : x;
+ /* if y==NaN then xx<yy is false, so we return the NaN y */
+ double xx, yy;
+ big_real:
+ xx = scm_i_big2dbl (x);
+ yy = SCM_REAL_VALUE (y);
+ return (xx < yy ? scm_make_real (xx) : y);
}
else if (SCM_FRACTIONP (y))
{
}
else if (SCM_BIGP (y))
{
- double xx = SCM_REAL_VALUE (x);
- int cmp;
- if (xisnan (xx))
- return x;
- cmp = xmpz_cmp_d (SCM_I_BIG_MPZ (y), xx);
- scm_remember_upto_here_1 (y);
- return (cmp < 0) ? y : x;
+ SCM t = x; x = y; y = t;
+ goto big_real;
}
else if (SCM_REALP (y))
{
else if (SCM_COMPLEXP (z))
return scm_make_real (SCM_COMPLEX_REAL (z));
else if (SCM_FRACTIONP (z))
- return scm_make_real (scm_i_fraction2double (z));
+ return z;
else
SCM_WTA_DISPATCH_1 (g_real_part, z, SCM_ARG1, s_real_part);
}
SCM_FALSEP
(scm_gr_p (scm_abs (scm_difference (ex, scm_divide (a, b))),
err))) /* abs(x-a/b) <= err */
- return scm_sum (int_part, scm_divide (a, b)); /* int_part+a/b */
+ {
+ SCM res = scm_sum (int_part, scm_divide (a, b));
+ if (SCM_FALSEP (scm_exact_p (x))
+ || SCM_FALSEP (scm_exact_p (err)))
+ return scm_exact_to_inexact (res);
+ else
+ return res;
+ }
rx = scm_divide (scm_difference (rx, tt), /* rx = 1/(rx - tt) */
SCM_UNDEFINED);
tt = scm_floor (rx); /* tt = floor (rx) */
void
scm_init_numbers ()
{
- abs_most_negative_fixnum = scm_i_long2big (- SCM_MOST_NEGATIVE_FIXNUM);
- scm_permanent_object (abs_most_negative_fixnum);
-
mpz_init_set_si (z_negative_one, -1);
/* It may be possible to tune the performance of some algorithms by using