}
#endif
+/*[clinic input]
+_decimal.Context.Etiny
+
+Return a value equal to Emin - prec + 1.
+
+This is the minimum exponent value for subnormal results. When
+underflow occurs, the exponent is set to Etiny.
+[clinic start generated code]*/
+
static PyObject *
-context_getetiny(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Context_Etiny_impl(PyObject *self)
+/*[clinic end generated code: output=c9a4a1a3e3575289 input=1274040f303f2244]*/
{
return PyLong_FromSsize_t(mpd_etiny(CTX(self)));
}
+/*[clinic input]
+_decimal.Context.Etop
+
+Return a value equal to Emax - prec + 1.
+
+This is the maximum exponent if the _clamp field of the context is set
+to 1 (IEEE clamp mode). Etop() must not be negative.
+[clinic start generated code]*/
+
static PyObject *
-context_getetop(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Context_Etop_impl(PyObject *self)
+/*[clinic end generated code: output=f0a3f6e1b829074e input=838a4409316ec728]*/
{
return PyLong_FromSsize_t(mpd_etop(CTX(self)));
}
}
}
+/*[clinic input]
+@classmethod
+_decimal.Decimal.__new__ as dec_new
+
+ value: object(c_default="NULL") = "0"
+ context: object = None
+
+Construct a new Decimal object.
+
+value can be an integer, string, tuple, or another Decimal object. If
+no value is given, return Decimal('0'). The context does not affect
+the conversion and is only passed to determine if the InvalidOperation
+trap is active.
+[clinic start generated code]*/
+
static PyObject *
-dec_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+dec_new_impl(PyTypeObject *type, PyObject *value, PyObject *context)
+/*[clinic end generated code: output=35f48a40c65625ba input=5f8a0892d3fcef80]*/
{
- static char *kwlist[] = {"value", "context", NULL};
- PyObject *v = NULL;
- PyObject *context = Py_None;
-
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
- &v, &context)) {
- return NULL;
- }
decimal_state *state = get_module_state_by_def(type);
CONTEXT_CHECK_VA(state, context);
- return PyDecType_FromObjectExact(type, v, context);
+ return PyDecType_FromObjectExact(type, value, context);
}
static PyObject *
return f;
}
+/*[clinic input]
+_decimal.Decimal.__round__
+
+ ndigits: object = NULL
+ /
+
+Return the Integral closest to self, rounding half toward even.
+[clinic start generated code]*/
+
static PyObject *
-PyDec_Round(PyObject *dec, PyObject *args)
+_decimal_Decimal___round___impl(PyObject *self, PyObject *ndigits)
+/*[clinic end generated code: output=ca6b3570a8df0c91 input=dc72084114f59380]*/
{
PyObject *result;
- PyObject *x = NULL;
uint32_t status = 0;
PyObject *context;
-
- decimal_state *state = get_module_state_by_def(Py_TYPE(dec));
+ decimal_state *state = get_module_state_by_def(Py_TYPE(self));
CURRENT_CONTEXT(state, context);
- if (!PyArg_ParseTuple(args, "|O", &x)) {
- return NULL;
- }
-
- if (x) {
+ if (ndigits) {
mpd_uint_t dq[1] = {1};
mpd_t q = {MPD_STATIC|MPD_CONST_DATA,0,1,1,1,dq};
mpd_ssize_t y;
- if (!PyLong_Check(x)) {
+ if (!PyLong_Check(ndigits)) {
PyErr_SetString(PyExc_TypeError,
"optional arg must be an integer");
return NULL;
}
- y = PyLong_AsSsize_t(x);
+ y = PyLong_AsSsize_t(ndigits);
if (y == -1 && PyErr_Occurred()) {
return NULL;
}
}
q.exp = (y == MPD_SSIZE_MIN) ? MPD_SSIZE_MAX : -y;
- mpd_qquantize(MPD(result), MPD(dec), &q, CTX(context), &status);
+ mpd_qquantize(MPD(result), MPD(self), &q, CTX(context), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
return result;
}
else {
- return dec_as_long(dec, context, MPD_ROUND_HALF_EVEN);
+ return dec_as_long(self, context, MPD_ROUND_HALF_EVEN);
}
}
return PyBool_FromLong(r);
}
-/* __ceil__ */
+/*[clinic input]
+_decimal.Decimal.__ceil__
+
+Return the ceiling as an Integral.
+[clinic start generated code]*/
+
static PyObject *
-dec_ceil(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___ceil___impl(PyObject *self)
+/*[clinic end generated code: output=e755a6fb7bceac19 input=4a18ef307ac57da0]*/
{
PyObject *context;
return dec_as_long(self, context, MPD_ROUND_CEILING);
}
-/* __complex__ */
+/*[clinic input]
+_decimal.Decimal.__complex__
+
+Convert this value to exact type complex.
+[clinic start generated code]*/
+
static PyObject *
-dec_complex(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___complex___impl(PyObject *self)
+/*[clinic end generated code: output=c9b5b4a9fdebc912 input=6b11c6f20af7061a]*/
{
PyObject *f;
double x;
return PyComplex_FromDoubles(x, 0);
}
-/* __copy__ (METH_NOARGS) and __deepcopy__ (METH_O) */
+/*[clinic input]
+_decimal.Decimal.__copy__
+
+[clinic start generated code]*/
+
+static PyObject *
+_decimal_Decimal___copy___impl(PyObject *self)
+/*[clinic end generated code: output=8eb3656c0250762b input=3dfd30a3e1493c01]*/
+{
+ return Py_NewRef(self);
+}
+
+/*[clinic input]
+_decimal.Decimal.__deepcopy__
+
+ memo: object
+ /
+
+[clinic start generated code]*/
+
static PyObject *
-dec_copy(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___deepcopy__(PyObject *self, PyObject *memo)
+/*[clinic end generated code: output=988fb34e0136b376 input=f95598c6f43233aa]*/
{
return Py_NewRef(self);
}
-/* __floor__ */
+/*[clinic input]
+_decimal.Decimal.__floor__
+
+Return the floor as an Integral.
+[clinic start generated code]*/
+
static PyObject *
-dec_floor(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___floor___impl(PyObject *self)
+/*[clinic end generated code: output=56767050ac1a1d5a input=cabcc5618564548b]*/
{
PyObject *context;
return self->hash;
}
-/* __reduce__ */
+/*[clinic input]
+_decimal.Decimal.__reduce__
+
+Return state information for pickling.
+[clinic start generated code]*/
+
static PyObject *
-dec_reduce(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___reduce___impl(PyObject *self)
+/*[clinic end generated code: output=84fa6648a496a8d2 input=0345ea951d9b986f]*/
{
PyObject *result, *str;
return result;
}
-/* __sizeof__ */
+/*[clinic input]
+_decimal.Decimal.__sizeof__
+
+ self as v: self
+
+Returns size in memory, in bytes
+[clinic start generated code]*/
+
static PyObject *
-dec_sizeof(PyObject *v, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___sizeof___impl(PyObject *v)
+/*[clinic end generated code: output=f16de05097c62b79 input=a557db538cfddbb7]*/
{
size_t res = _PyObject_SIZE(Py_TYPE(v));
if (mpd_isdynamic_data(MPD(v))) {
return PyLong_FromSize_t(res);
}
-/* __trunc__ */
+/*[clinic input]
+_decimal.Decimal.__trunc__
+
+Return the Integral closest to x between 0 and x.
+[clinic start generated code]*/
+
static PyObject *
-dec_trunc(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___trunc___impl(PyObject *self)
+/*[clinic end generated code: output=9ef59578960f80c0 input=a965a61096dcefeb]*/
{
PyObject *context;
_DECIMAL_DECIMAL_AS_INTEGER_RATIO_METHODDEF
/* Special methods */
- { "__copy__", dec_copy, METH_NOARGS, NULL },
- { "__deepcopy__", dec_copy, METH_O, NULL },
+ _DECIMAL_DECIMAL___COPY___METHODDEF
+ _DECIMAL_DECIMAL___DEEPCOPY___METHODDEF
_DECIMAL_DECIMAL___FORMAT___METHODDEF
- { "__reduce__", dec_reduce, METH_NOARGS, NULL },
- { "__round__", PyDec_Round, METH_VARARGS, NULL },
- { "__ceil__", dec_ceil, METH_NOARGS, NULL },
- { "__floor__", dec_floor, METH_NOARGS, NULL },
- { "__trunc__", dec_trunc, METH_NOARGS, NULL },
- { "__complex__", dec_complex, METH_NOARGS, NULL },
- { "__sizeof__", dec_sizeof, METH_NOARGS, NULL },
+ _DECIMAL_DECIMAL___REDUCE___METHODDEF
+ _DECIMAL_DECIMAL___ROUND___METHODDEF
+ _DECIMAL_DECIMAL___CEIL___METHODDEF
+ _DECIMAL_DECIMAL___FLOOR___METHODDEF
+ _DECIMAL_DECIMAL___TRUNC___METHODDEF
+ _DECIMAL_DECIMAL___COMPLEX___METHODDEF
+ _DECIMAL_DECIMAL___SIZEOF___METHODDEF
{ NULL, NULL, 1 }
};
{Py_tp_repr, dec_repr},
{Py_tp_hash, dec_hash},
{Py_tp_str, dec_str},
- {Py_tp_doc, (void *)doc_decimal},
+ {Py_tp_doc, (void *)dec_new__doc__},
{Py_tp_richcompare, dec_richcompare},
{Py_tp_methods, dec_methods},
{Py_tp_getset, dec_getsets},
DecCtx_TernaryFunc(mpd_qfma)
/* No argument */
+
+/*[clinic input]
+_decimal.Context.radix
+
+ self as context: self
+
+Return 10.
+[clinic start generated code]*/
+
static PyObject *
-ctx_mpd_radix(PyObject *context, PyObject *dummy)
+_decimal_Context_radix_impl(PyObject *context)
+/*[clinic end generated code: output=9218fa309e0fcaa1 input=faeaa5b71f838c38]*/
{
decimal_state *state = get_module_state_from_ctx(context);
return _dec_mpd_radix(state);
{ "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma },
/* No argument */
- { "Etiny", context_getetiny, METH_NOARGS, doc_ctx_Etiny },
- { "Etop", context_getetop, METH_NOARGS, doc_ctx_Etop },
- { "radix", ctx_mpd_radix, METH_NOARGS, doc_ctx_radix },
+ _DECIMAL_CONTEXT_ETINY_METHODDEF
+ _DECIMAL_CONTEXT_ETOP_METHODDEF
+ _DECIMAL_CONTEXT_RADIX_METHODDEF
/* Boolean functions */
{ "is_canonical", ctx_iscanonical, METH_O, doc_ctx_is_canonical },
static struct PyModuleDef _decimal_module = {
PyModuleDef_HEAD_INIT,
.m_name = "decimal",
- .m_doc = doc__decimal,
+ .m_doc = "C decimal arithmetic module",
.m_size = sizeof(decimal_state),
.m_methods = _decimal_methods,
.m_slots = _decimal_slots,
#include "pycore_abstract.h" // _PyNumber_Index()
#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()
+PyDoc_STRVAR(_decimal_Context_Etiny__doc__,
+"Etiny($self, /)\n"
+"--\n"
+"\n"
+"Return a value equal to Emin - prec + 1.\n"
+"\n"
+"This is the minimum exponent value for subnormal results. When\n"
+"underflow occurs, the exponent is set to Etiny.");
+
+#define _DECIMAL_CONTEXT_ETINY_METHODDEF \
+ {"Etiny", (PyCFunction)_decimal_Context_Etiny, METH_NOARGS, _decimal_Context_Etiny__doc__},
+
+static PyObject *
+_decimal_Context_Etiny_impl(PyObject *self);
+
+static PyObject *
+_decimal_Context_Etiny(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Context_Etiny_impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Context_Etop__doc__,
+"Etop($self, /)\n"
+"--\n"
+"\n"
+"Return a value equal to Emax - prec + 1.\n"
+"\n"
+"This is the maximum exponent if the _clamp field of the context is set\n"
+"to 1 (IEEE clamp mode). Etop() must not be negative.");
+
+#define _DECIMAL_CONTEXT_ETOP_METHODDEF \
+ {"Etop", (PyCFunction)_decimal_Context_Etop, METH_NOARGS, _decimal_Context_Etop__doc__},
+
+static PyObject *
+_decimal_Context_Etop_impl(PyObject *self);
+
+static PyObject *
+_decimal_Context_Etop(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Context_Etop_impl(self);
+}
+
PyDoc_STRVAR(_decimal_IEEEContext__doc__,
"IEEEContext($module, bits, /)\n"
"--\n"
return return_value;
}
+PyDoc_STRVAR(dec_new__doc__,
+"Decimal(value=\'0\', context=None)\n"
+"--\n"
+"\n"
+"Construct a new Decimal object.\n"
+"\n"
+"value can be an integer, string, tuple, or another Decimal object. If\n"
+"no value is given, return Decimal(\'0\'). The context does not affect\n"
+"the conversion and is only passed to determine if the InvalidOperation\n"
+"trap is active.");
+
+static PyObject *
+dec_new_impl(PyTypeObject *type, PyObject *value, PyObject *context);
+
+static PyObject *
+dec_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ Py_hash_t ob_hash;
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_hash = -1,
+ .ob_item = { &_Py_ID(value), &_Py_ID(context), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"value", "context", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "Decimal",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
+ PyObject * const *fastargs;
+ Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+ Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
+ PyObject *value = NULL;
+ PyObject *context = Py_None;
+
+ fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
+ /*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
+ if (!fastargs) {
+ goto exit;
+ }
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (fastargs[0]) {
+ value = fastargs[0];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+ context = fastargs[1];
+skip_optional_pos:
+ return_value = dec_new_impl(type, value, context);
+
+exit:
+ return return_value;
+}
+
PyDoc_STRVAR(_decimal_Decimal___format____doc__,
"__format__($self, format_spec, override=<unrepresentable>, /)\n"
"--\n"
return return_value;
}
+PyDoc_STRVAR(_decimal_Decimal___round____doc__,
+"__round__($self, ndigits=<unrepresentable>, /)\n"
+"--\n"
+"\n"
+"Return the Integral closest to self, rounding half toward even.");
+
+#define _DECIMAL_DECIMAL___ROUND___METHODDEF \
+ {"__round__", _PyCFunction_CAST(_decimal_Decimal___round__), METH_FASTCALL, _decimal_Decimal___round____doc__},
+
+static PyObject *
+_decimal_Decimal___round___impl(PyObject *self, PyObject *ndigits);
+
+static PyObject *
+_decimal_Decimal___round__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ PyObject *ndigits = NULL;
+
+ if (!_PyArg_CheckPositional("__round__", nargs, 0, 1)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ ndigits = args[0];
+skip_optional:
+ return_value = _decimal_Decimal___round___impl(self, ndigits);
+
+exit:
+ return return_value;
+}
+
PyDoc_STRVAR(_decimal_Decimal_as_tuple__doc__,
"as_tuple($self, /)\n"
"--\n"
return return_value;
}
+PyDoc_STRVAR(_decimal_Decimal___ceil____doc__,
+"__ceil__($self, /)\n"
+"--\n"
+"\n"
+"Return the ceiling as an Integral.");
+
+#define _DECIMAL_DECIMAL___CEIL___METHODDEF \
+ {"__ceil__", (PyCFunction)_decimal_Decimal___ceil__, METH_NOARGS, _decimal_Decimal___ceil____doc__},
+
+static PyObject *
+_decimal_Decimal___ceil___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___ceil__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___ceil___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___complex____doc__,
+"__complex__($self, /)\n"
+"--\n"
+"\n"
+"Convert this value to exact type complex.");
+
+#define _DECIMAL_DECIMAL___COMPLEX___METHODDEF \
+ {"__complex__", (PyCFunction)_decimal_Decimal___complex__, METH_NOARGS, _decimal_Decimal___complex____doc__},
+
+static PyObject *
+_decimal_Decimal___complex___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___complex__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___complex___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___copy____doc__,
+"__copy__($self, /)\n"
+"--\n"
+"\n");
+
+#define _DECIMAL_DECIMAL___COPY___METHODDEF \
+ {"__copy__", (PyCFunction)_decimal_Decimal___copy__, METH_NOARGS, _decimal_Decimal___copy____doc__},
+
+static PyObject *
+_decimal_Decimal___copy___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___copy__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___copy___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___deepcopy____doc__,
+"__deepcopy__($self, memo, /)\n"
+"--\n"
+"\n");
+
+#define _DECIMAL_DECIMAL___DEEPCOPY___METHODDEF \
+ {"__deepcopy__", (PyCFunction)_decimal_Decimal___deepcopy__, METH_O, _decimal_Decimal___deepcopy____doc__},
+
+PyDoc_STRVAR(_decimal_Decimal___floor____doc__,
+"__floor__($self, /)\n"
+"--\n"
+"\n"
+"Return the floor as an Integral.");
+
+#define _DECIMAL_DECIMAL___FLOOR___METHODDEF \
+ {"__floor__", (PyCFunction)_decimal_Decimal___floor__, METH_NOARGS, _decimal_Decimal___floor____doc__},
+
+static PyObject *
+_decimal_Decimal___floor___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___floor__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___floor___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___reduce____doc__,
+"__reduce__($self, /)\n"
+"--\n"
+"\n"
+"Return state information for pickling.");
+
+#define _DECIMAL_DECIMAL___REDUCE___METHODDEF \
+ {"__reduce__", (PyCFunction)_decimal_Decimal___reduce__, METH_NOARGS, _decimal_Decimal___reduce____doc__},
+
+static PyObject *
+_decimal_Decimal___reduce___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___reduce__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___reduce___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___sizeof____doc__,
+"__sizeof__($self, /)\n"
+"--\n"
+"\n"
+"Returns size in memory, in bytes");
+
+#define _DECIMAL_DECIMAL___SIZEOF___METHODDEF \
+ {"__sizeof__", (PyCFunction)_decimal_Decimal___sizeof__, METH_NOARGS, _decimal_Decimal___sizeof____doc__},
+
+static PyObject *
+_decimal_Decimal___sizeof___impl(PyObject *v);
+
+static PyObject *
+_decimal_Decimal___sizeof__(PyObject *v, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___sizeof___impl(v);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___trunc____doc__,
+"__trunc__($self, /)\n"
+"--\n"
+"\n"
+"Return the Integral closest to x between 0 and x.");
+
+#define _DECIMAL_DECIMAL___TRUNC___METHODDEF \
+ {"__trunc__", (PyCFunction)_decimal_Decimal___trunc__, METH_NOARGS, _decimal_Decimal___trunc____doc__},
+
+static PyObject *
+_decimal_Decimal___trunc___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___trunc__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Decimal___trunc___impl(self);
+}
+
PyDoc_STRVAR(_decimal_Context_power__doc__,
"power($self, /, a, b, modulo=None)\n"
"--\n"
exit:
return return_value;
}
-/*[clinic end generated code: output=9bbde3e723166dd3 input=a9049054013a1b77]*/
+
+PyDoc_STRVAR(_decimal_Context_radix__doc__,
+"radix($self, /)\n"
+"--\n"
+"\n"
+"Return 10.");
+
+#define _DECIMAL_CONTEXT_RADIX_METHODDEF \
+ {"radix", (PyCFunction)_decimal_Context_radix, METH_NOARGS, _decimal_Context_radix__doc__},
+
+static PyObject *
+_decimal_Context_radix_impl(PyObject *context);
+
+static PyObject *
+_decimal_Context_radix(PyObject *context, PyObject *Py_UNUSED(ignored))
+{
+ return _decimal_Context_radix_impl(context);
+}
+/*[clinic end generated code: output=ffc58f98fffed531 input=a9049054013a1b77]*/
#include "pymacro.h"
-
-/******************************************************************************/
-/* Module */
-/******************************************************************************/
-
-
-PyDoc_STRVAR(doc__decimal,
-"C decimal arithmetic module");
-
-/******************************************************************************/
-/* Decimal Object and Methods */
-/******************************************************************************/
-
-PyDoc_STRVAR(doc_decimal,
-"Decimal(value=\"0\", context=None)\n--\n\n\
-Construct a new Decimal object. 'value' can be an integer, string, tuple,\n\
-or another Decimal object. If no value is given, return Decimal('0'). The\n\
-context does not affect the conversion and is only passed to determine if\n\
-the InvalidOperation trap is active.\n\
-\n");
-
-PyDoc_STRVAR(doc_compare_total,
-"compare_total($self, /, other, context=None)\n--\n\n\
-Compare two operands using their abstract representation rather than\n\
-their numerical value. Similar to the compare() method, but the result\n\
-gives a total ordering on Decimal instances. Two Decimal instances with\n\
-the same numeric value but different representations compare unequal\n\
-in this ordering:\n\
-\n\
- >>> Decimal('12.0').compare_total(Decimal('12'))\n\
- Decimal('-1')\n\
-\n\
-Quiet and signaling NaNs are also included in the total ordering. The result\n\
-of this function is Decimal('0') if both operands have the same representation,\n\
-Decimal('-1') if the first operand is lower in the total order than the second,\n\
-and Decimal('1') if the first operand is higher in the total order than the\n\
-second operand. See the specification for details of the total order.\n\
-\n\
-This operation is unaffected by context and is quiet: no flags are changed\n\
-and no rounding is performed. As an exception, the C version may raise\n\
-InvalidOperation if the second operand cannot be converted exactly.\n\
-\n");
-
-PyDoc_STRVAR(doc_compare_total_mag,
-"compare_total_mag($self, /, other, context=None)\n--\n\n\
-Compare two operands using their abstract representation rather than their\n\
-value as in compare_total(), but ignoring the sign of each operand.\n\
-\n\
-x.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).\n\
-\n\
-This operation is unaffected by context and is quiet: no flags are changed\n\
-and no rounding is performed. As an exception, the C version may raise\n\
-InvalidOperation if the second operand cannot be converted exactly.\n\
-\n");
-
PyDoc_STRVAR(doc_is_canonical,
"is_canonical($self, /)\n--\n\n\
Return True if the argument is canonical and False otherwise. Currently,\n\
class method, this function observes the context limits.\n\
\n");
-PyDoc_STRVAR(doc_ctx_Etiny,
-"Etiny($self, /)\n--\n\n\
-Return a value equal to Emin - prec + 1, which is the minimum exponent value\n\
-for subnormal results. When underflow occurs, the exponent is set to Etiny.\n\
-\n");
-
-PyDoc_STRVAR(doc_ctx_Etop,
-"Etop($self, /)\n--\n\n\
-Return a value equal to Emax - prec + 1. This is the maximum exponent\n\
-if the _clamp field of the context is set to 1 (IEEE clamp mode). Etop()\n\
-must not be negative.\n\
-\n");
-
PyDoc_STRVAR(doc_ctx_abs,
"abs($self, x, /)\n--\n\n\
Return the absolute value of x.\n\
Return x multiplied by y, plus z.\n\
\n");
+PyDoc_STRVAR(doc_compare_total,
+"compare_total($self, /, other, context=None)\n--\n\n\
+Compare two operands using their abstract representation rather than\n\
+their numerical value. Similar to the compare() method, but the result\n\
+gives a total ordering on Decimal instances. Two Decimal instances with\n\
+the same numeric value but different representations compare unequal\n\
+in this ordering:\n\
+\n\
+ >>> Decimal('12.0').compare_total(Decimal('12'))\n\
+ Decimal('-1')\n\
+\n\
+Quiet and signaling NaNs are also included in the total ordering. The result\n\
+of this function is Decimal('0') if both operands have the same representation,\n\
+Decimal('-1') if the first operand is lower in the total order than the second,\n\
+and Decimal('1') if the first operand is higher in the total order than the\n\
+second operand. See the specification for details of the total order.\n\
+\n\
+This operation is unaffected by context and is quiet: no flags are changed\n\
+and no rounding is performed. As an exception, the C version may raise\n\
+InvalidOperation if the second operand cannot be converted exactly.\n\
+\n");
+
+PyDoc_STRVAR(doc_compare_total_mag,
+"compare_total_mag($self, /, other, context=None)\n--\n\n\
+Compare two operands using their abstract representation rather than their\n\
+value as in compare_total(), but ignoring the sign of each operand.\n\
+\n\
+x.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).\n\
+\n\
+This operation is unaffected by context and is quiet: no flags are changed\n\
+and no rounding is performed. As an exception, the C version may raise\n\
+InvalidOperation if the second operand cannot be converted exactly.\n\
+\n");
+
PyDoc_STRVAR(doc_ctx_is_canonical,
"is_canonical($self, x, /)\n--\n\n\
Return True if x is canonical, False otherwise.\n\
Return a value equal to x (rounded), having the exponent of y.\n\
\n");
-PyDoc_STRVAR(doc_ctx_radix,
-"radix($self, /)\n--\n\n\
-Return 10.\n\
-\n");
-
PyDoc_STRVAR(doc_ctx_remainder,
"remainder($self, x, y, /)\n--\n\n\
Return the remainder from integer division. The sign of the result,\n\
projects / thirdparty / Python / cpython.git / commitdiff
