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