1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(math_gcd__doc__,
6 "gcd($module, x, y, /)\n"
7 "--\n"
8 "\n"
9 "greatest common divisor of x and y");
10
11 #define MATH_GCD_METHODDEF \
12 {"gcd", (PyCFunction)math_gcd, METH_FASTCALL, math_gcd__doc__},
13
14 static PyObject *
15 math_gcd_impl(PyObject *module, PyObject *a, PyObject *b);
16
17 static PyObject *
math_gcd(PyObject * module,PyObject * const * args,Py_ssize_t nargs)18 math_gcd(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
19 {
20 PyObject *return_value = NULL;
21 PyObject *a;
22 PyObject *b;
23
24 if (!_PyArg_UnpackStack(args, nargs, "gcd",
25 2, 2,
26 &a, &b)) {
27 goto exit;
28 }
29 return_value = math_gcd_impl(module, a, b);
30
31 exit:
32 return return_value;
33 }
34
35 PyDoc_STRVAR(math_ceil__doc__,
36 "ceil($module, x, /)\n"
37 "--\n"
38 "\n"
39 "Return the ceiling of x as an Integral.\n"
40 "\n"
41 "This is the smallest integer >= x.");
42
43 #define MATH_CEIL_METHODDEF \
44 {"ceil", (PyCFunction)math_ceil, METH_O, math_ceil__doc__},
45
46 PyDoc_STRVAR(math_floor__doc__,
47 "floor($module, x, /)\n"
48 "--\n"
49 "\n"
50 "Return the floor of x as an Integral.\n"
51 "\n"
52 "This is the largest integer <= x.");
53
54 #define MATH_FLOOR_METHODDEF \
55 {"floor", (PyCFunction)math_floor, METH_O, math_floor__doc__},
56
57 PyDoc_STRVAR(math_fsum__doc__,
58 "fsum($module, seq, /)\n"
59 "--\n"
60 "\n"
61 "Return an accurate floating point sum of values in the iterable seq.\n"
62 "\n"
63 "Assumes IEEE-754 floating point arithmetic.");
64
65 #define MATH_FSUM_METHODDEF \
66 {"fsum", (PyCFunction)math_fsum, METH_O, math_fsum__doc__},
67
68 PyDoc_STRVAR(math_factorial__doc__,
69 "factorial($module, x, /)\n"
70 "--\n"
71 "\n"
72 "Find x!.\n"
73 "\n"
74 "Raise a ValueError if x is negative or non-integral.");
75
76 #define MATH_FACTORIAL_METHODDEF \
77 {"factorial", (PyCFunction)math_factorial, METH_O, math_factorial__doc__},
78
79 PyDoc_STRVAR(math_trunc__doc__,
80 "trunc($module, x, /)\n"
81 "--\n"
82 "\n"
83 "Truncates the Real x to the nearest Integral toward 0.\n"
84 "\n"
85 "Uses the __trunc__ magic method.");
86
87 #define MATH_TRUNC_METHODDEF \
88 {"trunc", (PyCFunction)math_trunc, METH_O, math_trunc__doc__},
89
90 PyDoc_STRVAR(math_frexp__doc__,
91 "frexp($module, x, /)\n"
92 "--\n"
93 "\n"
94 "Return the mantissa and exponent of x, as pair (m, e).\n"
95 "\n"
96 "m is a float and e is an int, such that x = m * 2.**e.\n"
97 "If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.");
98
99 #define MATH_FREXP_METHODDEF \
100 {"frexp", (PyCFunction)math_frexp, METH_O, math_frexp__doc__},
101
102 static PyObject *
103 math_frexp_impl(PyObject *module, double x);
104
105 static PyObject *
math_frexp(PyObject * module,PyObject * arg)106 math_frexp(PyObject *module, PyObject *arg)
107 {
108 PyObject *return_value = NULL;
109 double x;
110
111 if (!PyArg_Parse(arg, "d:frexp", &x)) {
112 goto exit;
113 }
114 return_value = math_frexp_impl(module, x);
115
116 exit:
117 return return_value;
118 }
119
120 PyDoc_STRVAR(math_ldexp__doc__,
121 "ldexp($module, x, i, /)\n"
122 "--\n"
123 "\n"
124 "Return x * (2**i).\n"
125 "\n"
126 "This is essentially the inverse of frexp().");
127
128 #define MATH_LDEXP_METHODDEF \
129 {"ldexp", (PyCFunction)math_ldexp, METH_FASTCALL, math_ldexp__doc__},
130
131 static PyObject *
132 math_ldexp_impl(PyObject *module, double x, PyObject *i);
133
134 static PyObject *
math_ldexp(PyObject * module,PyObject * const * args,Py_ssize_t nargs)135 math_ldexp(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
136 {
137 PyObject *return_value = NULL;
138 double x;
139 PyObject *i;
140
141 if (!_PyArg_ParseStack(args, nargs, "dO:ldexp",
142 &x, &i)) {
143 goto exit;
144 }
145 return_value = math_ldexp_impl(module, x, i);
146
147 exit:
148 return return_value;
149 }
150
151 PyDoc_STRVAR(math_modf__doc__,
152 "modf($module, x, /)\n"
153 "--\n"
154 "\n"
155 "Return the fractional and integer parts of x.\n"
156 "\n"
157 "Both results carry the sign of x and are floats.");
158
159 #define MATH_MODF_METHODDEF \
160 {"modf", (PyCFunction)math_modf, METH_O, math_modf__doc__},
161
162 static PyObject *
163 math_modf_impl(PyObject *module, double x);
164
165 static PyObject *
math_modf(PyObject * module,PyObject * arg)166 math_modf(PyObject *module, PyObject *arg)
167 {
168 PyObject *return_value = NULL;
169 double x;
170
171 if (!PyArg_Parse(arg, "d:modf", &x)) {
172 goto exit;
173 }
174 return_value = math_modf_impl(module, x);
175
176 exit:
177 return return_value;
178 }
179
180 PyDoc_STRVAR(math_log__doc__,
181 "log(x, [base=math.e])\n"
182 "Return the logarithm of x to the given base.\n"
183 "\n"
184 "If the base not specified, returns the natural logarithm (base e) of x.");
185
186 #define MATH_LOG_METHODDEF \
187 {"log", (PyCFunction)math_log, METH_VARARGS, math_log__doc__},
188
189 static PyObject *
190 math_log_impl(PyObject *module, PyObject *x, int group_right_1,
191 PyObject *base);
192
193 static PyObject *
math_log(PyObject * module,PyObject * args)194 math_log(PyObject *module, PyObject *args)
195 {
196 PyObject *return_value = NULL;
197 PyObject *x;
198 int group_right_1 = 0;
199 PyObject *base = NULL;
200
201 switch (PyTuple_GET_SIZE(args)) {
202 case 1:
203 if (!PyArg_ParseTuple(args, "O:log", &x)) {
204 goto exit;
205 }
206 break;
207 case 2:
208 if (!PyArg_ParseTuple(args, "OO:log", &x, &base)) {
209 goto exit;
210 }
211 group_right_1 = 1;
212 break;
213 default:
214 PyErr_SetString(PyExc_TypeError, "math.log requires 1 to 2 arguments");
215 goto exit;
216 }
217 return_value = math_log_impl(module, x, group_right_1, base);
218
219 exit:
220 return return_value;
221 }
222
223 PyDoc_STRVAR(math_log2__doc__,
224 "log2($module, x, /)\n"
225 "--\n"
226 "\n"
227 "Return the base 2 logarithm of x.");
228
229 #define MATH_LOG2_METHODDEF \
230 {"log2", (PyCFunction)math_log2, METH_O, math_log2__doc__},
231
232 PyDoc_STRVAR(math_log10__doc__,
233 "log10($module, x, /)\n"
234 "--\n"
235 "\n"
236 "Return the base 10 logarithm of x.");
237
238 #define MATH_LOG10_METHODDEF \
239 {"log10", (PyCFunction)math_log10, METH_O, math_log10__doc__},
240
241 PyDoc_STRVAR(math_fmod__doc__,
242 "fmod($module, x, y, /)\n"
243 "--\n"
244 "\n"
245 "Return fmod(x, y), according to platform C.\n"
246 "\n"
247 "x % y may differ.");
248
249 #define MATH_FMOD_METHODDEF \
250 {"fmod", (PyCFunction)math_fmod, METH_FASTCALL, math_fmod__doc__},
251
252 static PyObject *
253 math_fmod_impl(PyObject *module, double x, double y);
254
255 static PyObject *
math_fmod(PyObject * module,PyObject * const * args,Py_ssize_t nargs)256 math_fmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
257 {
258 PyObject *return_value = NULL;
259 double x;
260 double y;
261
262 if (!_PyArg_ParseStack(args, nargs, "dd:fmod",
263 &x, &y)) {
264 goto exit;
265 }
266 return_value = math_fmod_impl(module, x, y);
267
268 exit:
269 return return_value;
270 }
271
272 PyDoc_STRVAR(math_hypot__doc__,
273 "hypot($module, x, y, /)\n"
274 "--\n"
275 "\n"
276 "Return the Euclidean distance, sqrt(x*x + y*y).");
277
278 #define MATH_HYPOT_METHODDEF \
279 {"hypot", (PyCFunction)math_hypot, METH_FASTCALL, math_hypot__doc__},
280
281 static PyObject *
282 math_hypot_impl(PyObject *module, double x, double y);
283
284 static PyObject *
math_hypot(PyObject * module,PyObject * const * args,Py_ssize_t nargs)285 math_hypot(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
286 {
287 PyObject *return_value = NULL;
288 double x;
289 double y;
290
291 if (!_PyArg_ParseStack(args, nargs, "dd:hypot",
292 &x, &y)) {
293 goto exit;
294 }
295 return_value = math_hypot_impl(module, x, y);
296
297 exit:
298 return return_value;
299 }
300
301 PyDoc_STRVAR(math_pow__doc__,
302 "pow($module, x, y, /)\n"
303 "--\n"
304 "\n"
305 "Return x**y (x to the power of y).");
306
307 #define MATH_POW_METHODDEF \
308 {"pow", (PyCFunction)math_pow, METH_FASTCALL, math_pow__doc__},
309
310 static PyObject *
311 math_pow_impl(PyObject *module, double x, double y);
312
313 static PyObject *
math_pow(PyObject * module,PyObject * const * args,Py_ssize_t nargs)314 math_pow(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
315 {
316 PyObject *return_value = NULL;
317 double x;
318 double y;
319
320 if (!_PyArg_ParseStack(args, nargs, "dd:pow",
321 &x, &y)) {
322 goto exit;
323 }
324 return_value = math_pow_impl(module, x, y);
325
326 exit:
327 return return_value;
328 }
329
330 PyDoc_STRVAR(math_degrees__doc__,
331 "degrees($module, x, /)\n"
332 "--\n"
333 "\n"
334 "Convert angle x from radians to degrees.");
335
336 #define MATH_DEGREES_METHODDEF \
337 {"degrees", (PyCFunction)math_degrees, METH_O, math_degrees__doc__},
338
339 static PyObject *
340 math_degrees_impl(PyObject *module, double x);
341
342 static PyObject *
math_degrees(PyObject * module,PyObject * arg)343 math_degrees(PyObject *module, PyObject *arg)
344 {
345 PyObject *return_value = NULL;
346 double x;
347
348 if (!PyArg_Parse(arg, "d:degrees", &x)) {
349 goto exit;
350 }
351 return_value = math_degrees_impl(module, x);
352
353 exit:
354 return return_value;
355 }
356
357 PyDoc_STRVAR(math_radians__doc__,
358 "radians($module, x, /)\n"
359 "--\n"
360 "\n"
361 "Convert angle x from degrees to radians.");
362
363 #define MATH_RADIANS_METHODDEF \
364 {"radians", (PyCFunction)math_radians, METH_O, math_radians__doc__},
365
366 static PyObject *
367 math_radians_impl(PyObject *module, double x);
368
369 static PyObject *
math_radians(PyObject * module,PyObject * arg)370 math_radians(PyObject *module, PyObject *arg)
371 {
372 PyObject *return_value = NULL;
373 double x;
374
375 if (!PyArg_Parse(arg, "d:radians", &x)) {
376 goto exit;
377 }
378 return_value = math_radians_impl(module, x);
379
380 exit:
381 return return_value;
382 }
383
384 PyDoc_STRVAR(math_isfinite__doc__,
385 "isfinite($module, x, /)\n"
386 "--\n"
387 "\n"
388 "Return True if x is neither an infinity nor a NaN, and False otherwise.");
389
390 #define MATH_ISFINITE_METHODDEF \
391 {"isfinite", (PyCFunction)math_isfinite, METH_O, math_isfinite__doc__},
392
393 static PyObject *
394 math_isfinite_impl(PyObject *module, double x);
395
396 static PyObject *
math_isfinite(PyObject * module,PyObject * arg)397 math_isfinite(PyObject *module, PyObject *arg)
398 {
399 PyObject *return_value = NULL;
400 double x;
401
402 if (!PyArg_Parse(arg, "d:isfinite", &x)) {
403 goto exit;
404 }
405 return_value = math_isfinite_impl(module, x);
406
407 exit:
408 return return_value;
409 }
410
411 PyDoc_STRVAR(math_isnan__doc__,
412 "isnan($module, x, /)\n"
413 "--\n"
414 "\n"
415 "Return True if x is a NaN (not a number), and False otherwise.");
416
417 #define MATH_ISNAN_METHODDEF \
418 {"isnan", (PyCFunction)math_isnan, METH_O, math_isnan__doc__},
419
420 static PyObject *
421 math_isnan_impl(PyObject *module, double x);
422
423 static PyObject *
math_isnan(PyObject * module,PyObject * arg)424 math_isnan(PyObject *module, PyObject *arg)
425 {
426 PyObject *return_value = NULL;
427 double x;
428
429 if (!PyArg_Parse(arg, "d:isnan", &x)) {
430 goto exit;
431 }
432 return_value = math_isnan_impl(module, x);
433
434 exit:
435 return return_value;
436 }
437
438 PyDoc_STRVAR(math_isinf__doc__,
439 "isinf($module, x, /)\n"
440 "--\n"
441 "\n"
442 "Return True if x is a positive or negative infinity, and False otherwise.");
443
444 #define MATH_ISINF_METHODDEF \
445 {"isinf", (PyCFunction)math_isinf, METH_O, math_isinf__doc__},
446
447 static PyObject *
448 math_isinf_impl(PyObject *module, double x);
449
450 static PyObject *
math_isinf(PyObject * module,PyObject * arg)451 math_isinf(PyObject *module, PyObject *arg)
452 {
453 PyObject *return_value = NULL;
454 double x;
455
456 if (!PyArg_Parse(arg, "d:isinf", &x)) {
457 goto exit;
458 }
459 return_value = math_isinf_impl(module, x);
460
461 exit:
462 return return_value;
463 }
464
465 PyDoc_STRVAR(math_isclose__doc__,
466 "isclose($module, /, a, b, *, rel_tol=1e-09, abs_tol=0.0)\n"
467 "--\n"
468 "\n"
469 "Determine whether two floating point numbers are close in value.\n"
470 "\n"
471 " rel_tol\n"
472 " maximum difference for being considered \"close\", relative to the\n"
473 " magnitude of the input values\n"
474 " abs_tol\n"
475 " maximum difference for being considered \"close\", regardless of the\n"
476 " magnitude of the input values\n"
477 "\n"
478 "Return True if a is close in value to b, and False otherwise.\n"
479 "\n"
480 "For the values to be considered close, the difference between them\n"
481 "must be smaller than at least one of the tolerances.\n"
482 "\n"
483 "-inf, inf and NaN behave similarly to the IEEE 754 Standard. That\n"
484 "is, NaN is not close to anything, even itself. inf and -inf are\n"
485 "only close to themselves.");
486
487 #define MATH_ISCLOSE_METHODDEF \
488 {"isclose", (PyCFunction)math_isclose, METH_FASTCALL|METH_KEYWORDS, math_isclose__doc__},
489
490 static int
491 math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
492 double abs_tol);
493
494 static PyObject *
math_isclose(PyObject * module,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)495 math_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
496 {
497 PyObject *return_value = NULL;
498 static const char * const _keywords[] = {"a", "b", "rel_tol", "abs_tol", NULL};
499 static _PyArg_Parser _parser = {"dd|$dd:isclose", _keywords, 0};
500 double a;
501 double b;
502 double rel_tol = 1e-09;
503 double abs_tol = 0.0;
504 int _return_value;
505
506 if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
507 &a, &b, &rel_tol, &abs_tol)) {
508 goto exit;
509 }
510 _return_value = math_isclose_impl(module, a, b, rel_tol, abs_tol);
511 if ((_return_value == -1) && PyErr_Occurred()) {
512 goto exit;
513 }
514 return_value = PyBool_FromLong((long)_return_value);
515
516 exit:
517 return return_value;
518 }
519 /*[clinic end generated code: output=e554bad553045546 input=a9049054013a1b77]*/
520