LCOV - code coverage report
Current view: | top level - Modules/clinic - mathmodule.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 220 | 262 | 84.0 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 19 | 19 | 100.0 %
|  |  | Branches: | 118 | 211 | 55.9 %

               Branch data     Line data    Source code
           1                 :            : /*[clinic input]
           2                 :            : preserve
           3                 :            : [clinic start generated code]*/
           4                 :            :
           5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
           6                 :            : #  include "pycore_gc.h"            // PyGC_Head
           7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
           8                 :            : #endif
           9                 :            :
          10                 :            :
          11                 :            : PyDoc_STRVAR(math_ceil__doc__,
          12                 :            : "ceil($module, x, /)\n"
          13                 :            : "--\n"
          14                 :            : "\n"
          15                 :            : "Return the ceiling of x as an Integral.\n"
          16                 :            : "\n"
          17                 :            : "This is the smallest integer >= x.");
          18                 :            :
          19                 :            : #define MATH_CEIL_METHODDEF    \
          20                 :            :     {"ceil", (PyCFunction)math_ceil, METH_O, math_ceil__doc__},
          21                 :            :
          22                 :            : PyDoc_STRVAR(math_floor__doc__,
          23                 :            : "floor($module, x, /)\n"
          24                 :            : "--\n"
          25                 :            : "\n"
          26                 :            : "Return the floor of x as an Integral.\n"
          27                 :            : "\n"
          28                 :            : "This is the largest integer <= x.");
          29                 :            :
          30                 :            : #define MATH_FLOOR_METHODDEF    \
          31                 :            :     {"floor", (PyCFunction)math_floor, METH_O, math_floor__doc__},
          32                 :            :
          33                 :            : PyDoc_STRVAR(math_fsum__doc__,
          34                 :            : "fsum($module, seq, /)\n"
          35                 :            : "--\n"
          36                 :            : "\n"
          37                 :            : "Return an accurate floating point sum of values in the iterable seq.\n"
          38                 :            : "\n"
          39                 :            : "Assumes IEEE-754 floating point arithmetic.");
          40                 :            :
          41                 :            : #define MATH_FSUM_METHODDEF    \
          42                 :            :     {"fsum", (PyCFunction)math_fsum, METH_O, math_fsum__doc__},
          43                 :            :
          44                 :            : PyDoc_STRVAR(math_isqrt__doc__,
          45                 :            : "isqrt($module, n, /)\n"
          46                 :            : "--\n"
          47                 :            : "\n"
          48                 :            : "Return the integer part of the square root of the input.");
          49                 :            :
          50                 :            : #define MATH_ISQRT_METHODDEF    \
          51                 :            :     {"isqrt", (PyCFunction)math_isqrt, METH_O, math_isqrt__doc__},
          52                 :            :
          53                 :            : PyDoc_STRVAR(math_factorial__doc__,
          54                 :            : "factorial($module, n, /)\n"
          55                 :            : "--\n"
          56                 :            : "\n"
          57                 :            : "Find n!.\n"
          58                 :            : "\n"
          59                 :            : "Raise a ValueError if x is negative or non-integral.");
          60                 :            :
          61                 :            : #define MATH_FACTORIAL_METHODDEF    \
          62                 :            :     {"factorial", (PyCFunction)math_factorial, METH_O, math_factorial__doc__},
          63                 :            :
          64                 :            : PyDoc_STRVAR(math_trunc__doc__,
          65                 :            : "trunc($module, x, /)\n"
          66                 :            : "--\n"
          67                 :            : "\n"
          68                 :            : "Truncates the Real x to the nearest Integral toward 0.\n"
          69                 :            : "\n"
          70                 :            : "Uses the __trunc__ magic method.");
          71                 :            :
          72                 :            : #define MATH_TRUNC_METHODDEF    \
          73                 :            :     {"trunc", (PyCFunction)math_trunc, METH_O, math_trunc__doc__},
          74                 :            :
          75                 :            : PyDoc_STRVAR(math_frexp__doc__,
          76                 :            : "frexp($module, x, /)\n"
          77                 :            : "--\n"
          78                 :            : "\n"
          79                 :            : "Return the mantissa and exponent of x, as pair (m, e).\n"
          80                 :            : "\n"
          81                 :            : "m is a float and e is an int, such that x = m * 2.**e.\n"
          82                 :            : "If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.");
          83                 :            :
          84                 :            : #define MATH_FREXP_METHODDEF    \
          85                 :            :     {"frexp", (PyCFunction)math_frexp, METH_O, math_frexp__doc__},
          86                 :            :
          87                 :            : static PyObject *
          88                 :            : math_frexp_impl(PyObject *module, double x);
          89                 :            :
          90                 :            : static PyObject *
          91                 :     520007 : math_frexp(PyObject *module, PyObject *arg)
          92                 :            : {
          93                 :     520007 :     PyObject *return_value = NULL;
          94                 :            :     double x;
          95                 :            :
          96         [ +  + ]:     520007 :     if (PyFloat_CheckExact(arg)) {
          97                 :     480003 :         x = PyFloat_AS_DOUBLE(arg);
          98                 :            :     }
          99                 :            :     else
         100                 :            :     {
         101                 :      40004 :         x = PyFloat_AsDouble(arg);
         102   [ +  +  -  + ]:      40004 :         if (x == -1.0 && PyErr_Occurred()) {
         103                 :          0 :             goto exit;
         104                 :            :         }
         105                 :            :     }
         106                 :     520007 :     return_value = math_frexp_impl(module, x);
         107                 :            :
         108                 :     520007 : exit:
         109                 :     520007 :     return return_value;
         110                 :            : }
         111                 :            :
         112                 :            : PyDoc_STRVAR(math_ldexp__doc__,
         113                 :            : "ldexp($module, x, i, /)\n"
         114                 :            : "--\n"
         115                 :            : "\n"
         116                 :            : "Return x * (2**i).\n"
         117                 :            : "\n"
         118                 :            : "This is essentially the inverse of frexp().");
         119                 :            :
         120                 :            : #define MATH_LDEXP_METHODDEF    \
         121                 :            :     {"ldexp", _PyCFunction_CAST(math_ldexp), METH_FASTCALL, math_ldexp__doc__},
         122                 :            :
         123                 :            : static PyObject *
         124                 :            : math_ldexp_impl(PyObject *module, double x, PyObject *i);
         125                 :            :
         126                 :            : static PyObject *
         127                 :     524166 : math_ldexp(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         128                 :            : {
         129                 :     524166 :     PyObject *return_value = NULL;
         130                 :            :     double x;
         131                 :            :     PyObject *i;
         132                 :            :
         133   [ +  +  -  +  :     524166 :     if (!_PyArg_CheckPositional("ldexp", nargs, 2, 2)) {
                       +  - ]
         134                 :          1 :         goto exit;
         135                 :            :     }
         136         [ +  + ]:     524165 :     if (PyFloat_CheckExact(args[0])) {
         137                 :     522161 :         x = PyFloat_AS_DOUBLE(args[0]);
         138                 :            :     }
         139                 :            :     else
         140                 :            :     {
         141                 :       2004 :         x = PyFloat_AsDouble(args[0]);
         142   [ +  +  -  + ]:       2004 :         if (x == -1.0 && PyErr_Occurred()) {
         143                 :          0 :             goto exit;
         144                 :            :         }
         145                 :            :     }
         146                 :     524165 :     i = args[1];
         147                 :     524165 :     return_value = math_ldexp_impl(module, x, i);
         148                 :            :
         149                 :     524166 : exit:
         150                 :     524166 :     return return_value;
         151                 :            : }
         152                 :            :
         153                 :            : PyDoc_STRVAR(math_modf__doc__,
         154                 :            : "modf($module, x, /)\n"
         155                 :            : "--\n"
         156                 :            : "\n"
         157                 :            : "Return the fractional and integer parts of x.\n"
         158                 :            : "\n"
         159                 :            : "Both results carry the sign of x and are floats.");
         160                 :            :
         161                 :            : #define MATH_MODF_METHODDEF    \
         162                 :            :     {"modf", (PyCFunction)math_modf, METH_O, math_modf__doc__},
         163                 :            :
         164                 :            : static PyObject *
         165                 :            : math_modf_impl(PyObject *module, double x);
         166                 :            :
         167                 :            : static PyObject *
         168                 :          5 : math_modf(PyObject *module, PyObject *arg)
         169                 :            : {
         170                 :          5 :     PyObject *return_value = NULL;
         171                 :            :     double x;
         172                 :            :
         173         [ +  - ]:          5 :     if (PyFloat_CheckExact(arg)) {
         174                 :          5 :         x = PyFloat_AS_DOUBLE(arg);
         175                 :            :     }
         176                 :            :     else
         177                 :            :     {
         178                 :          0 :         x = PyFloat_AsDouble(arg);
         179   [ #  #  #  # ]:          0 :         if (x == -1.0 && PyErr_Occurred()) {
         180                 :          0 :             goto exit;
         181                 :            :         }
         182                 :            :     }
         183                 :          5 :     return_value = math_modf_impl(module, x);
         184                 :            :
         185                 :          5 : exit:
         186                 :          5 :     return return_value;
         187                 :            : }
         188                 :            :
         189                 :            : PyDoc_STRVAR(math_log__doc__,
         190                 :            : "log(x, [base=math.e])\n"
         191                 :            : "Return the logarithm of x to the given base.\n"
         192                 :            : "\n"
         193                 :            : "If the base not specified, returns the natural logarithm (base e) of x.");
         194                 :            :
         195                 :            : #define MATH_LOG_METHODDEF    \
         196                 :            :     {"log", (PyCFunction)math_log, METH_VARARGS, math_log__doc__},
         197                 :            :
         198                 :            : static PyObject *
         199                 :            : math_log_impl(PyObject *module, PyObject *x, int group_right_1,
         200                 :            :               PyObject *base);
         201                 :            :
         202                 :            : static PyObject *
         203                 :     100054 : math_log(PyObject *module, PyObject *args)
         204                 :            : {
         205                 :     100054 :     PyObject *return_value = NULL;
         206                 :            :     PyObject *x;
         207                 :     100054 :     int group_right_1 = 0;
         208                 :     100054 :     PyObject *base = NULL;
         209                 :            :
         210      [ +  +  + ]:     100054 :     switch (PyTuple_GET_SIZE(args)) {
         211                 :     100050 :         case 1:
         212         [ -  + ]:     100050 :             if (!PyArg_ParseTuple(args, "O:log", &x)) {
         213                 :          0 :                 goto exit;
         214                 :            :             }
         215                 :     100050 :             break;
         216                 :          3 :         case 2:
         217         [ -  + ]:          3 :             if (!PyArg_ParseTuple(args, "OO:log", &x, &base)) {
         218                 :          0 :                 goto exit;
         219                 :            :             }
         220                 :          3 :             group_right_1 = 1;
         221                 :          3 :             break;
         222                 :          1 :         default:
         223                 :          1 :             PyErr_SetString(PyExc_TypeError, "math.log requires 1 to 2 arguments");
         224                 :          1 :             goto exit;
         225                 :            :     }
         226                 :     100053 :     return_value = math_log_impl(module, x, group_right_1, base);
         227                 :            :
         228                 :     100054 : exit:
         229                 :     100054 :     return return_value;
         230                 :            : }
         231                 :            :
         232                 :            : PyDoc_STRVAR(math_log2__doc__,
         233                 :            : "log2($module, x, /)\n"
         234                 :            : "--\n"
         235                 :            : "\n"
         236                 :            : "Return the base 2 logarithm of x.");
         237                 :            :
         238                 :            : #define MATH_LOG2_METHODDEF    \
         239                 :            :     {"log2", (PyCFunction)math_log2, METH_O, math_log2__doc__},
         240                 :            :
         241                 :            : PyDoc_STRVAR(math_log10__doc__,
         242                 :            : "log10($module, x, /)\n"
         243                 :            : "--\n"
         244                 :            : "\n"
         245                 :            : "Return the base 10 logarithm of x.");
         246                 :            :
         247                 :            : #define MATH_LOG10_METHODDEF    \
         248                 :            :     {"log10", (PyCFunction)math_log10, METH_O, math_log10__doc__},
         249                 :            :
         250                 :            : PyDoc_STRVAR(math_fmod__doc__,
         251                 :            : "fmod($module, x, y, /)\n"
         252                 :            : "--\n"
         253                 :            : "\n"
         254                 :            : "Return fmod(x, y), according to platform C.\n"
         255                 :            : "\n"
         256                 :            : "x % y may differ.");
         257                 :            :
         258                 :            : #define MATH_FMOD_METHODDEF    \
         259                 :            :     {"fmod", _PyCFunction_CAST(math_fmod), METH_FASTCALL, math_fmod__doc__},
         260                 :            :
         261                 :            : static PyObject *
         262                 :            : math_fmod_impl(PyObject *module, double x, double y);
         263                 :            :
         264                 :            : static PyObject *
         265                 :         20 : math_fmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         266                 :            : {
         267                 :         20 :     PyObject *return_value = NULL;
         268                 :            :     double x;
         269                 :            :     double y;
         270                 :            :
         271   [ +  +  -  +  :         20 :     if (!_PyArg_CheckPositional("fmod", nargs, 2, 2)) {
                       +  - ]
         272                 :          1 :         goto exit;
         273                 :            :     }
         274         [ +  + ]:         19 :     if (PyFloat_CheckExact(args[0])) {
         275                 :         13 :         x = PyFloat_AS_DOUBLE(args[0]);
         276                 :            :     }
         277                 :            :     else
         278                 :            :     {
         279                 :          6 :         x = PyFloat_AsDouble(args[0]);
         280   [ -  +  -  - ]:          6 :         if (x == -1.0 && PyErr_Occurred()) {
         281                 :          0 :             goto exit;
         282                 :            :         }
         283                 :            :     }
         284         [ +  + ]:         19 :     if (PyFloat_CheckExact(args[1])) {
         285                 :         17 :         y = PyFloat_AS_DOUBLE(args[1]);
         286                 :            :     }
         287                 :            :     else
         288                 :            :     {
         289                 :          2 :         y = PyFloat_AsDouble(args[1]);
         290   [ -  +  -  - ]:          2 :         if (y == -1.0 && PyErr_Occurred()) {
         291                 :          0 :             goto exit;
         292                 :            :         }
         293                 :            :     }
         294                 :         19 :     return_value = math_fmod_impl(module, x, y);
         295                 :            :
         296                 :         20 : exit:
         297                 :         20 :     return return_value;
         298                 :            : }
         299                 :            :
         300                 :            : PyDoc_STRVAR(math_dist__doc__,
         301                 :            : "dist($module, p, q, /)\n"
         302                 :            : "--\n"
         303                 :            : "\n"
         304                 :            : "Return the Euclidean distance between two points p and q.\n"
         305                 :            : "\n"
         306                 :            : "The points should be specified as sequences (or iterables) of\n"
         307                 :            : "coordinates.  Both inputs must have the same dimension.\n"
         308                 :            : "\n"
         309                 :            : "Roughly equivalent to:\n"
         310                 :            : "    sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))");
         311                 :            :
         312                 :            : #define MATH_DIST_METHODDEF    \
         313                 :            :     {"dist", _PyCFunction_CAST(math_dist), METH_FASTCALL, math_dist__doc__},
         314                 :            :
         315                 :            : static PyObject *
         316                 :            : math_dist_impl(PyObject *module, PyObject *p, PyObject *q);
         317                 :            :
         318                 :            : static PyObject *
         319                 :     113772 : math_dist(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         320                 :            : {
         321                 :     113772 :     PyObject *return_value = NULL;
         322                 :            :     PyObject *p;
         323                 :            :     PyObject *q;
         324                 :            :
         325   [ +  +  +  +  :     113772 :     if (!_PyArg_CheckPositional("dist", nargs, 2, 2)) {
                       +  - ]
         326                 :          2 :         goto exit;
         327                 :            :     }
         328                 :     113770 :     p = args[0];
         329                 :     113770 :     q = args[1];
         330                 :     113770 :     return_value = math_dist_impl(module, p, q);
         331                 :            :
         332                 :     113772 : exit:
         333                 :     113772 :     return return_value;
         334                 :            : }
         335                 :            :
         336                 :            : PyDoc_STRVAR(math_sumprod__doc__,
         337                 :            : "sumprod($module, p, q, /)\n"
         338                 :            : "--\n"
         339                 :            : "\n"
         340                 :            : "Return the sum of products of values from two iterables p and q.\n"
         341                 :            : "\n"
         342                 :            : "Roughly equivalent to:\n"
         343                 :            : "\n"
         344                 :            : "    sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))\n"
         345                 :            : "\n"
         346                 :            : "For float and mixed int/float inputs, the intermediate products\n"
         347                 :            : "and sums are computed with extended precision.");
         348                 :            :
         349                 :            : #define MATH_SUMPROD_METHODDEF    \
         350                 :            :     {"sumprod", _PyCFunction_CAST(math_sumprod), METH_FASTCALL, math_sumprod__doc__},
         351                 :            :
         352                 :            : static PyObject *
         353                 :            : math_sumprod_impl(PyObject *module, PyObject *p, PyObject *q);
         354                 :            :
         355                 :            : static PyObject *
         356                 :         44 : math_sumprod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         357                 :            : {
         358                 :         44 :     PyObject *return_value = NULL;
         359                 :            :     PyObject *p;
         360                 :            :     PyObject *q;
         361                 :            :
         362   [ +  +  +  +  :         44 :     if (!_PyArg_CheckPositional("sumprod", nargs, 2, 2)) {
                       +  - ]
         363                 :          3 :         goto exit;
         364                 :            :     }
         365                 :         41 :     p = args[0];
         366                 :         41 :     q = args[1];
         367                 :         41 :     return_value = math_sumprod_impl(module, p, q);
         368                 :            :
         369                 :         44 : exit:
         370                 :         44 :     return return_value;
         371                 :            : }
         372                 :            :
         373                 :            : PyDoc_STRVAR(math_pow__doc__,
         374                 :            : "pow($module, x, y, /)\n"
         375                 :            : "--\n"
         376                 :            : "\n"
         377                 :            : "Return x**y (x to the power of y).");
         378                 :            :
         379                 :            : #define MATH_POW_METHODDEF    \
         380                 :            :     {"pow", _PyCFunction_CAST(math_pow), METH_FASTCALL, math_pow__doc__},
         381                 :            :
         382                 :            : static PyObject *
         383                 :            : math_pow_impl(PyObject *module, double x, double y);
         384                 :            :
         385                 :            : static PyObject *
         386                 :        121 : math_pow(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         387                 :            : {
         388                 :        121 :     PyObject *return_value = NULL;
         389                 :            :     double x;
         390                 :            :     double y;
         391                 :            :
         392   [ +  +  -  +  :        121 :     if (!_PyArg_CheckPositional("pow", nargs, 2, 2)) {
                       +  - ]
         393                 :          1 :         goto exit;
         394                 :            :     }
         395         [ +  + ]:        120 :     if (PyFloat_CheckExact(args[0])) {
         396                 :        103 :         x = PyFloat_AS_DOUBLE(args[0]);
         397                 :            :     }
         398                 :            :     else
         399                 :            :     {
         400                 :         17 :         x = PyFloat_AsDouble(args[0]);
         401   [ -  +  -  - ]:         17 :         if (x == -1.0 && PyErr_Occurred()) {
         402                 :          0 :             goto exit;
         403                 :            :         }
         404                 :            :     }
         405         [ +  + ]:        120 :     if (PyFloat_CheckExact(args[1])) {
         406                 :        111 :         y = PyFloat_AS_DOUBLE(args[1]);
         407                 :            :     }
         408                 :            :     else
         409                 :            :     {
         410                 :          9 :         y = PyFloat_AsDouble(args[1]);
         411   [ +  +  -  + ]:          9 :         if (y == -1.0 && PyErr_Occurred()) {
         412                 :          0 :             goto exit;
         413                 :            :         }
         414                 :            :     }
         415                 :        120 :     return_value = math_pow_impl(module, x, y);
         416                 :            :
         417                 :        121 : exit:
         418                 :        121 :     return return_value;
         419                 :            : }
         420                 :            :
         421                 :            : PyDoc_STRVAR(math_degrees__doc__,
         422                 :            : "degrees($module, x, /)\n"
         423                 :            : "--\n"
         424                 :            : "\n"
         425                 :            : "Convert angle x from radians to degrees.");
         426                 :            :
         427                 :            : #define MATH_DEGREES_METHODDEF    \
         428                 :            :     {"degrees", (PyCFunction)math_degrees, METH_O, math_degrees__doc__},
         429                 :            :
         430                 :            : static PyObject *
         431                 :            : math_degrees_impl(PyObject *module, double x);
         432                 :            :
         433                 :            : static PyObject *
         434                 :          4 : math_degrees(PyObject *module, PyObject *arg)
         435                 :            : {
         436                 :          4 :     PyObject *return_value = NULL;
         437                 :            :     double x;
         438                 :            :
         439         [ +  + ]:          4 :     if (PyFloat_CheckExact(arg)) {
         440                 :          3 :         x = PyFloat_AS_DOUBLE(arg);
         441                 :            :     }
         442                 :            :     else
         443                 :            :     {
         444                 :          1 :         x = PyFloat_AsDouble(arg);
         445   [ -  +  -  - ]:          1 :         if (x == -1.0 && PyErr_Occurred()) {
         446                 :          0 :             goto exit;
         447                 :            :         }
         448                 :            :     }
         449                 :          4 :     return_value = math_degrees_impl(module, x);
         450                 :            :
         451                 :          4 : exit:
         452                 :          4 :     return return_value;
         453                 :            : }
         454                 :            :
         455                 :            : PyDoc_STRVAR(math_radians__doc__,
         456                 :            : "radians($module, x, /)\n"
         457                 :            : "--\n"
         458                 :            : "\n"
         459                 :            : "Convert angle x from degrees to radians.");
         460                 :            :
         461                 :            : #define MATH_RADIANS_METHODDEF    \
         462                 :            :     {"radians", (PyCFunction)math_radians, METH_O, math_radians__doc__},
         463                 :            :
         464                 :            : static PyObject *
         465                 :            : math_radians_impl(PyObject *module, double x);
         466                 :            :
         467                 :            : static PyObject *
         468                 :          4 : math_radians(PyObject *module, PyObject *arg)
         469                 :            : {
         470                 :          4 :     PyObject *return_value = NULL;
         471                 :            :     double x;
         472                 :            :
         473         [ -  + ]:          4 :     if (PyFloat_CheckExact(arg)) {
         474                 :          0 :         x = PyFloat_AS_DOUBLE(arg);
         475                 :            :     }
         476                 :            :     else
         477                 :            :     {
         478                 :          4 :         x = PyFloat_AsDouble(arg);
         479   [ -  +  -  - ]:          4 :         if (x == -1.0 && PyErr_Occurred()) {
         480                 :          0 :             goto exit;
         481                 :            :         }
         482                 :            :     }
         483                 :          4 :     return_value = math_radians_impl(module, x);
         484                 :            :
         485                 :          4 : exit:
         486                 :          4 :     return return_value;
         487                 :            : }
         488                 :            :
         489                 :            : PyDoc_STRVAR(math_isfinite__doc__,
         490                 :            : "isfinite($module, x, /)\n"
         491                 :            : "--\n"
         492                 :            : "\n"
         493                 :            : "Return True if x is neither an infinity nor a NaN, and False otherwise.");
         494                 :            :
         495                 :            : #define MATH_ISFINITE_METHODDEF    \
         496                 :            :     {"isfinite", (PyCFunction)math_isfinite, METH_O, math_isfinite__doc__},
         497                 :            :
         498                 :            : static PyObject *
         499                 :            : math_isfinite_impl(PyObject *module, double x);
         500                 :            :
         501                 :            : static PyObject *
         502                 :          7 : math_isfinite(PyObject *module, PyObject *arg)
         503                 :            : {
         504                 :          7 :     PyObject *return_value = NULL;
         505                 :            :     double x;
         506                 :            :
         507         [ +  - ]:          7 :     if (PyFloat_CheckExact(arg)) {
         508                 :          7 :         x = PyFloat_AS_DOUBLE(arg);
         509                 :            :     }
         510                 :            :     else
         511                 :            :     {
         512                 :          0 :         x = PyFloat_AsDouble(arg);
         513   [ #  #  #  # ]:          0 :         if (x == -1.0 && PyErr_Occurred()) {
         514                 :          0 :             goto exit;
         515                 :            :         }
         516                 :            :     }
         517                 :          7 :     return_value = math_isfinite_impl(module, x);
         518                 :            :
         519                 :          7 : exit:
         520                 :          7 :     return return_value;
         521                 :            : }
         522                 :            :
         523                 :            : PyDoc_STRVAR(math_isnan__doc__,
         524                 :            : "isnan($module, x, /)\n"
         525                 :            : "--\n"
         526                 :            : "\n"
         527                 :            : "Return True if x is a NaN (not a number), and False otherwise.");
         528                 :            :
         529                 :            : #define MATH_ISNAN_METHODDEF    \
         530                 :            :     {"isnan", (PyCFunction)math_isnan, METH_O, math_isnan__doc__},
         531                 :            :
         532                 :            : static PyObject *
         533                 :            : math_isnan_impl(PyObject *module, double x);
         534                 :            :
         535                 :            : static PyObject *
         536                 :      79052 : math_isnan(PyObject *module, PyObject *arg)
         537                 :            : {
         538                 :      79052 :     PyObject *return_value = NULL;
         539                 :            :     double x;
         540                 :            :
         541         [ +  - ]:      79052 :     if (PyFloat_CheckExact(arg)) {
         542                 :      79052 :         x = PyFloat_AS_DOUBLE(arg);
         543                 :            :     }
         544                 :            :     else
         545                 :            :     {
         546                 :          0 :         x = PyFloat_AsDouble(arg);
         547   [ #  #  #  # ]:          0 :         if (x == -1.0 && PyErr_Occurred()) {
         548                 :          0 :             goto exit;
         549                 :            :         }
         550                 :            :     }
         551                 :      79052 :     return_value = math_isnan_impl(module, x);
         552                 :            :
         553                 :      79052 : exit:
         554                 :      79052 :     return return_value;
         555                 :            : }
         556                 :            :
         557                 :            : PyDoc_STRVAR(math_isinf__doc__,
         558                 :            : "isinf($module, x, /)\n"
         559                 :            : "--\n"
         560                 :            : "\n"
         561                 :            : "Return True if x is a positive or negative infinity, and False otherwise.");
         562                 :            :
         563                 :            : #define MATH_ISINF_METHODDEF    \
         564                 :            :     {"isinf", (PyCFunction)math_isinf, METH_O, math_isinf__doc__},
         565                 :            :
         566                 :            : static PyObject *
         567                 :            : math_isinf_impl(PyObject *module, double x);
         568                 :            :
         569                 :            : static PyObject *
         570                 :     239380 : math_isinf(PyObject *module, PyObject *arg)
         571                 :            : {
         572                 :     239380 :     PyObject *return_value = NULL;
         573                 :            :     double x;
         574                 :            :
         575         [ +  - ]:     239380 :     if (PyFloat_CheckExact(arg)) {
         576                 :     239380 :         x = PyFloat_AS_DOUBLE(arg);
         577                 :            :     }
         578                 :            :     else
         579                 :            :     {
         580                 :          0 :         x = PyFloat_AsDouble(arg);
         581   [ #  #  #  # ]:          0 :         if (x == -1.0 && PyErr_Occurred()) {
         582                 :          0 :             goto exit;
         583                 :            :         }
         584                 :            :     }
         585                 :     239380 :     return_value = math_isinf_impl(module, x);
         586                 :            :
         587                 :     239380 : exit:
         588                 :     239380 :     return return_value;
         589                 :            : }
         590                 :            :
         591                 :            : PyDoc_STRVAR(math_isclose__doc__,
         592                 :            : "isclose($module, /, a, b, *, rel_tol=1e-09, abs_tol=0.0)\n"
         593                 :            : "--\n"
         594                 :            : "\n"
         595                 :            : "Determine whether two floating point numbers are close in value.\n"
         596                 :            : "\n"
         597                 :            : "  rel_tol\n"
         598                 :            : "    maximum difference for being considered \"close\", relative to the\n"
         599                 :            : "    magnitude of the input values\n"
         600                 :            : "  abs_tol\n"
         601                 :            : "    maximum difference for being considered \"close\", regardless of the\n"
         602                 :            : "    magnitude of the input values\n"
         603                 :            : "\n"
         604                 :            : "Return True if a is close in value to b, and False otherwise.\n"
         605                 :            : "\n"
         606                 :            : "For the values to be considered close, the difference between them\n"
         607                 :            : "must be smaller than at least one of the tolerances.\n"
         608                 :            : "\n"
         609                 :            : "-inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n"
         610                 :            : "is, NaN is not close to anything, even itself.  inf and -inf are\n"
         611                 :            : "only close to themselves.");
         612                 :            :
         613                 :            : #define MATH_ISCLOSE_METHODDEF    \
         614                 :            :     {"isclose", _PyCFunction_CAST(math_isclose), METH_FASTCALL|METH_KEYWORDS, math_isclose__doc__},
         615                 :            :
         616                 :            : static int
         617                 :            : math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
         618                 :            :                   double abs_tol);
         619                 :            :
         620                 :            : static PyObject *
         621                 :        156 : math_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         622                 :            : {
         623                 :        156 :     PyObject *return_value = NULL;
         624                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         625                 :            :
         626                 :            :     #define NUM_KEYWORDS 4
         627                 :            :     static struct {
         628                 :            :         PyGC_Head _this_is_not_used;
         629                 :            :         PyObject_VAR_HEAD
         630                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         631                 :            :     } _kwtuple = {
         632                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         633                 :            :         .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(rel_tol), &_Py_ID(abs_tol), },
         634                 :            :     };
         635                 :            :     #undef NUM_KEYWORDS
         636                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         637                 :            :
         638                 :            :     #else  // !Py_BUILD_CORE
         639                 :            :     #  define KWTUPLE NULL
         640                 :            :     #endif  // !Py_BUILD_CORE
         641                 :            :
         642                 :            :     static const char * const _keywords[] = {"a", "b", "rel_tol", "abs_tol", NULL};
         643                 :            :     static _PyArg_Parser _parser = {
         644                 :            :         .keywords = _keywords,
         645                 :            :         .fname = "isclose",
         646                 :            :         .kwtuple = KWTUPLE,
         647                 :            :     };
         648                 :            :     #undef KWTUPLE
         649                 :            :     PyObject *argsbuf[4];
         650         [ +  + ]:        156 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
         651                 :            :     double a;
         652                 :            :     double b;
         653                 :        156 :     double rel_tol = 1e-09;
         654                 :        156 :     double abs_tol = 0.0;
         655                 :            :     int _return_value;
         656                 :            :
         657   [ +  +  +  -  :        156 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
                 +  -  -  + ]
         658         [ -  + ]:        156 :     if (!args) {
         659                 :          0 :         goto exit;
         660                 :            :     }
         661         [ +  + ]:        156 :     if (PyFloat_CheckExact(args[0])) {
         662                 :        132 :         a = PyFloat_AS_DOUBLE(args[0]);
         663                 :            :     }
         664                 :            :     else
         665                 :            :     {
         666                 :         24 :         a = PyFloat_AsDouble(args[0]);
         667   [ -  +  -  - ]:         24 :         if (a == -1.0 && PyErr_Occurred()) {
         668                 :          0 :             goto exit;
         669                 :            :         }
         670                 :            :     }
         671         [ +  + ]:        156 :     if (PyFloat_CheckExact(args[1])) {
         672                 :        133 :         b = PyFloat_AS_DOUBLE(args[1]);
         673                 :            :     }
         674                 :            :     else
         675                 :            :     {
         676                 :         23 :         b = PyFloat_AsDouble(args[1]);
         677   [ -  +  -  - ]:         23 :         if (b == -1.0 && PyErr_Occurred()) {
         678                 :          0 :             goto exit;
         679                 :            :         }
         680                 :            :     }
         681         [ +  + ]:        156 :     if (!noptargs) {
         682                 :         98 :         goto skip_optional_kwonly;
         683                 :            :     }
         684         [ +  + ]:         58 :     if (args[2]) {
         685         [ +  - ]:         43 :         if (PyFloat_CheckExact(args[2])) {
         686                 :         43 :             rel_tol = PyFloat_AS_DOUBLE(args[2]);
         687                 :            :         }
         688                 :            :         else
         689                 :            :         {
         690                 :          0 :             rel_tol = PyFloat_AsDouble(args[2]);
         691   [ #  #  #  # ]:          0 :             if (rel_tol == -1.0 && PyErr_Occurred()) {
         692                 :          0 :                 goto exit;
         693                 :            :             }
         694                 :            :         }
         695         [ +  + ]:         43 :         if (!--noptargs) {
         696                 :         36 :             goto skip_optional_kwonly;
         697                 :            :         }
         698                 :            :     }
         699         [ +  - ]:         22 :     if (PyFloat_CheckExact(args[3])) {
         700                 :         22 :         abs_tol = PyFloat_AS_DOUBLE(args[3]);
         701                 :            :     }
         702                 :            :     else
         703                 :            :     {
         704                 :          0 :         abs_tol = PyFloat_AsDouble(args[3]);
         705   [ #  #  #  # ]:          0 :         if (abs_tol == -1.0 && PyErr_Occurred()) {
         706                 :          0 :             goto exit;
         707                 :            :         }
         708                 :            :     }
         709                 :          0 : skip_optional_kwonly:
         710                 :        156 :     _return_value = math_isclose_impl(module, a, b, rel_tol, abs_tol);
         711   [ +  +  +  - ]:        156 :     if ((_return_value == -1) && PyErr_Occurred()) {
         712                 :          2 :         goto exit;
         713                 :            :     }
         714                 :        154 :     return_value = PyBool_FromLong((long)_return_value);
         715                 :            :
         716                 :        156 : exit:
         717                 :        156 :     return return_value;
         718                 :            : }
         719                 :            :
         720                 :            : PyDoc_STRVAR(math_prod__doc__,
         721                 :            : "prod($module, iterable, /, *, start=1)\n"
         722                 :            : "--\n"
         723                 :            : "\n"
         724                 :            : "Calculate the product of all the elements in the input iterable.\n"
         725                 :            : "\n"
         726                 :            : "The default start value for the product is 1.\n"
         727                 :            : "\n"
         728                 :            : "When the iterable is empty, return the start value.  This function is\n"
         729                 :            : "intended specifically for use with numeric values and may reject\n"
         730                 :            : "non-numeric types.");
         731                 :            :
         732                 :            : #define MATH_PROD_METHODDEF    \
         733                 :            :     {"prod", _PyCFunction_CAST(math_prod), METH_FASTCALL|METH_KEYWORDS, math_prod__doc__},
         734                 :            :
         735                 :            : static PyObject *
         736                 :            : math_prod_impl(PyObject *module, PyObject *iterable, PyObject *start);
         737                 :            :
         738                 :            : static PyObject *
         739                 :         52 : math_prod(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         740                 :            : {
         741                 :         52 :     PyObject *return_value = NULL;
         742                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         743                 :            :
         744                 :            :     #define NUM_KEYWORDS 1
         745                 :            :     static struct {
         746                 :            :         PyGC_Head _this_is_not_used;
         747                 :            :         PyObject_VAR_HEAD
         748                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         749                 :            :     } _kwtuple = {
         750                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         751                 :            :         .ob_item = { &_Py_ID(start), },
         752                 :            :     };
         753                 :            :     #undef NUM_KEYWORDS
         754                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         755                 :            :
         756                 :            :     #else  // !Py_BUILD_CORE
         757                 :            :     #  define KWTUPLE NULL
         758                 :            :     #endif  // !Py_BUILD_CORE
         759                 :            :
         760                 :            :     static const char * const _keywords[] = {"", "start", NULL};
         761                 :            :     static _PyArg_Parser _parser = {
         762                 :            :         .keywords = _keywords,
         763                 :            :         .fname = "prod",
         764                 :            :         .kwtuple = KWTUPLE,
         765                 :            :     };
         766                 :            :     #undef KWTUPLE
         767                 :            :     PyObject *argsbuf[2];
         768         [ +  + ]:         52 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
         769                 :            :     PyObject *iterable;
         770                 :         52 :     PyObject *start = NULL;
         771                 :            :
         772   [ +  +  +  +  :         52 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
                 +  +  -  + ]
         773         [ +  + ]:         52 :     if (!args) {
         774                 :          2 :         goto exit;
         775                 :            :     }
         776                 :         50 :     iterable = args[0];
         777         [ +  + ]:         50 :     if (!noptargs) {
         778                 :         39 :         goto skip_optional_kwonly;
         779                 :            :     }
         780                 :         11 :     start = args[1];
         781                 :         50 : skip_optional_kwonly:
         782                 :         50 :     return_value = math_prod_impl(module, iterable, start);
         783                 :            :
         784                 :         52 : exit:
         785                 :         52 :     return return_value;
         786                 :            : }
         787                 :            :
         788                 :            : PyDoc_STRVAR(math_perm__doc__,
         789                 :            : "perm($module, n, k=None, /)\n"
         790                 :            : "--\n"
         791                 :            : "\n"
         792                 :            : "Number of ways to choose k items from n items without repetition and with order.\n"
         793                 :            : "\n"
         794                 :            : "Evaluates to n! / (n - k)! when k <= n and evaluates\n"
         795                 :            : "to zero when k > n.\n"
         796                 :            : "\n"
         797                 :            : "If k is not specified or is None, then k defaults to n\n"
         798                 :            : "and the function returns n!.\n"
         799                 :            : "\n"
         800                 :            : "Raises TypeError if either of the arguments are not integers.\n"
         801                 :            : "Raises ValueError if either of the arguments are negative.");
         802                 :            :
         803                 :            : #define MATH_PERM_METHODDEF    \
         804                 :            :     {"perm", _PyCFunction_CAST(math_perm), METH_FASTCALL, math_perm__doc__},
         805                 :            :
         806                 :            : static PyObject *
         807                 :            : math_perm_impl(PyObject *module, PyObject *n, PyObject *k);
         808                 :            :
         809                 :            : static PyObject *
         810                 :      25973 : math_perm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         811                 :            : {
         812                 :      25973 :     PyObject *return_value = NULL;
         813                 :            :     PyObject *n;
         814                 :      25973 :     PyObject *k = Py_None;
         815                 :            :
         816   [ +  +  +  +  :      25973 :     if (!_PyArg_CheckPositional("perm", nargs, 1, 2)) {
                       +  - ]
         817                 :          3 :         goto exit;
         818                 :            :     }
         819                 :      25970 :     n = args[0];
         820         [ +  + ]:      25970 :     if (nargs < 2) {
         821                 :         20 :         goto skip_optional;
         822                 :            :     }
         823                 :      25950 :     k = args[1];
         824                 :      25970 : skip_optional:
         825                 :      25970 :     return_value = math_perm_impl(module, n, k);
         826                 :            :
         827                 :      25973 : exit:
         828                 :      25973 :     return return_value;
         829                 :            : }
         830                 :            :
         831                 :            : PyDoc_STRVAR(math_comb__doc__,
         832                 :            : "comb($module, n, k, /)\n"
         833                 :            : "--\n"
         834                 :            : "\n"
         835                 :            : "Number of ways to choose k items from n items without repetition and without order.\n"
         836                 :            : "\n"
         837                 :            : "Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n"
         838                 :            : "to zero when k > n.\n"
         839                 :            : "\n"
         840                 :            : "Also called the binomial coefficient because it is equivalent\n"
         841                 :            : "to the coefficient of k-th term in polynomial expansion of the\n"
         842                 :            : "expression (1 + x)**n.\n"
         843                 :            : "\n"
         844                 :            : "Raises TypeError if either of the arguments are not integers.\n"
         845                 :            : "Raises ValueError if either of the arguments are negative.");
         846                 :            :
         847                 :            : #define MATH_COMB_METHODDEF    \
         848                 :            :     {"comb", _PyCFunction_CAST(math_comb), METH_FASTCALL, math_comb__doc__},
         849                 :            :
         850                 :            : static PyObject *
         851                 :            : math_comb_impl(PyObject *module, PyObject *n, PyObject *k);
         852                 :            :
         853                 :            : static PyObject *
         854                 :      30937 : math_comb(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         855                 :            : {
         856                 :      30937 :     PyObject *return_value = NULL;
         857                 :            :     PyObject *n;
         858                 :            :     PyObject *k;
         859                 :            :
         860   [ +  +  +  +  :      30937 :     if (!_PyArg_CheckPositional("comb", nargs, 2, 2)) {
                       +  - ]
         861                 :          3 :         goto exit;
         862                 :            :     }
         863                 :      30934 :     n = args[0];
         864                 :      30934 :     k = args[1];
         865                 :      30934 :     return_value = math_comb_impl(module, n, k);
         866                 :            :
         867                 :      30937 : exit:
         868                 :      30937 :     return return_value;
         869                 :            : }
         870                 :            :
         871                 :            : PyDoc_STRVAR(math_nextafter__doc__,
         872                 :            : "nextafter($module, x, y, /)\n"
         873                 :            : "--\n"
         874                 :            : "\n"
         875                 :            : "Return the next floating-point value after x towards y.");
         876                 :            :
         877                 :            : #define MATH_NEXTAFTER_METHODDEF    \
         878                 :            :     {"nextafter", _PyCFunction_CAST(math_nextafter), METH_FASTCALL, math_nextafter__doc__},
         879                 :            :
         880                 :            : static PyObject *
         881                 :            : math_nextafter_impl(PyObject *module, double x, double y);
         882                 :            :
         883                 :            : static PyObject *
         884                 :         25 : math_nextafter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         885                 :            : {
         886                 :         25 :     PyObject *return_value = NULL;
         887                 :            :     double x;
         888                 :            :     double y;
         889                 :            :
         890   [ +  -  -  +  :         25 :     if (!_PyArg_CheckPositional("nextafter", nargs, 2, 2)) {
                       -  - ]
         891                 :          0 :         goto exit;
         892                 :            :     }
         893         [ +  - ]:         25 :     if (PyFloat_CheckExact(args[0])) {
         894                 :         25 :         x = PyFloat_AS_DOUBLE(args[0]);
         895                 :            :     }
         896                 :            :     else
         897                 :            :     {
         898                 :          0 :         x = PyFloat_AsDouble(args[0]);
         899   [ #  #  #  # ]:          0 :         if (x == -1.0 && PyErr_Occurred()) {
         900                 :          0 :             goto exit;
         901                 :            :         }
         902                 :            :     }
         903         [ +  - ]:         25 :     if (PyFloat_CheckExact(args[1])) {
         904                 :         25 :         y = PyFloat_AS_DOUBLE(args[1]);
         905                 :            :     }
         906                 :            :     else
         907                 :            :     {
         908                 :          0 :         y = PyFloat_AsDouble(args[1]);
         909   [ #  #  #  # ]:          0 :         if (y == -1.0 && PyErr_Occurred()) {
         910                 :          0 :             goto exit;
         911                 :            :         }
         912                 :            :     }
         913                 :         25 :     return_value = math_nextafter_impl(module, x, y);
         914                 :            :
         915                 :         25 : exit:
         916                 :         25 :     return return_value;
         917                 :            : }
         918                 :            :
         919                 :            : PyDoc_STRVAR(math_ulp__doc__,
         920                 :            : "ulp($module, x, /)\n"
         921                 :            : "--\n"
         922                 :            : "\n"
         923                 :            : "Return the value of the least significant bit of the float x.");
         924                 :            :
         925                 :            : #define MATH_ULP_METHODDEF    \
         926                 :            :     {"ulp", (PyCFunction)math_ulp, METH_O, math_ulp__doc__},
         927                 :            :
         928                 :            : static double
         929                 :            : math_ulp_impl(PyObject *module, double x);
         930                 :            :
         931                 :            : static PyObject *
         932                 :         21 : math_ulp(PyObject *module, PyObject *arg)
         933                 :            : {
         934                 :         21 :     PyObject *return_value = NULL;
         935                 :            :     double x;
         936                 :            :     double _return_value;
         937                 :            :
         938         [ +  + ]:         21 :     if (PyFloat_CheckExact(arg)) {
         939                 :         11 :         x = PyFloat_AS_DOUBLE(arg);
         940                 :            :     }
         941                 :            :     else
         942                 :            :     {
         943                 :         10 :         x = PyFloat_AsDouble(arg);
         944   [ -  +  -  - ]:         10 :         if (x == -1.0 && PyErr_Occurred()) {
         945                 :          0 :             goto exit;
         946                 :            :         }
         947                 :            :     }
         948                 :         21 :     _return_value = math_ulp_impl(module, x);
         949   [ -  +  -  - ]:         21 :     if ((_return_value == -1.0) && PyErr_Occurred()) {
         950                 :          0 :         goto exit;
         951                 :            :     }
         952                 :         21 :     return_value = PyFloat_FromDouble(_return_value);
         953                 :            :
         954                 :         21 : exit:
         955                 :         21 :     return return_value;
         956                 :            : }
         957                 :            : /*[clinic end generated code: output=899211ec70e4506c input=a9049054013a1b77]*/

Generated by: LCOV version 1.14