From fc4d0a382ea5126521b206f33d69fd243f110f6f Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Thu, 19 Jan 2017 18:13:09 +0200
Subject: Issue #20186: Converted the math module to Argument Clinic. Patch by
 Tal Einat.

---
 Modules/clinic/mathmodule.c.h | 539 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 539 insertions(+)
 create mode 100644 Modules/clinic/mathmodule.c.h

(limited to 'Modules/clinic/mathmodule.c.h')

diff --git a/Modules/clinic/mathmodule.c.h b/Modules/clinic/mathmodule.c.h
new file mode 100644
index 0000000000..84a7a70cdc
--- /dev/null
+++ b/Modules/clinic/mathmodule.c.h
@@ -0,0 +1,539 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(math_gcd__doc__,
+"gcd($module, x, y, /)\n"
+"--\n"
+"\n"
+"greatest common divisor of x and y");
+
+#define MATH_GCD_METHODDEF    \
+    {"gcd", (PyCFunction)math_gcd, METH_FASTCALL, math_gcd__doc__},
+
+static PyObject *
+math_gcd_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+math_gcd(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!_PyArg_UnpackStack(args, nargs, "gcd",
+        2, 2,
+        &a, &b)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("gcd", kwnames)) {
+        goto exit;
+    }
+    return_value = math_gcd_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_ceil__doc__,
+"ceil($module, x, /)\n"
+"--\n"
+"\n"
+"Return the ceiling of x as an Integral.\n"
+"\n"
+"This is the smallest integer >= x.");
+
+#define MATH_CEIL_METHODDEF    \
+    {"ceil", (PyCFunction)math_ceil, METH_O, math_ceil__doc__},
+
+PyDoc_STRVAR(math_floor__doc__,
+"floor($module, x, /)\n"
+"--\n"
+"\n"
+"Return the floor of x as an Integral.\n"
+"\n"
+"This is the largest integer <= x.");
+
+#define MATH_FLOOR_METHODDEF    \
+    {"floor", (PyCFunction)math_floor, METH_O, math_floor__doc__},
+
+PyDoc_STRVAR(math_fsum__doc__,
+"fsum($module, seq, /)\n"
+"--\n"
+"\n"
+"Return an accurate floating point sum of values in the iterable seq.\n"
+"\n"
+"Assumes IEEE-754 floating point arithmetic.");
+
+#define MATH_FSUM_METHODDEF    \
+    {"fsum", (PyCFunction)math_fsum, METH_O, math_fsum__doc__},
+
+PyDoc_STRVAR(math_factorial__doc__,
+"factorial($module, x, /)\n"
+"--\n"
+"\n"
+"Find x!.\n"
+"\n"
+"Raise a ValueError if x is negative or non-integral.");
+
+#define MATH_FACTORIAL_METHODDEF    \
+    {"factorial", (PyCFunction)math_factorial, METH_O, math_factorial__doc__},
+
+PyDoc_STRVAR(math_trunc__doc__,
+"trunc($module, x, /)\n"
+"--\n"
+"\n"
+"Truncates the Real x to the nearest Integral toward 0.\n"
+"\n"
+"Uses the __trunc__ magic method.");
+
+#define MATH_TRUNC_METHODDEF    \
+    {"trunc", (PyCFunction)math_trunc, METH_O, math_trunc__doc__},
+
+PyDoc_STRVAR(math_frexp__doc__,
+"frexp($module, x, /)\n"
+"--\n"
+"\n"
+"Return the mantissa and exponent of x, as pair (m, e).\n"
+"\n"
+"m is a float and e is an int, such that x = m * 2.**e.\n"
+"If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.");
+
+#define MATH_FREXP_METHODDEF    \
+    {"frexp", (PyCFunction)math_frexp, METH_O, math_frexp__doc__},
+
+static PyObject *
+math_frexp_impl(PyObject *module, double x);
+
+static PyObject *
+math_frexp(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:frexp", &x)) {
+        goto exit;
+    }
+    return_value = math_frexp_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_ldexp__doc__,
+"ldexp($module, x, i, /)\n"
+"--\n"
+"\n"
+"Return x * (2**i).\n"
+"\n"
+"This is essentially the inverse of frexp().");
+
+#define MATH_LDEXP_METHODDEF    \
+    {"ldexp", (PyCFunction)math_ldexp, METH_FASTCALL, math_ldexp__doc__},
+
+static PyObject *
+math_ldexp_impl(PyObject *module, double x, PyObject *i);
+
+static PyObject *
+math_ldexp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    double x;
+    PyObject *i;
+
+    if (!_PyArg_ParseStack(args, nargs, "dO:ldexp",
+        &x, &i)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("ldexp", kwnames)) {
+        goto exit;
+    }
+    return_value = math_ldexp_impl(module, x, i);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_modf__doc__,
+"modf($module, x, /)\n"
+"--\n"
+"\n"
+"Return the fractional and integer parts of x.\n"
+"\n"
+"Both results carry the sign of x and are floats.");
+
+#define MATH_MODF_METHODDEF    \
+    {"modf", (PyCFunction)math_modf, METH_O, math_modf__doc__},
+
+static PyObject *
+math_modf_impl(PyObject *module, double x);
+
+static PyObject *
+math_modf(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:modf", &x)) {
+        goto exit;
+    }
+    return_value = math_modf_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_log__doc__,
+"log(x, [base=math.e])\n"
+"Return the logarithm of x to the given base.\n"
+"\n"
+"If the base not specified, returns the natural logarithm (base e) of x.");
+
+#define MATH_LOG_METHODDEF    \
+    {"log", (PyCFunction)math_log, METH_VARARGS, math_log__doc__},
+
+static PyObject *
+math_log_impl(PyObject *module, PyObject *x, int group_right_1,
+              PyObject *base);
+
+static PyObject *
+math_log(PyObject *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *x;
+    int group_right_1 = 0;
+    PyObject *base = NULL;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O:log", &x)) {
+                goto exit;
+            }
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "OO:log", &x, &base)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "math.log requires 1 to 2 arguments");
+            goto exit;
+    }
+    return_value = math_log_impl(module, x, group_right_1, base);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_log2__doc__,
+"log2($module, x, /)\n"
+"--\n"
+"\n"
+"Return the base 2 logarithm of x.");
+
+#define MATH_LOG2_METHODDEF    \
+    {"log2", (PyCFunction)math_log2, METH_O, math_log2__doc__},
+
+PyDoc_STRVAR(math_log10__doc__,
+"log10($module, x, /)\n"
+"--\n"
+"\n"
+"Return the base 10 logarithm of x.");
+
+#define MATH_LOG10_METHODDEF    \
+    {"log10", (PyCFunction)math_log10, METH_O, math_log10__doc__},
+
+PyDoc_STRVAR(math_fmod__doc__,
+"fmod($module, x, y, /)\n"
+"--\n"
+"\n"
+"Return fmod(x, y), according to platform C.\n"
+"\n"
+"x % y may differ.");
+
+#define MATH_FMOD_METHODDEF    \
+    {"fmod", (PyCFunction)math_fmod, METH_FASTCALL, math_fmod__doc__},
+
+static PyObject *
+math_fmod_impl(PyObject *module, double x, double y);
+
+static PyObject *
+math_fmod(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    double x;
+    double y;
+
+    if (!_PyArg_ParseStack(args, nargs, "dd:fmod",
+        &x, &y)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("fmod", kwnames)) {
+        goto exit;
+    }
+    return_value = math_fmod_impl(module, x, y);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_hypot__doc__,
+"hypot($module, x, y, /)\n"
+"--\n"
+"\n"
+"Return the Euclidean distance, sqrt(x*x + y*y).");
+
+#define MATH_HYPOT_METHODDEF    \
+    {"hypot", (PyCFunction)math_hypot, METH_FASTCALL, math_hypot__doc__},
+
+static PyObject *
+math_hypot_impl(PyObject *module, double x, double y);
+
+static PyObject *
+math_hypot(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    double x;
+    double y;
+
+    if (!_PyArg_ParseStack(args, nargs, "dd:hypot",
+        &x, &y)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("hypot", kwnames)) {
+        goto exit;
+    }
+    return_value = math_hypot_impl(module, x, y);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_pow__doc__,
+"pow($module, x, y, /)\n"
+"--\n"
+"\n"
+"Return x**y (x to the power of y).");
+
+#define MATH_POW_METHODDEF    \
+    {"pow", (PyCFunction)math_pow, METH_FASTCALL, math_pow__doc__},
+
+static PyObject *
+math_pow_impl(PyObject *module, double x, double y);
+
+static PyObject *
+math_pow(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    double x;
+    double y;
+
+    if (!_PyArg_ParseStack(args, nargs, "dd:pow",
+        &x, &y)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("pow", kwnames)) {
+        goto exit;
+    }
+    return_value = math_pow_impl(module, x, y);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_degrees__doc__,
+"degrees($module, x, /)\n"
+"--\n"
+"\n"
+"Convert angle x from radians to degrees.");
+
+#define MATH_DEGREES_METHODDEF    \
+    {"degrees", (PyCFunction)math_degrees, METH_O, math_degrees__doc__},
+
+static PyObject *
+math_degrees_impl(PyObject *module, double x);
+
+static PyObject *
+math_degrees(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:degrees", &x)) {
+        goto exit;
+    }
+    return_value = math_degrees_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_radians__doc__,
+"radians($module, x, /)\n"
+"--\n"
+"\n"
+"Convert angle x from degrees to radians.");
+
+#define MATH_RADIANS_METHODDEF    \
+    {"radians", (PyCFunction)math_radians, METH_O, math_radians__doc__},
+
+static PyObject *
+math_radians_impl(PyObject *module, double x);
+
+static PyObject *
+math_radians(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:radians", &x)) {
+        goto exit;
+    }
+    return_value = math_radians_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_isfinite__doc__,
+"isfinite($module, x, /)\n"
+"--\n"
+"\n"
+"Return True if x is neither an infinity nor a NaN, and False otherwise.");
+
+#define MATH_ISFINITE_METHODDEF    \
+    {"isfinite", (PyCFunction)math_isfinite, METH_O, math_isfinite__doc__},
+
+static PyObject *
+math_isfinite_impl(PyObject *module, double x);
+
+static PyObject *
+math_isfinite(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:isfinite", &x)) {
+        goto exit;
+    }
+    return_value = math_isfinite_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_isnan__doc__,
+"isnan($module, x, /)\n"
+"--\n"
+"\n"
+"Return True if x is a NaN (not a number), and False otherwise.");
+
+#define MATH_ISNAN_METHODDEF    \
+    {"isnan", (PyCFunction)math_isnan, METH_O, math_isnan__doc__},
+
+static PyObject *
+math_isnan_impl(PyObject *module, double x);
+
+static PyObject *
+math_isnan(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:isnan", &x)) {
+        goto exit;
+    }
+    return_value = math_isnan_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_isinf__doc__,
+"isinf($module, x, /)\n"
+"--\n"
+"\n"
+"Return True if x is a positive or negative infinity, and False otherwise.");
+
+#define MATH_ISINF_METHODDEF    \
+    {"isinf", (PyCFunction)math_isinf, METH_O, math_isinf__doc__},
+
+static PyObject *
+math_isinf_impl(PyObject *module, double x);
+
+static PyObject *
+math_isinf(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double x;
+
+    if (!PyArg_Parse(arg, "d:isinf", &x)) {
+        goto exit;
+    }
+    return_value = math_isinf_impl(module, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(math_isclose__doc__,
+"isclose($module, /, a, b, *, rel_tol=1e-09, abs_tol=0.0)\n"
+"--\n"
+"\n"
+"Determine whether two floating point numbers are close in value.\n"
+"\n"
+"  rel_tol\n"
+"    maximum difference for being considered \"close\", relative to the\n"
+"    magnitude of the input values\n"
+"  abs_tol\n"
+"    maximum difference for being considered \"close\", regardless of the\n"
+"    magnitude of the input values\n"
+"\n"
+"Return True if a is close in value to b, and False otherwise.\n"
+"\n"
+"For the values to be considered close, the difference between them\n"
+"must be smaller than at least one of the tolerances.\n"
+"\n"
+"-inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n"
+"is, NaN is not close to anything, even itself.  inf and -inf are\n"
+"only close to themselves.");
+
+#define MATH_ISCLOSE_METHODDEF    \
+    {"isclose", (PyCFunction)math_isclose, METH_FASTCALL, math_isclose__doc__},
+
+static int
+math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
+                  double abs_tol);
+
+static PyObject *
+math_isclose(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    static const char * const _keywords[] = {"a", "b", "rel_tol", "abs_tol", NULL};
+    static _PyArg_Parser _parser = {"dd|$dd:isclose", _keywords, 0};
+    double a;
+    double b;
+    double rel_tol = 1e-09;
+    double abs_tol = 0.0;
+    int _return_value;
+
+    if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
+        &a, &b, &rel_tol, &abs_tol)) {
+        goto exit;
+    }
+    _return_value = math_isclose_impl(module, a, b, rel_tol, abs_tol);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=71806f73a5c4bf0b input=a9049054013a1b77]*/
-- 
cgit v1.2.1


From 06a1969f0c560934f61b1df1798e9aab89b19702 Mon Sep 17 00:00:00 2001
From: Mark Dickinson <dickinsm@gmail.com>
Date: Sat, 21 Jan 2017 12:35:30 +0000
Subject: Issue #29282: add fused multiply-add function, math.fma.

---
 Modules/clinic/mathmodule.c.h | 36 +++++++++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

(limited to 'Modules/clinic/mathmodule.c.h')

diff --git a/Modules/clinic/mathmodule.c.h b/Modules/clinic/mathmodule.c.h
index 84a7a70cdc..4e9fe20cf5 100644
--- a/Modules/clinic/mathmodule.c.h
+++ b/Modules/clinic/mathmodule.c.h
@@ -80,6 +80,40 @@ PyDoc_STRVAR(math_factorial__doc__,
 #define MATH_FACTORIAL_METHODDEF    \
     {"factorial", (PyCFunction)math_factorial, METH_O, math_factorial__doc__},
 
+PyDoc_STRVAR(math_fma__doc__,
+"fma($module, x, y, z, /)\n"
+"--\n"
+"\n"
+"Fused multiply-add operation. Compute (x * y) + z with a single round.");
+
+#define MATH_FMA_METHODDEF    \
+    {"fma", (PyCFunction)math_fma, METH_FASTCALL, math_fma__doc__},
+
+static PyObject *
+math_fma_impl(PyObject *module, double x, double y, double z);
+
+static PyObject *
+math_fma(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    double x;
+    double y;
+    double z;
+
+    if (!_PyArg_ParseStack(args, nargs, "ddd:fma",
+        &x, &y, &z)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("fma", kwnames)) {
+        goto exit;
+    }
+    return_value = math_fma_impl(module, x, y, z);
+
+exit:
+    return return_value;
+}
+
 PyDoc_STRVAR(math_trunc__doc__,
 "trunc($module, x, /)\n"
 "--\n"
@@ -536,4 +570,4 @@ math_isclose(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=71806f73a5c4bf0b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=f428e1075d00c334 input=a9049054013a1b77]*/
-- 
cgit v1.2.1


From 15a9df1f32c007a211dc165b26c189153feec4ca Mon Sep 17 00:00:00 2001
From: Mark Dickinson <dickinsm@gmail.com>
Date: Sat, 21 Jan 2017 13:10:52 +0000
Subject: Issue #29282: Backed out changeset b33012ef1417

---
 Modules/clinic/mathmodule.c.h | 36 +-----------------------------------
 1 file changed, 1 insertion(+), 35 deletions(-)

(limited to 'Modules/clinic/mathmodule.c.h')

diff --git a/Modules/clinic/mathmodule.c.h b/Modules/clinic/mathmodule.c.h
index 4e9fe20cf5..84a7a70cdc 100644
--- a/Modules/clinic/mathmodule.c.h
+++ b/Modules/clinic/mathmodule.c.h
@@ -80,40 +80,6 @@ PyDoc_STRVAR(math_factorial__doc__,
 #define MATH_FACTORIAL_METHODDEF    \
     {"factorial", (PyCFunction)math_factorial, METH_O, math_factorial__doc__},
 
-PyDoc_STRVAR(math_fma__doc__,
-"fma($module, x, y, z, /)\n"
-"--\n"
-"\n"
-"Fused multiply-add operation. Compute (x * y) + z with a single round.");
-
-#define MATH_FMA_METHODDEF    \
-    {"fma", (PyCFunction)math_fma, METH_FASTCALL, math_fma__doc__},
-
-static PyObject *
-math_fma_impl(PyObject *module, double x, double y, double z);
-
-static PyObject *
-math_fma(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    PyObject *return_value = NULL;
-    double x;
-    double y;
-    double z;
-
-    if (!_PyArg_ParseStack(args, nargs, "ddd:fma",
-        &x, &y, &z)) {
-        goto exit;
-    }
-
-    if (!_PyArg_NoStackKeywords("fma", kwnames)) {
-        goto exit;
-    }
-    return_value = math_fma_impl(module, x, y, z);
-
-exit:
-    return return_value;
-}
-
 PyDoc_STRVAR(math_trunc__doc__,
 "trunc($module, x, /)\n"
 "--\n"
@@ -570,4 +536,4 @@ math_isclose(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=f428e1075d00c334 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=71806f73a5c4bf0b input=a9049054013a1b77]*/
-- 
cgit v1.2.1