cpython-lru_cache-weakref: Modules/mathmodule.c annotate

annotate Modules/mathmodule.c @ 47192:32bd18709dfd legacy-trunk

Improve diffing logic and output for test_pydoc.

author	Georg Brandl <georg@python.org>
date	Tue, 20 May 2008 08:07:36 +0000
parents	fd0b894bc90c
children	2fffdedb10f8

rev	line source
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1 /* Math module -- standard C math library functions, pi and e */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	3 /* Here are some comments from Tim Peters, extracted from the
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	4 discussion attached to http://bugs.python.org/issue1640. They
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	5 describe the general aims of the math module with respect to
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	6 special values, IEEE-754 floating-point exceptions, and Python
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	7 exceptions.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	8
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	9 These are the "spirit of 754" rules:
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	10
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	11 1. If the mathematical result is a real number, but of magnitude too
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	12 large to approximate by a machine float, overflow is signaled and the
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	13 result is an infinity (with the appropriate sign).
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	14
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	15 2. If the mathematical result is a real number, but of magnitude too
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	16 small to approximate by a machine float, underflow is signaled and the
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	17 result is a zero (with the appropriate sign).
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	18
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	19 3. At a singularity (a value x such that the limit of f(y) as y
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	20 approaches x exists and is an infinity), "divide by zero" is signaled
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	21 and the result is an infinity (with the appropriate sign). This is
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	22 complicated a little by that the left-side and right-side limits may
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	23 not be the same; e.g., 1/x approaches +inf or -inf as x approaches 0
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	24 from the positive or negative directions. In that specific case, the
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	25 sign of the zero determines the result of 1/0.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	26
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	27 4. At a point where a function has no defined result in the extended
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	28 reals (i.e., the reals plus an infinity or two), invalid operation is
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	29 signaled and a NaN is returned.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	30
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	31 And these are what Python has historically /tried/ to do (but not
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	32 always successfully, as platform libm behavior varies a lot):
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	33
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	34 For #1, raise OverflowError.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	35
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	36 For #2, return a zero (with the appropriate sign if that happens by
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	37 accident ;-)).
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	38
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	39 For #3 and #4, raise ValueError. It may have made sense to raise
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	40 Python's ZeroDivisionError in #3, but historically that's only been
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	41 raised for division by zero and mod by zero.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	42
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	43 */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	44
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	45 /*
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	46 In general, on an IEEE-754 platform the aim is to follow the C99
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	47 standard, including Annex 'F', whenever possible. Where the
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	48 standard recommends raising the 'divide-by-zero' or 'invalid'
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	49 floating-point exceptions, Python should raise a ValueError. Where
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	50 the standard recommends raising 'overflow', Python should raise an
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	51 OverflowError. In all other circumstances a value should be
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	52 returned.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	53 */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	54
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	55 #include "Python.h"
34872 0143d990d60c Make that a C, not a C++, comment. Michael W. Hudson <mwh@python.net> parents: 34871 diff changeset	56 #include "longintrepr.h" /* just for SHIFT */
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	57
44940 12099143724f Add prototypes to get the mathmodule.c to compile on OSF1 5.1 (Tru64) Neal Norwitz <nnorwitz@gmail.com> parents: 44488 diff changeset	58 #ifdef _OSF_SOURCE
12099143724f Add prototypes to get the mathmodule.c to compile on OSF1 5.1 (Tru64) Neal Norwitz <nnorwitz@gmail.com> parents: 44488 diff changeset	59 /* OSF1 5.1 doesn't make this available with XOPEN_SOURCE_EXTENDED defined */
12099143724f Add prototypes to get the mathmodule.c to compile on OSF1 5.1 (Tru64) Neal Norwitz <nnorwitz@gmail.com> parents: 44488 diff changeset	60 extern double copysign(double, double);
12099143724f Add prototypes to get the mathmodule.c to compile on OSF1 5.1 (Tru64) Neal Norwitz <nnorwitz@gmail.com> parents: 44488 diff changeset	61 #endif
12099143724f Add prototypes to get the mathmodule.c to compile on OSF1 5.1 (Tru64) Neal Norwitz <nnorwitz@gmail.com> parents: 44488 diff changeset	62
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	63 /* Call is_error when errno != 0, and where x is the result libm
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	64 * returned. is_error will usually set up an exception and return
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	65 * true (1), but may return false (0) without setting up an exception.
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	66 */
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	67 static int
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	68 is_error(double x)
498 56bb1067a880 Improve error handling. Guido van Rossum <guido@python.org> parents: 438 diff changeset	69 {
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	70 int result = 1; /* presumption of guilt */
15181 2ed358446f2f Repaired a comment and asserted a precondition. Tim Peters <tim.peters@gmail.com> parents: 15170 diff changeset	71 assert(errno); /* non-zero errno is a precondition for calling */
498 56bb1067a880 Improve error handling. Guido van Rossum <guido@python.org> parents: 438 diff changeset	72 if (errno == EDOM)
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	73 PyErr_SetString(PyExc_ValueError, "math domain error");
19750 35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	74
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	75 else if (errno == ERANGE) {
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	76 /* ANSI C generally requires libm functions to set ERANGE
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	77 * on overflow, but also generally allows them to set
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	78 * ERANGE on underflow too. There's no consistency about
19750 35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	79 * the latter across platforms.
35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	80 * Alas, C99 never requires that errno be set.
35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	81 * Here we suppress the underflow errors (libm functions
35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	82 * should return a zero on underflow, and +- HUGE_VAL on
35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	83 * overflow, so testing the result for zero suffices to
35b6a1d0b1e0 Rework the way we try to check for libm overflow, given that C99 no longer Tim Peters <tim.peters@gmail.com> parents: 19730 diff changeset	84 * distinguish the cases).
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	85 */
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	86 if (x)
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	87 PyErr_SetString(PyExc_OverflowError,
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	88 "math range error");
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	89 else
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	90 result = 0;
09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	91 }
498 56bb1067a880 Improve error handling. Guido van Rossum <guido@python.org> parents: 438 diff changeset	92 else
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	93 /* Unexpected math error */
49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	94 PyErr_SetFromErrno(PyExc_ValueError);
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	95 return result;
498 56bb1067a880 Improve error handling. Guido van Rossum <guido@python.org> parents: 438 diff changeset	96 }
56bb1067a880 Improve error handling. Guido van Rossum <guido@python.org> parents: 438 diff changeset	97
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	98 /*
46507 022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	99 wrapper for atan2 that deals directly with special cases before
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	100 delegating to the platform libm for the remaining cases. This
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	101 is necessary to get consistent behaviour across platforms.
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	102 Windows, FreeBSD and alpha Tru64 are amongst platforms that don't
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	103 always follow C99.
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	104 */
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	105
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	106 static double
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	107 m_atan2(double y, double x)
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	108 {
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	109 if (Py_IS_NAN(x) \|\| Py_IS_NAN(y))
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	110 return Py_NAN;
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	111 if (Py_IS_INFINITY(y)) {
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	112 if (Py_IS_INFINITY(x)) {
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	113 if (copysign(1., x) == 1.)
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	114 /* atan2(+-inf, +inf) == +-pi/4 */
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	115 return copysign(0.25*Py_MATH_PI, y);
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	116 else
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	117 /* atan2(+-inf, -inf) == +-pi3/4 /
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	118 return copysign(0.75*Py_MATH_PI, y);
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	119 }
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	120 /* atan2(+-inf, x) == +-pi/2 for finite x */
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	121 return copysign(0.5*Py_MATH_PI, y);
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	122 }
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	123 if (Py_IS_INFINITY(x) \|\| y == 0.) {
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	124 if (copysign(1., x) == 1.)
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	125 /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	126 return copysign(0., y);
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	127 else
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	128 /* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	129 return copysign(Py_MATH_PI, y);
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	130 }
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	131 return atan2(y, x);
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	132 }
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	133
022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	134 /*
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	135 math_1 is used to wrap a libm function f that takes a double
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	136 arguments and returns a double.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	137
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	138 The error reporting follows these rules, which are designed to do
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	139 the right thing on C89/C99 platforms and IEEE 754/non IEEE 754
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	140 platforms.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	141
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	142 - a NaN result from non-NaN inputs causes ValueError to be raised
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	143 - an infinite result from finite inputs causes OverflowError to be
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	144 raised if can_overflow is 1, or raises ValueError if can_overflow
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	145 is 0.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	146 - if the result is finite and errno == EDOM then ValueError is
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	147 raised
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	148 - if the result is finite and nonzero and errno == ERANGE then
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	149 OverflowError is raised
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	150
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	151 The last rule is used to catch overflow on platforms which follow
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	152 C89 but for which HUGE_VAL is not an infinity.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	153
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	154 For the majority of one-argument functions these rules are enough
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	155 to ensure that Python's functions behave as specified in 'Annex F'
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	156 of the C99 standard, with the 'invalid' and 'divide-by-zero'
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	157 floating-point exceptions mapping to Python's ValueError and the
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	158 'overflow' floating-point exception mapping to OverflowError.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	159 math_1 only works for functions that don't have singularities and
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	160 the possibility of overflow; fortunately, that covers everything we
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	161 care about right now.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	162 */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	163
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	164 static PyObject *
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	165 math_1(PyObject arg, double (func) (double), int can_overflow)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	166 {
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	167 double x, r;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	168 x = PyFloat_AsDouble(arg);
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	169 if (x == -1.0 && PyErr_Occurred())
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	170 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	171 errno = 0;
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	172 PyFPE_START_PROTECT("in math_1", return 0);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	173 r = (*func)(x);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	174 PyFPE_END_PROTECT(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	175 if (Py_IS_NAN(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	176 if (!Py_IS_NAN(x))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	177 errno = EDOM;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	178 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	179 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	180 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	181 else if (Py_IS_INFINITY(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	182 if (Py_IS_FINITE(x))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	183 errno = can_overflow ? ERANGE : EDOM;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	184 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	185 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	186 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	187 if (errno && is_error(r))
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	188 return NULL;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	189 else
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	190 return PyFloat_FromDouble(r);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	191 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	192
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	193 /*
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	194 math_2 is used to wrap a libm function f that takes two double
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	195 arguments and returns a double.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	196
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	197 The error reporting follows these rules, which are designed to do
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	198 the right thing on C89/C99 platforms and IEEE 754/non IEEE 754
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	199 platforms.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	200
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	201 - a NaN result from non-NaN inputs causes ValueError to be raised
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	202 - an infinite result from finite inputs causes OverflowError to be
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	203 raised.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	204 - if the result is finite and errno == EDOM then ValueError is
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	205 raised
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	206 - if the result is finite and nonzero and errno == ERANGE then
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	207 OverflowError is raised
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	208
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	209 The last rule is used to catch overflow on platforms which follow
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	210 C89 but for which HUGE_VAL is not an infinity.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	211
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	212 For most two-argument functions (copysign, fmod, hypot, atan2)
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	213 these rules are enough to ensure that Python's functions behave as
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	214 specified in 'Annex F' of the C99 standard, with the 'invalid' and
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	215 'divide-by-zero' floating-point exceptions mapping to Python's
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	216 ValueError and the 'overflow' floating-point exception mapping to
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	217 OverflowError.
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	218 */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	219
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	220 static PyObject *
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	221 math_2(PyObject args, double (func) (double, double), char *funcname)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	222 {
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	223 PyObject ox, oy;
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	224 double x, y, r;
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	225 if (! PyArg_UnpackTuple(args, funcname, 2, 2, &ox, &oy))
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	226 return NULL;
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	227 x = PyFloat_AsDouble(ox);
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	228 y = PyFloat_AsDouble(oy);
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	229 if ((x == -1.0 \|\| y == -1.0) && PyErr_Occurred())
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	230 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	231 errno = 0;
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	232 PyFPE_START_PROTECT("in math_2", return 0);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	233 r = (*func)(x, y);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	234 PyFPE_END_PROTECT(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	235 if (Py_IS_NAN(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	236 if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	237 errno = EDOM;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	238 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	239 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	240 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	241 else if (Py_IS_INFINITY(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	242 if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	243 errno = ERANGE;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	244 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	245 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	246 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	247 if (errno && is_error(r))
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	248 return NULL;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	249 else
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	250 return PyFloat_FromDouble(r);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	251 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	252
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	253 #define FUNC1(funcname, func, can_overflow, docstring) \
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	254 static PyObject * math_##funcname(PyObject self, PyObject args) { \
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	255 return math_1(args, func, can_overflow); \
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	256 }\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	257 PyDoc_STRVAR(math_##funcname##_doc, docstring);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	258
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	259 #define FUNC2(funcname, func, docstring) \
24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	260 static PyObject * math_##funcname(PyObject self, PyObject args) { \
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	261 return math_2(args, func, #funcname); \
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	262 }\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	263 PyDoc_STRVAR(math_##funcname##_doc, docstring);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	264
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	265 FUNC1(acos, acos, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	266 "acos(x)\n\nReturn the arc cosine (measured in radians) of x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	267 FUNC1(acosh, acosh, 0,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	268 "acosh(x)\n\nReturn the hyperbolic arc cosine (measured in radians) of x.")
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	269 FUNC1(asin, asin, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	270 "asin(x)\n\nReturn the arc sine (measured in radians) of x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	271 FUNC1(asinh, asinh, 0,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	272 "asinh(x)\n\nReturn the hyperbolic arc sine (measured in radians) of x.")
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	273 FUNC1(atan, atan, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	274 "atan(x)\n\nReturn the arc tangent (measured in radians) of x.")
46507 022296032d8f math.atan2 is misbehaving on Windows; this patch Mark Dickinson <dickinsm@gmail.com> parents: 46500 diff changeset	275 FUNC2(atan2, m_atan2,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	276 "atan2(y, x)\n\nReturn the arc tangent (measured in radians) of y/x.\n"
e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	277 "Unlike atan(y/x), the signs of both x and y are considered.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	278 FUNC1(atanh, atanh, 0,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	279 "atanh(x)\n\nReturn the hyperbolic arc tangent (measured in radians) of x.")
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	280 FUNC1(ceil, ceil, 0,
44488 94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This Jeffrey Yasskin <jyasskin@gmail.com> parents: 44453 diff changeset	281 "ceil(x)\n\nReturn the ceiling of x as a float.\n"
94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This Jeffrey Yasskin <jyasskin@gmail.com> parents: 44453 diff changeset	282 "This is the smallest integral value >= x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	283 FUNC2(copysign, copysign,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	284 "copysign(x,y)\n\nReturn x with the sign of y.")
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	285 FUNC1(cos, cos, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	286 "cos(x)\n\nReturn the cosine of x (measured in radians).")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	287 FUNC1(cosh, cosh, 1,
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	288 "cosh(x)\n\nReturn the hyperbolic cosine of x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	289 FUNC1(exp, exp, 1,
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	290 "exp(x)\n\nReturn e raised to the power of x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	291 FUNC1(fabs, fabs, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	292 "fabs(x)\n\nReturn the absolute value of the float x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	293 FUNC1(floor, floor, 0,
44488 94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This Jeffrey Yasskin <jyasskin@gmail.com> parents: 44453 diff changeset	294 "floor(x)\n\nReturn the floor of x as a float.\n"
94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This Jeffrey Yasskin <jyasskin@gmail.com> parents: 44453 diff changeset	295 "This is the largest integral value <= x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	296 FUNC1(log1p, log1p, 1,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	297 "log1p(x)\n\nReturn the natural logarithm of 1+x (base e).\n\
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	298 The result is computed in a way which is accurate for x near zero.")
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	299 FUNC1(sin, sin, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	300 "sin(x)\n\nReturn the sine of x (measured in radians).")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	301 FUNC1(sinh, sinh, 1,
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	302 "sinh(x)\n\nReturn the hyperbolic sine of x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	303 FUNC1(sqrt, sqrt, 0,
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	304 "sqrt(x)\n\nReturn the square root of x.")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	305 FUNC1(tan, tan, 0,
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	306 "tan(x)\n\nReturn the tangent of x (measured in radians).")
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	307 FUNC1(tanh, tanh, 0,
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	308 "tanh(x)\n\nReturn the hyperbolic tangent of x.")
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	309
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	310 static PyObject *
45079 492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	311 math_trunc(PyObject self, PyObject number)
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	312 {
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	313 return PyObject_CallMethod(number, "__trunc__", NULL);
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	314 }
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	315
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	316 PyDoc_STRVAR(math_trunc_doc,
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	317 "trunc(x:Real) -> Integral\n"
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	318 "\n"
45102 ce9816f53690 Neaten-up a bit. Raymond Hettinger <python@rcn.com> parents: 45079 diff changeset	319 "Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.");
45079 492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	320
492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	321 static PyObject *
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	322 math_frexp(PyObject self, PyObject arg)
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	323 {
9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	324 int i;
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	325 double x = PyFloat_AsDouble(arg);
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	326 if (x == -1.0 && PyErr_Occurred())
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	327 return NULL;
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	328 /* deal with special cases directly, to sidestep platform
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	329 differences */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	330 if (Py_IS_NAN(x) \|\| Py_IS_INFINITY(x) \|\| !x) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	331 i = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	332 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	333 else {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	334 PyFPE_START_PROTECT("in math_frexp", return 0);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	335 x = frexp(x, &i);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	336 PyFPE_END_PROTECT(x);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	337 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	338 return Py_BuildValue("(di)", x, i);
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	339 }
9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	340
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	341 PyDoc_STRVAR(math_frexp_doc,
19712 b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	342 "frexp(x)\n"
b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	343 "\n"
b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	344 "Return the mantissa and exponent of x, as pair (m, e).\n"
b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	345 "m is a float and e is an int, such that x = m * 2.**e.\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	346 "If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.");
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	347
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	348 static PyObject *
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	349 math_ldexp(PyObject self, PyObject args)
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	350 {
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	351 double x, r;
46797 fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	352 PyObject *oexp;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	353 long exp;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	354 if (! PyArg_ParseTuple(args, "dO:ldexp", &x, &oexp))
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	355 return NULL;
46797 fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	356
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	357 if (PyLong_Check(oexp)) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	358 /* on overflow, replace exponent with either LONG_MAX
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	359 or LONG_MIN, depending on the sign. */
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	360 exp = PyLong_AsLong(oexp);
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	361 if (exp == -1 && PyErr_Occurred()) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	362 if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	363 if (Py_SIZE(oexp) < 0) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	364 exp = LONG_MIN;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	365 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	366 else {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	367 exp = LONG_MAX;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	368 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	369 PyErr_Clear();
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	370 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	371 else {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	372 /* propagate any unexpected exception */
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	373 return NULL;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	374 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	375 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	376 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	377 else if (PyInt_Check(oexp)) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	378 exp = PyInt_AS_LONG(oexp);
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	379 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	380 else {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	381 PyErr_SetString(PyExc_TypeError,
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	382 "Expected an int or long as second argument "
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	383 "to ldexp.");
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	384 return NULL;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	385 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	386
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	387 if (x == 0. \|\| !Py_IS_FINITE(x)) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	388 /* NaNs, zeros and infinities are returned unchanged */
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	389 r = x;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	390 errno = 0;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	391 } else if (exp > INT_MAX) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	392 /* overflow */
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	393 r = copysign(Py_HUGE_VAL, x);
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	394 errno = ERANGE;
46797 fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	395 } else if (exp < INT_MIN) {
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	396 /* underflow to +-0 */
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	397 r = copysign(0., x);
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	398 errno = 0;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	399 } else {
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	400 errno = 0;
46797 fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	401 PyFPE_START_PROTECT("in math_ldexp", return 0);
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	402 r = ldexp(x, (int)exp);
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	403 PyFPE_END_PROTECT(r);
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	404 if (Py_IS_INFINITY(r))
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	405 errno = ERANGE;
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	406 }
fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	407
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	408 if (errno && is_error(r))
15170 09c7ac188ce2 Stop raising OverflowError on underflows reported by libm (errno==ERANGE and Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	409 return NULL;
46797 fd0b894bc90c Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and Mark Dickinson <dickinsm@gmail.com> parents: 46509 diff changeset	410 return PyFloat_FromDouble(r);
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	411 }
9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	412
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	413 PyDoc_STRVAR(math_ldexp_doc,
ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	414 "ldexp(x, i) -> x * (2**i)");
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	415
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	416 static PyObject *
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	417 math_modf(PyObject self, PyObject arg)
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	418 {
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	419 double y, x = PyFloat_AsDouble(arg);
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	420 if (x == -1.0 && PyErr_Occurred())
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	421 return NULL;
46499 80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	422 /* some platforms don't do the right thing for NaNs and
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	423 infinities, so we take care of special cases directly. */
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	424 if (!Py_IS_FINITE(x)) {
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	425 if (Py_IS_INFINITY(x))
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	426 return Py_BuildValue("(dd)", copysign(0., x), x);
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	427 else if (Py_IS_NAN(x))
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	428 return Py_BuildValue("(dd)", x, x);
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	429 }
80b16595e462 FreeBSD doesn't follow C99 for modf(inf); so add explicit Mark Dickinson <dickinsm@gmail.com> parents: 46490 diff changeset	430
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	431 errno = 0;
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	432 PyFPE_START_PROTECT("in math_modf", return 0);
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	433 x = modf(x, &y);
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	434 PyFPE_END_PROTECT(x);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	435 return Py_BuildValue("(dd)", x, y);
407 9b3d557665a9 Added frexp, ldexp, modf, fmod. Guido van Rossum <guido@python.org> parents: 320 diff changeset	436 }
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	437
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	438 PyDoc_STRVAR(math_modf_doc,
19712 b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	439 "modf(x)\n"
b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	440 "\n"
b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	441 "Return the fractional and integer parts of x. Both results carry the sign\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	442 "of x. The integer part is returned as a real.");
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	443
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	444 /* A decent logarithm is easy to compute even for huge longs, but libm can't
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	445 do that by itself -- loghelper can. func is log or log10, and name is
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	446 "log" or "log10". Note that overflow isn't possible: a long can contain
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	447 no more than INT_MAX * SHIFT bits, so has value certainly less than
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	448 2(264 * 216) == 2280, and log2 of that is 280, which is
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	449 small enough to fit in an IEEE single. log and log10 are even smaller.
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	450 */
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	451
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	452 static PyObject*
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	453 loghelper(PyObject* arg, double (func)(double), char funcname)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	454 {
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	455 /* If it is long, do it ourselves. */
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	456 if (PyLong_Check(arg)) {
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	457 double x;
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	458 int e;
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	459 x = _PyLong_AsScaledDouble(arg, &e);
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	460 if (x <= 0.0) {
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	461 PyErr_SetString(PyExc_ValueError,
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	462 "math domain error");
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	463 return NULL;
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	464 }
44947 8e435bdd4bc8 setup.py doesn't pick up changes to a header file Christian Heimes <christian@cheimes.de> parents: 44940 diff changeset	465 /* Value is ~= x * 2*(ePyLong_SHIFT), so the log ~=
8e435bdd4bc8 setup.py doesn't pick up changes to a header file Christian Heimes <christian@cheimes.de> parents: 44940 diff changeset	466 log(x) + log(2) * e * PyLong_SHIFT.
8e435bdd4bc8 setup.py doesn't pick up changes to a header file Christian Heimes <christian@cheimes.de> parents: 44940 diff changeset	467 CAUTION: e*PyLong_SHIFT may overflow using int arithmetic,
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	468 so force use of double. */
44947 8e435bdd4bc8 setup.py doesn't pick up changes to a header file Christian Heimes <christian@cheimes.de> parents: 44940 diff changeset	469 x = func(x) + (e * (double)PyLong_SHIFT) * func(2.0);
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	470 return PyFloat_FromDouble(x);
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	471 }
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	472
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	473 /* Else let libm handle it by itself. */
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	474 return math_1(arg, func, 0);
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	475 }
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	476
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	477 static PyObject *
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	478 math_log(PyObject self, PyObject args)
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	479 {
26661 b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	480 PyObject *arg;
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	481 PyObject *base = NULL;
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	482 PyObject num, den;
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	483 PyObject *ans;
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	484
26818 e094a03a80ff SF patch #659536: Use PyArg_UnpackTuple where possible. Raymond Hettinger <python@rcn.com> parents: 26661 diff changeset	485 if (!PyArg_UnpackTuple(args, "log", 1, 2, &arg, &base))
26661 b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	486 return NULL;
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	487
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	488 num = loghelper(arg, log, "log");
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	489 if (num == NULL \|\| base == NULL)
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	490 return num;
26661 b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	491
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	492 den = loghelper(base, log, "log");
26661 b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	493 if (den == NULL) {
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	494 Py_DECREF(num);
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	495 return NULL;
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	496 }
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	497
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	498 ans = PyNumber_Divide(num, den);
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	499 Py_DECREF(num);
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	500 Py_DECREF(den);
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	501 return ans;
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	502 }
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	503
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	504 PyDoc_STRVAR(math_log_doc,
26661 b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	505 "log(x[, base]) -> the logarithm of x to the given base.\n\
b12e326b4ea2 Apply SF patch 652930: Add optional base argument to math.log(x[, base]). Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	506 If the base not specified, returns the natural logarithm (base e) of x.");
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	507
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	508 static PyObject *
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	509 math_log10(PyObject self, PyObject arg)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	510 {
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	511 return loghelper(arg, log10, "log10");
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	512 }
9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	513
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	514 PyDoc_STRVAR(math_log10_doc,
ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	515 "log10(x) -> the base 10 logarithm of x.");
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	516
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	517 static PyObject *
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	518 math_fmod(PyObject self, PyObject args)
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	519 {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	520 PyObject ox, oy;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	521 double r, x, y;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	522 if (! PyArg_UnpackTuple(args, "fmod", 2, 2, &ox, &oy))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	523 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	524 x = PyFloat_AsDouble(ox);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	525 y = PyFloat_AsDouble(oy);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	526 if ((x == -1.0 \|\| y == -1.0) && PyErr_Occurred())
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	527 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	528 /* fmod(x, +/-Inf) returns x for finite x. */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	529 if (Py_IS_INFINITY(y) && Py_IS_FINITE(x))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	530 return PyFloat_FromDouble(x);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	531 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	532 PyFPE_START_PROTECT("in math_fmod", return 0);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	533 r = fmod(x, y);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	534 PyFPE_END_PROTECT(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	535 if (Py_IS_NAN(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	536 if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	537 errno = EDOM;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	538 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	539 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	540 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	541 if (errno && is_error(r))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	542 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	543 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	544 return PyFloat_FromDouble(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	545 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	546
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	547 PyDoc_STRVAR(math_fmod_doc,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	548 "fmod(x,y)\n\nReturn fmod(x, y), according to platform C."
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	549 " x % y may differ.");
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	550
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	551 static PyObject *
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	552 math_hypot(PyObject self, PyObject args)
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	553 {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	554 PyObject ox, oy;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	555 double r, x, y;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	556 if (! PyArg_UnpackTuple(args, "hypot", 2, 2, &ox, &oy))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	557 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	558 x = PyFloat_AsDouble(ox);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	559 y = PyFloat_AsDouble(oy);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	560 if ((x == -1.0 \|\| y == -1.0) && PyErr_Occurred())
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	561 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	562 /* hypot(x, +/-Inf) returns Inf, even if x is a NaN. */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	563 if (Py_IS_INFINITY(x))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	564 return PyFloat_FromDouble(fabs(x));
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	565 if (Py_IS_INFINITY(y))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	566 return PyFloat_FromDouble(fabs(y));
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	567 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	568 PyFPE_START_PROTECT("in math_hypot", return 0);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	569 r = hypot(x, y);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	570 PyFPE_END_PROTECT(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	571 if (Py_IS_NAN(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	572 if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	573 errno = EDOM;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	574 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	575 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	576 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	577 else if (Py_IS_INFINITY(r)) {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	578 if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	579 errno = ERANGE;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	580 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	581 errno = 0;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	582 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	583 if (errno && is_error(r))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	584 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	585 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	586 return PyFloat_FromDouble(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	587 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	588
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	589 PyDoc_STRVAR(math_hypot_doc,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	590 "hypot(x,y)\n\nReturn the Euclidean distance, sqrt(xx + yy).");
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	591
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	592 /* pow can't use math_2, but needs its own wrapper: the problem is
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	593 that an infinite result can arise either as a result of overflow
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	594 (in which case OverflowError should be raised) or as a result of
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	595 e.g. 0.**-5. (for which ValueError needs to be raised.)
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	596 */
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	597
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	598 static PyObject *
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	599 math_pow(PyObject self, PyObject args)
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	600 {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	601 PyObject ox, oy;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	602 double r, x, y;
46500 a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	603 int odd_y;
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	604
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	605 if (! PyArg_UnpackTuple(args, "pow", 2, 2, &ox, &oy))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	606 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	607 x = PyFloat_AsDouble(ox);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	608 y = PyFloat_AsDouble(oy);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	609 if ((x == -1.0 \|\| y == -1.0) && PyErr_Occurred())
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	610 return NULL;
46490 648b4d01cccf Additional special-case handling for math.pow. Mark Dickinson <dickinsm@gmail.com> parents: 46486 diff changeset	611
46500 a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	612 /* deal directly with IEEE specials, to cope with problems on various
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	613 platforms whose semantics don't exactly match C99 */
46509 052fd8f1ca37 Silence 'r may be used uninitialized' compiler warning. Mark Dickinson <dickinsm@gmail.com> parents: 46507 diff changeset	614 r = 0.; /* silence compiler warning */
46500 a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	615 if (!Py_IS_FINITE(x) \|\| !Py_IS_FINITE(y)) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	616 errno = 0;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	617 if (Py_IS_NAN(x))
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	618 r = y == 0. ? 1. : x; /* NaN*0 = 1 /
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	619 else if (Py_IS_NAN(y))
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	620 r = x == 1. ? 1. : y; /* 1*NaN = 1 /
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	621 else if (Py_IS_INFINITY(x)) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	622 odd_y = Py_IS_FINITE(y) && fmod(fabs(y), 2.0) == 1.0;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	623 if (y > 0.)
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	624 r = odd_y ? x : fabs(x);
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	625 else if (y == 0.)
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	626 r = 1.;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	627 else /* y < 0. */
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	628 r = odd_y ? copysign(0., x) : 0.;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	629 }
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	630 else if (Py_IS_INFINITY(y)) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	631 if (fabs(x) == 1.0)
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	632 r = 1.;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	633 else if (y > 0. && fabs(x) > 1.0)
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	634 r = y;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	635 else if (y < 0. && fabs(x) < 1.0) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	636 r = -y; /* result is +inf */
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	637 if (x == 0.) /* 0*-inf: divide-by-zero /
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	638 errno = EDOM;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	639 }
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	640 else
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	641 r = 0.;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	642 }
46486 82d85a05923b Additional tests for math.pow, and extra special-case Mark Dickinson <dickinsm@gmail.com> parents: 46473 diff changeset	643 }
46500 a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	644 else {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	645 /* let libm handle finite*finite /
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	646 errno = 0;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	647 PyFPE_START_PROTECT("in math_pow", return 0);
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	648 r = pow(x, y);
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	649 PyFPE_END_PROTECT(r);
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	650 /* a NaN result should arise only from (-ve)**(finite
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	651 non-integer); in this case we want to raise ValueError. */
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	652 if (!Py_IS_FINITE(r)) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	653 if (Py_IS_NAN(r)) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	654 errno = EDOM;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	655 }
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	656 /*
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	657 an infinite result here arises either from:
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	658 (A) (+/-0.)**negative (-> divide-by-zero)
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	659 (B) overflow of x**y with x and y finite
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	660 */
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	661 else if (Py_IS_INFINITY(r)) {
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	662 if (x == 0.)
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	663 errno = EDOM;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	664 else
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	665 errno = ERANGE;
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	666 }
a20def0101de Yet more explicit special case handling to make Mark Dickinson <dickinsm@gmail.com> parents: 46499 diff changeset	667 }
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	668 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	669
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	670 if (errno && is_error(r))
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	671 return NULL;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	672 else
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	673 return PyFloat_FromDouble(r);
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	674 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	675
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	676 PyDoc_STRVAR(math_pow_doc,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	677 "pow(x,y)\n\nReturn x**y (x to the power of y).");
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	678
44437 968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	679 static const double degToRad = Py_MATH_PI / 180.0;
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	680 static const double radToDeg = 180.0 / Py_MATH_PI;
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	681
a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	682 static PyObject *
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	683 math_degrees(PyObject self, PyObject arg)
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	684 {
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	685 double x = PyFloat_AsDouble(arg);
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	686 if (x == -1.0 && PyErr_Occurred())
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	687 return NULL;
44437 968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	688 return PyFloat_FromDouble(x * radToDeg);
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	689 }
a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	690
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	691 PyDoc_STRVAR(math_degrees_doc,
ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	692 "degrees(x) -> converts angle x from radians to degrees");
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	693
a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	694 static PyObject *
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	695 math_radians(PyObject self, PyObject arg)
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	696 {
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	697 double x = PyFloat_AsDouble(arg);
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	698 if (x == -1.0 && PyErr_Occurred())
23427 a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	699 return NULL;
a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	700 return PyFloat_FromDouble(x * degToRad);
a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	701 }
a4d675b8b53c Added degrees() and radians() to mathmodule. Closes patch 552452 and Raymond Hettinger <python@rcn.com> parents: 19758 diff changeset	702
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	703 PyDoc_STRVAR(math_radians_doc,
ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	704 "radians(x) -> converts angle x from degrees to radians");
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19712 diff changeset	705
44437 968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	706 static PyObject *
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	707 math_isnan(PyObject self, PyObject arg)
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	708 {
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	709 double x = PyFloat_AsDouble(arg);
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	710 if (x == -1.0 && PyErr_Occurred())
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	711 return NULL;
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	712 return PyBool_FromLong((long)Py_IS_NAN(x));
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	713 }
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	714
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	715 PyDoc_STRVAR(math_isnan_doc,
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	716 "isnan(x) -> bool\n\
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	717 Checks if float x is not a number (NaN)");
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	718
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	719 static PyObject *
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	720 math_isinf(PyObject self, PyObject arg)
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	721 {
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	722 double x = PyFloat_AsDouble(arg);
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	723 if (x == -1.0 && PyErr_Occurred())
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	724 return NULL;
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	725 return PyBool_FromLong((long)Py_IS_INFINITY(x));
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	726 }
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	727
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	728 PyDoc_STRVAR(math_isinf_doc,
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	729 "isinf(x) -> bool\n\
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	730 Checks if float x is infinite (positive or negative)");
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	731
4635 49745ddb4f69 Renamed Barry Warsaw <barry@python.org> parents: 4503 diff changeset	732 static PyMethodDef math_methods[] = {
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	733 {"acos", math_acos, METH_O, math_acos_doc},
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	734 {"acosh", math_acosh, METH_O, math_acosh_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	735 {"asin", math_asin, METH_O, math_asin_doc},
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	736 {"asinh", math_asinh, METH_O, math_asinh_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	737 {"atan", math_atan, METH_O, math_atan_doc},
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	738 {"atan2", math_atan2, METH_VARARGS, math_atan2_doc},
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	739 {"atanh", math_atanh, METH_O, math_atanh_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	740 {"ceil", math_ceil, METH_O, math_ceil_doc},
44440 6208b17d0dbe Added copysign(x, y) function to the math module Christian Heimes <christian@cheimes.de> parents: 44437 diff changeset	741 {"copysign", math_copysign, METH_VARARGS, math_copysign_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	742 {"cos", math_cos, METH_O, math_cos_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	743 {"cosh", math_cosh, METH_O, math_cosh_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	744 {"degrees", math_degrees, METH_O, math_degrees_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	745 {"exp", math_exp, METH_O, math_exp_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	746 {"fabs", math_fabs, METH_O, math_fabs_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	747 {"floor", math_floor, METH_O, math_floor_doc},
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	748 {"fmod", math_fmod, METH_VARARGS, math_fmod_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	749 {"frexp", math_frexp, METH_O, math_frexp_doc},
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	750 {"hypot", math_hypot, METH_VARARGS, math_hypot_doc},
44437 968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	751 {"isinf", math_isinf, METH_O, math_isinf_doc},
968bda81e6c8 Added math.isinf() and math.isnan() Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	752 {"isnan", math_isnan, METH_O, math_isnan_doc},
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	753 {"ldexp", math_ldexp, METH_VARARGS, math_ldexp_doc},
24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	754 {"log", math_log, METH_VARARGS, math_log_doc},
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	755 {"log1p", math_log1p, METH_O, math_log1p_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	756 {"log10", math_log10, METH_O, math_log10_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	757 {"modf", math_modf, METH_O, math_modf_doc},
13326 24717405dd89 ANSI-fication, remove Py_PROTO, etc. Fred Drake <fdrake@acm.org> parents: 13309 diff changeset	758 {"pow", math_pow, METH_VARARGS, math_pow_doc},
40362 271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	759 {"radians", math_radians, METH_O, math_radians_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	760 {"sin", math_sin, METH_O, math_sin_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	761 {"sinh", math_sinh, METH_O, math_sinh_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	762 {"sqrt", math_sqrt, METH_O, math_sqrt_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	763 {"tan", math_tan, METH_O, math_tan_doc},
271133981e63 Speed up function calls into the math module by using METH_O. Neal Norwitz <nnorwitz@gmail.com> parents: 38491 diff changeset	764 {"tanh", math_tanh, METH_O, math_tanh_doc},
45079 492b302aded6 Move __builtins__.trunc() to math.trunc() per Jeffrey Yasskin <jyasskin@gmail.com> parents: 44947 diff changeset	765 {"trunc", math_trunc, METH_O, math_trunc_doc},
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	766 {NULL, NULL} /* sentinel */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	767 };
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	768
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	769
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	770 PyDoc_STRVAR(module_doc,
19712 b4521436e8f8 Mechanical fiddling to make this easier to work with in my editor. Tim Peters <tim.peters@gmail.com> parents: 19048 diff changeset	771 "This module is always available. It provides access to the\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23427 diff changeset	772 "mathematical functions defined by the C standard.");
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	773
24471 f66b3a3509c7 Excise DL_EXPORT/DL_IMPORT from Modules/. Required adding a prototype Mark Hammond <mhammond@skippinet.com.au>* parents: 23832 diff changeset	774 PyMODINIT_FUNC
13651 8a063423e0b7 Bunch of minor ANSIfications: 'void initfunc()' -> 'void initfunc(void)', Thomas Wouters <thomas@python.org> parents: 13331 diff changeset	775 initmath(void)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	776 {
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	777 PyObject *m;
19048 e282d6b2b758 Part of SF patch [#431848] mathmodule.c: doc strings & conversion, from Tim Peters <tim.peters@gmail.com> parents: 18066 diff changeset	778
9593 f22f769bf3d9 Added Doc strings -- by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 9588 diff changeset	779 m = Py_InitModule3("math", math_methods, module_doc);
36324 1af7f719ed28 Check return result from Py_InitModule(). This API can fail. Neal Norwitz <nnorwitz@gmail.com>* parents: 34872 diff changeset	780 if (m == NULL)
1af7f719ed28 Check return result from Py_InitModule(). This API can fail. Neal Norwitz <nnorwitz@gmail.com>* parents: 34872 diff changeset	781 goto finally;
4752 7367fb107108 Better error checking in initmath(). Barry Warsaw <barry@python.org> parents: 4635 diff changeset	782
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	783 PyModule_AddObject(m, "pi", PyFloat_FromDouble(Py_MATH_PI));
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	784 PyModule_AddObject(m, "e", PyFloat_FromDouble(Py_MATH_E));
4752 7367fb107108 Better error checking in initmath(). Barry Warsaw <barry@python.org> parents: 4635 diff changeset	785
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 45102 diff changeset	786 finally:
14346 5397fdf88ec2 Do the absolute minimal amount of modifications to eradicate Barry Warsaw <barry@python.org> parents: 13912 diff changeset	787 return;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	788 }

Mercurial > cpython-lru_cache-weakref

annotate Modules/mathmodule.c @ 47192:32bd18709dfd legacy-trunk