Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2001-2012 Python Software Foundation. All Rights Reserved. |
| 3 | * Modified and extended by Stefan Krah. |
| 4 | */ |
| 5 | |
| 6 | |
| 7 | #ifndef DOCSTRINGS_H |
| 8 | #define DOCSTRINGS_H |
| 9 | |
| 10 | |
| 11 | #include "pymacro.h" |
| 12 | |
| 13 | |
| 14 | /******************************************************************************/ |
| 15 | /* Module */ |
| 16 | /******************************************************************************/ |
| 17 | |
| 18 | |
| 19 | PyDoc_STRVAR(doc__decimal, |
| 20 | "C decimal arithmetic module"); |
| 21 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 22 | PyDoc_STRVAR(doc_getcontext, |
| 23 | "getcontext($module, /)\n--\n\n\ |
| 24 | Get the current default context.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 25 | \n"); |
| 26 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 27 | PyDoc_STRVAR(doc_setcontext, |
| 28 | "setcontext($module, context, /)\n--\n\n\ |
| 29 | Set a new default context.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 30 | \n"); |
| 31 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 32 | PyDoc_STRVAR(doc_localcontext, |
| 33 | "localcontext($module, /, ctx=None)\n--\n\n\ |
| 34 | Return a context manager that will set the default context to a copy of ctx\n\ |
| 35 | on entry to the with-statement and restore the previous default context when\n\ |
| 36 | exiting the with-statement. If no context is specified, a copy of the current\n\ |
| 37 | default context is used.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 38 | \n"); |
| 39 | |
| 40 | #ifdef EXTRA_FUNCTIONALITY |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 41 | PyDoc_STRVAR(doc_ieee_context, |
| 42 | "IEEEContext($module, bits, /)\n--\n\n\ |
| 43 | Return a context object initialized to the proper values for one of the\n\ |
| 44 | IEEE interchange formats. The argument must be a multiple of 32 and less\n\ |
| 45 | than IEEE_CONTEXT_MAX_BITS. For the most common values, the constants\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 46 | DECIMAL32, DECIMAL64 and DECIMAL128 are provided.\n\ |
| 47 | \n"); |
| 48 | #endif |
| 49 | |
| 50 | |
| 51 | /******************************************************************************/ |
| 52 | /* Decimal Object and Methods */ |
| 53 | /******************************************************************************/ |
| 54 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 55 | PyDoc_STRVAR(doc_decimal, |
| 56 | "Decimal(value=\"0\", context=None)\n--\n\n\ |
| 57 | Construct a new Decimal object. 'value' can be an integer, string, tuple,\n\ |
| 58 | or another Decimal object. If no value is given, return Decimal('0'). The\n\ |
| 59 | context does not affect the conversion and is only passed to determine if\n\ |
| 60 | the InvalidOperation trap is active.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 61 | \n"); |
| 62 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 63 | PyDoc_STRVAR(doc_adjusted, |
| 64 | "adjusted($self, /)\n--\n\n\ |
| 65 | Return the adjusted exponent of the number. Defined as exp + digits - 1.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 66 | \n"); |
| 67 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 68 | PyDoc_STRVAR(doc_as_tuple, |
| 69 | "as_tuple($self, /)\n--\n\n\ |
| 70 | Return a tuple representation of the number.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 71 | \n"); |
| 72 | |
Stefan Krah | 53f2e0a | 2015-12-28 23:02:02 +0100 | [diff] [blame] | 73 | PyDoc_STRVAR(doc_as_integer_ratio, |
| 74 | "as_integer_ratio($self, /)\n--\n\n\ |
| 75 | Decimal.as_integer_ratio() -> (int, int)\n\ |
| 76 | \n\ |
| 77 | Return a pair of integers, whose ratio is exactly equal to the original\n\ |
| 78 | Decimal and with a positive denominator. The ratio is in lowest terms.\n\ |
| 79 | Raise OverflowError on infinities and a ValueError on NaNs.\n\ |
| 80 | \n"); |
| 81 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 82 | PyDoc_STRVAR(doc_canonical, |
| 83 | "canonical($self, /)\n--\n\n\ |
| 84 | Return the canonical encoding of the argument. Currently, the encoding\n\ |
| 85 | of a Decimal instance is always canonical, so this operation returns its\n\ |
| 86 | argument unchanged.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 87 | \n"); |
| 88 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 89 | PyDoc_STRVAR(doc_compare, |
| 90 | "compare($self, /, other, context=None)\n--\n\n\ |
| 91 | Compare self to other. Return a decimal value:\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 92 | \n\ |
| 93 | a or b is a NaN ==> Decimal('NaN')\n\ |
| 94 | a < b ==> Decimal('-1')\n\ |
| 95 | a == b ==> Decimal('0')\n\ |
| 96 | a > b ==> Decimal('1')\n\ |
| 97 | \n"); |
| 98 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 99 | PyDoc_STRVAR(doc_compare_signal, |
| 100 | "compare_signal($self, /, other, context=None)\n--\n\n\ |
| 101 | Identical to compare, except that all NaNs signal.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 102 | \n"); |
| 103 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 104 | PyDoc_STRVAR(doc_compare_total, |
| 105 | "compare_total($self, /, other, context=None)\n--\n\n\ |
| 106 | Compare two operands using their abstract representation rather than\n\ |
| 107 | their numerical value. Similar to the compare() method, but the result\n\ |
| 108 | gives a total ordering on Decimal instances. Two Decimal instances with\n\ |
| 109 | the same numeric value but different representations compare unequal\n\ |
| 110 | in this ordering:\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 111 | \n\ |
| 112 | >>> Decimal('12.0').compare_total(Decimal('12'))\n\ |
| 113 | Decimal('-1')\n\ |
| 114 | \n\ |
| 115 | Quiet and signaling NaNs are also included in the total ordering. The result\n\ |
| 116 | of this function is Decimal('0') if both operands have the same representation,\n\ |
| 117 | Decimal('-1') if the first operand is lower in the total order than the second,\n\ |
| 118 | and Decimal('1') if the first operand is higher in the total order than the\n\ |
| 119 | second operand. See the specification for details of the total order.\n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 120 | \n\ |
| 121 | This operation is unaffected by context and is quiet: no flags are changed\n\ |
| 122 | and no rounding is performed. As an exception, the C version may raise\n\ |
| 123 | InvalidOperation if the second operand cannot be converted exactly.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 124 | \n"); |
| 125 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 126 | PyDoc_STRVAR(doc_compare_total_mag, |
| 127 | "compare_total_mag($self, /, other, context=None)\n--\n\n\ |
| 128 | Compare two operands using their abstract representation rather than their\n\ |
| 129 | value as in compare_total(), but ignoring the sign of each operand.\n\ |
| 130 | \n\ |
| 131 | x.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).\n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 132 | \n\ |
| 133 | This operation is unaffected by context and is quiet: no flags are changed\n\ |
| 134 | and no rounding is performed. As an exception, the C version may raise\n\ |
| 135 | InvalidOperation if the second operand cannot be converted exactly.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 136 | \n"); |
| 137 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 138 | PyDoc_STRVAR(doc_conjugate, |
| 139 | "conjugate($self, /)\n--\n\n\ |
| 140 | Return self.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 141 | \n"); |
| 142 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 143 | PyDoc_STRVAR(doc_copy_abs, |
| 144 | "copy_abs($self, /)\n--\n\n\ |
| 145 | Return the absolute value of the argument. This operation is unaffected by\n\ |
| 146 | context and is quiet: no flags are changed and no rounding is performed.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 147 | \n"); |
| 148 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 149 | PyDoc_STRVAR(doc_copy_negate, |
| 150 | "copy_negate($self, /)\n--\n\n\ |
| 151 | Return the negation of the argument. This operation is unaffected by context\n\ |
| 152 | and is quiet: no flags are changed and no rounding is performed.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 153 | \n"); |
| 154 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 155 | PyDoc_STRVAR(doc_copy_sign, |
| 156 | "copy_sign($self, /, other, context=None)\n--\n\n\ |
| 157 | Return a copy of the first operand with the sign set to be the same as the\n\ |
| 158 | sign of the second operand. For example:\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 159 | \n\ |
| 160 | >>> Decimal('2.3').copy_sign(Decimal('-1.5'))\n\ |
| 161 | Decimal('-2.3')\n\ |
| 162 | \n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 163 | This operation is unaffected by context and is quiet: no flags are changed\n\ |
| 164 | and no rounding is performed. As an exception, the C version may raise\n\ |
| 165 | InvalidOperation if the second operand cannot be converted exactly.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 166 | \n"); |
| 167 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 168 | PyDoc_STRVAR(doc_exp, |
| 169 | "exp($self, /, context=None)\n--\n\n\ |
| 170 | Return the value of the (natural) exponential function e**x at the given\n\ |
| 171 | number. The function always uses the ROUND_HALF_EVEN mode and the result\n\ |
| 172 | is correctly rounded.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 173 | \n"); |
| 174 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 175 | PyDoc_STRVAR(doc_from_float, |
Stefan Krah | 6b7786b | 2014-05-02 14:34:11 +0200 | [diff] [blame] | 176 | "from_float($type, f, /)\n--\n\n\ |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 177 | Class method that converts a float to a decimal number, exactly.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 178 | Since 0.1 is not exactly representable in binary floating point,\n\ |
| 179 | Decimal.from_float(0.1) is not the same as Decimal('0.1').\n\ |
| 180 | \n\ |
| 181 | >>> Decimal.from_float(0.1)\n\ |
| 182 | Decimal('0.1000000000000000055511151231257827021181583404541015625')\n\ |
| 183 | >>> Decimal.from_float(float('nan'))\n\ |
| 184 | Decimal('NaN')\n\ |
| 185 | >>> Decimal.from_float(float('inf'))\n\ |
| 186 | Decimal('Infinity')\n\ |
| 187 | >>> Decimal.from_float(float('-inf'))\n\ |
| 188 | Decimal('-Infinity')\n\ |
| 189 | \n\ |
| 190 | \n"); |
| 191 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 192 | PyDoc_STRVAR(doc_fma, |
| 193 | "fma($self, /, other, third, context=None)\n--\n\n\ |
| 194 | Fused multiply-add. Return self*other+third with no rounding of the\n\ |
| 195 | intermediate product self*other.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 196 | \n\ |
| 197 | >>> Decimal(2).fma(3, 5)\n\ |
| 198 | Decimal('11')\n\ |
| 199 | \n\ |
| 200 | \n"); |
| 201 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 202 | PyDoc_STRVAR(doc_is_canonical, |
| 203 | "is_canonical($self, /)\n--\n\n\ |
| 204 | Return True if the argument is canonical and False otherwise. Currently,\n\ |
| 205 | a Decimal instance is always canonical, so this operation always returns\n\ |
| 206 | True.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 207 | \n"); |
| 208 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 209 | PyDoc_STRVAR(doc_is_finite, |
| 210 | "is_finite($self, /)\n--\n\n\ |
| 211 | Return True if the argument is a finite number, and False if the argument\n\ |
| 212 | is infinite or a NaN.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 213 | \n"); |
| 214 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 215 | PyDoc_STRVAR(doc_is_infinite, |
| 216 | "is_infinite($self, /)\n--\n\n\ |
| 217 | Return True if the argument is either positive or negative infinity and\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 218 | False otherwise.\n\ |
| 219 | \n"); |
| 220 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 221 | PyDoc_STRVAR(doc_is_nan, |
| 222 | "is_nan($self, /)\n--\n\n\ |
| 223 | Return True if the argument is a (quiet or signaling) NaN and False\n\ |
| 224 | otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 225 | \n"); |
| 226 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 227 | PyDoc_STRVAR(doc_is_normal, |
| 228 | "is_normal($self, /, context=None)\n--\n\n\ |
| 229 | Return True if the argument is a normal finite non-zero number with an\n\ |
| 230 | adjusted exponent greater than or equal to Emin. Return False if the\n\ |
| 231 | argument is zero, subnormal, infinite or a NaN.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 232 | \n"); |
| 233 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 234 | PyDoc_STRVAR(doc_is_qnan, |
| 235 | "is_qnan($self, /)\n--\n\n\ |
| 236 | Return True if the argument is a quiet NaN, and False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 237 | \n"); |
| 238 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 239 | PyDoc_STRVAR(doc_is_signed, |
| 240 | "is_signed($self, /)\n--\n\n\ |
| 241 | Return True if the argument has a negative sign and False otherwise.\n\ |
| 242 | Note that both zeros and NaNs can carry signs.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 243 | \n"); |
| 244 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 245 | PyDoc_STRVAR(doc_is_snan, |
| 246 | "is_snan($self, /)\n--\n\n\ |
| 247 | Return True if the argument is a signaling NaN and False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 248 | \n"); |
| 249 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 250 | PyDoc_STRVAR(doc_is_subnormal, |
| 251 | "is_subnormal($self, /, context=None)\n--\n\n\ |
| 252 | Return True if the argument is subnormal, and False otherwise. A number is\n\ |
| 253 | subnormal if it is non-zero, finite, and has an adjusted exponent less\n\ |
| 254 | than Emin.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 255 | \n"); |
| 256 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 257 | PyDoc_STRVAR(doc_is_zero, |
| 258 | "is_zero($self, /)\n--\n\n\ |
| 259 | Return True if the argument is a (positive or negative) zero and False\n\ |
| 260 | otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 261 | \n"); |
| 262 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 263 | PyDoc_STRVAR(doc_ln, |
| 264 | "ln($self, /, context=None)\n--\n\n\ |
| 265 | Return the natural (base e) logarithm of the operand. The function always\n\ |
| 266 | uses the ROUND_HALF_EVEN mode and the result is correctly rounded.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 267 | \n"); |
| 268 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 269 | PyDoc_STRVAR(doc_log10, |
| 270 | "log10($self, /, context=None)\n--\n\n\ |
| 271 | Return the base ten logarithm of the operand. The function always uses the\n\ |
| 272 | ROUND_HALF_EVEN mode and the result is correctly rounded.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 273 | \n"); |
| 274 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 275 | PyDoc_STRVAR(doc_logb, |
| 276 | "logb($self, /, context=None)\n--\n\n\ |
| 277 | For a non-zero number, return the adjusted exponent of the operand as a\n\ |
| 278 | Decimal instance. If the operand is a zero, then Decimal('-Infinity') is\n\ |
| 279 | returned and the DivisionByZero condition is raised. If the operand is\n\ |
| 280 | an infinity then Decimal('Infinity') is returned.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 281 | \n"); |
| 282 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 283 | PyDoc_STRVAR(doc_logical_and, |
| 284 | "logical_and($self, /, other, context=None)\n--\n\n\ |
| 285 | Return the digit-wise 'and' of the two (logical) operands.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 286 | \n"); |
| 287 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 288 | PyDoc_STRVAR(doc_logical_invert, |
| 289 | "logical_invert($self, /, context=None)\n--\n\n\ |
| 290 | Return the digit-wise inversion of the (logical) operand.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 291 | \n"); |
| 292 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 293 | PyDoc_STRVAR(doc_logical_or, |
| 294 | "logical_or($self, /, other, context=None)\n--\n\n\ |
| 295 | Return the digit-wise 'or' of the two (logical) operands.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 296 | \n"); |
| 297 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 298 | PyDoc_STRVAR(doc_logical_xor, |
| 299 | "logical_xor($self, /, other, context=None)\n--\n\n\ |
| 300 | Return the digit-wise 'exclusive or' of the two (logical) operands.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 301 | \n"); |
| 302 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 303 | PyDoc_STRVAR(doc_max, |
| 304 | "max($self, /, other, context=None)\n--\n\n\ |
| 305 | Maximum of self and other. If one operand is a quiet NaN and the other is\n\ |
| 306 | numeric, the numeric operand is returned.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 307 | \n"); |
| 308 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 309 | PyDoc_STRVAR(doc_max_mag, |
| 310 | "max_mag($self, /, other, context=None)\n--\n\n\ |
| 311 | Similar to the max() method, but the comparison is done using the absolute\n\ |
| 312 | values of the operands.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 313 | \n"); |
| 314 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 315 | PyDoc_STRVAR(doc_min, |
| 316 | "min($self, /, other, context=None)\n--\n\n\ |
| 317 | Minimum of self and other. If one operand is a quiet NaN and the other is\n\ |
| 318 | numeric, the numeric operand is returned.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 319 | \n"); |
| 320 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 321 | PyDoc_STRVAR(doc_min_mag, |
| 322 | "min_mag($self, /, other, context=None)\n--\n\n\ |
| 323 | Similar to the min() method, but the comparison is done using the absolute\n\ |
| 324 | values of the operands.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 325 | \n"); |
| 326 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 327 | PyDoc_STRVAR(doc_next_minus, |
| 328 | "next_minus($self, /, context=None)\n--\n\n\ |
| 329 | Return the largest number representable in the given context (or in the\n\ |
| 330 | current default context if no context is given) that is smaller than the\n\ |
| 331 | given operand.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 332 | \n"); |
| 333 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 334 | PyDoc_STRVAR(doc_next_plus, |
| 335 | "next_plus($self, /, context=None)\n--\n\n\ |
| 336 | Return the smallest number representable in the given context (or in the\n\ |
| 337 | current default context if no context is given) that is larger than the\n\ |
| 338 | given operand.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 339 | \n"); |
| 340 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 341 | PyDoc_STRVAR(doc_next_toward, |
| 342 | "next_toward($self, /, other, context=None)\n--\n\n\ |
| 343 | If the two operands are unequal, return the number closest to the first\n\ |
| 344 | operand in the direction of the second operand. If both operands are\n\ |
| 345 | numerically equal, return a copy of the first operand with the sign set\n\ |
| 346 | to be the same as the sign of the second operand.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 347 | \n"); |
| 348 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 349 | PyDoc_STRVAR(doc_normalize, |
| 350 | "normalize($self, /, context=None)\n--\n\n\ |
| 351 | Normalize the number by stripping the rightmost trailing zeros and\n\ |
| 352 | converting any result equal to Decimal('0') to Decimal('0e0'). Used\n\ |
| 353 | for producing canonical values for members of an equivalence class.\n\ |
| 354 | For example, Decimal('32.100') and Decimal('0.321000e+2') both normalize\n\ |
| 355 | to the equivalent value Decimal('32.1').\n\ |
| 356 | \n"); |
| 357 | |
| 358 | PyDoc_STRVAR(doc_number_class, |
| 359 | "number_class($self, /, context=None)\n--\n\n\ |
| 360 | Return a string describing the class of the operand. The returned value\n\ |
| 361 | is one of the following ten strings:\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 362 | \n\ |
| 363 | * '-Infinity', indicating that the operand is negative infinity.\n\ |
| 364 | * '-Normal', indicating that the operand is a negative normal number.\n\ |
| 365 | * '-Subnormal', indicating that the operand is negative and subnormal.\n\ |
| 366 | * '-Zero', indicating that the operand is a negative zero.\n\ |
| 367 | * '+Zero', indicating that the operand is a positive zero.\n\ |
| 368 | * '+Subnormal', indicating that the operand is positive and subnormal.\n\ |
| 369 | * '+Normal', indicating that the operand is a positive normal number.\n\ |
| 370 | * '+Infinity', indicating that the operand is positive infinity.\n\ |
| 371 | * 'NaN', indicating that the operand is a quiet NaN (Not a Number).\n\ |
| 372 | * 'sNaN', indicating that the operand is a signaling NaN.\n\ |
| 373 | \n\ |
| 374 | \n"); |
| 375 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 376 | PyDoc_STRVAR(doc_quantize, |
| 377 | "quantize($self, /, exp, rounding=None, context=None)\n--\n\n\ |
| 378 | Return a value equal to the first operand after rounding and having the\n\ |
| 379 | exponent of the second operand.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 380 | \n\ |
| 381 | >>> Decimal('1.41421356').quantize(Decimal('1.000'))\n\ |
| 382 | Decimal('1.414')\n\ |
| 383 | \n\ |
| 384 | Unlike other operations, if the length of the coefficient after the quantize\n\ |
| 385 | operation would be greater than precision, then an InvalidOperation is signaled.\n\ |
| 386 | This guarantees that, unless there is an error condition, the quantized exponent\n\ |
| 387 | is always equal to that of the right-hand operand.\n\ |
| 388 | \n\ |
| 389 | Also unlike other operations, quantize never signals Underflow, even if the\n\ |
| 390 | result is subnormal and inexact.\n\ |
| 391 | \n\ |
| 392 | If the exponent of the second operand is larger than that of the first, then\n\ |
| 393 | rounding may be necessary. In this case, the rounding mode is determined by the\n\ |
| 394 | rounding argument if given, else by the given context argument; if neither\n\ |
| 395 | argument is given, the rounding mode of the current thread's context is used.\n\ |
| 396 | \n"); |
| 397 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 398 | PyDoc_STRVAR(doc_radix, |
| 399 | "radix($self, /)\n--\n\n\ |
| 400 | Return Decimal(10), the radix (base) in which the Decimal class does\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 401 | all its arithmetic. Included for compatibility with the specification.\n\ |
| 402 | \n"); |
| 403 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 404 | PyDoc_STRVAR(doc_remainder_near, |
| 405 | "remainder_near($self, /, other, context=None)\n--\n\n\ |
| 406 | Return the remainder from dividing self by other. This differs from\n\ |
| 407 | self % other in that the sign of the remainder is chosen so as to minimize\n\ |
| 408 | its absolute value. More precisely, the return value is self - n * other\n\ |
| 409 | where n is the integer nearest to the exact value of self / other, and\n\ |
| 410 | if two integers are equally near then the even one is chosen.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 411 | \n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 412 | If the result is zero then its sign will be the sign of self.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 413 | \n"); |
| 414 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 415 | PyDoc_STRVAR(doc_rotate, |
| 416 | "rotate($self, /, other, context=None)\n--\n\n\ |
| 417 | Return the result of rotating the digits of the first operand by an amount\n\ |
| 418 | specified by the second operand. The second operand must be an integer in\n\ |
| 419 | the range -precision through precision. The absolute value of the second\n\ |
| 420 | operand gives the number of places to rotate. If the second operand is\n\ |
| 421 | positive then rotation is to the left; otherwise rotation is to the right.\n\ |
| 422 | The coefficient of the first operand is padded on the left with zeros to\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 423 | length precision if necessary. The sign and exponent of the first operand are\n\ |
| 424 | unchanged.\n\ |
| 425 | \n"); |
| 426 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 427 | PyDoc_STRVAR(doc_same_quantum, |
| 428 | "same_quantum($self, /, other, context=None)\n--\n\n\ |
| 429 | Test whether self and other have the same exponent or whether both are NaN.\n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 430 | \n\ |
| 431 | This operation is unaffected by context and is quiet: no flags are changed\n\ |
| 432 | and no rounding is performed. As an exception, the C version may raise\n\ |
| 433 | InvalidOperation if the second operand cannot be converted exactly.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 434 | \n"); |
| 435 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 436 | PyDoc_STRVAR(doc_scaleb, |
| 437 | "scaleb($self, /, other, context=None)\n--\n\n\ |
| 438 | Return the first operand with the exponent adjusted the second. Equivalently,\n\ |
| 439 | return the first operand multiplied by 10**other. The second operand must be\n\ |
| 440 | an integer.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 441 | \n"); |
| 442 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 443 | PyDoc_STRVAR(doc_shift, |
| 444 | "shift($self, /, other, context=None)\n--\n\n\ |
| 445 | Return the result of shifting the digits of the first operand by an amount\n\ |
| 446 | specified by the second operand. The second operand must be an integer in\n\ |
| 447 | the range -precision through precision. The absolute value of the second\n\ |
| 448 | operand gives the number of places to shift. If the second operand is\n\ |
| 449 | positive, then the shift is to the left; otherwise the shift is to the\n\ |
| 450 | right. Digits shifted into the coefficient are zeros. The sign and exponent\n\ |
| 451 | of the first operand are unchanged.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 452 | \n"); |
| 453 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 454 | PyDoc_STRVAR(doc_sqrt, |
| 455 | "sqrt($self, /, context=None)\n--\n\n\ |
| 456 | Return the square root of the argument to full precision. The result is\n\ |
| 457 | correctly rounded using the ROUND_HALF_EVEN rounding mode.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 458 | \n"); |
| 459 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 460 | PyDoc_STRVAR(doc_to_eng_string, |
| 461 | "to_eng_string($self, /, context=None)\n--\n\n\ |
| 462 | Convert to an engineering-type string. Engineering notation has an exponent\n\ |
| 463 | which is a multiple of 3, so there are up to 3 digits left of the decimal\n\ |
| 464 | place. For example, Decimal('123E+1') is converted to Decimal('1.23E+3').\n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 465 | \n\ |
| 466 | The value of context.capitals determines whether the exponent sign is lower\n\ |
| 467 | or upper case. Otherwise, the context does not affect the operation.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 468 | \n"); |
| 469 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 470 | PyDoc_STRVAR(doc_to_integral, |
| 471 | "to_integral($self, /, rounding=None, context=None)\n--\n\n\ |
| 472 | Identical to the to_integral_value() method. The to_integral() name has been\n\ |
| 473 | kept for compatibility with older versions.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 474 | \n"); |
| 475 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 476 | PyDoc_STRVAR(doc_to_integral_exact, |
| 477 | "to_integral_exact($self, /, rounding=None, context=None)\n--\n\n\ |
| 478 | Round to the nearest integer, signaling Inexact or Rounded as appropriate if\n\ |
| 479 | rounding occurs. The rounding mode is determined by the rounding parameter\n\ |
| 480 | if given, else by the given context. If neither parameter is given, then the\n\ |
| 481 | rounding mode of the current default context is used.\n\ |
| 482 | \n"); |
| 483 | |
| 484 | PyDoc_STRVAR(doc_to_integral_value, |
| 485 | "to_integral_value($self, /, rounding=None, context=None)\n--\n\n\ |
| 486 | Round to the nearest integer without signaling Inexact or Rounded. The\n\ |
| 487 | rounding mode is determined by the rounding parameter if given, else by\n\ |
| 488 | the given context. If neither parameter is given, then the rounding mode\n\ |
Stefan Krah | 040e311 | 2012-12-15 22:33:33 +0100 | [diff] [blame] | 489 | of the current default context is used.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 490 | \n"); |
| 491 | |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 492 | |
| 493 | /******************************************************************************/ |
| 494 | /* Context Object and Methods */ |
| 495 | /******************************************************************************/ |
| 496 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 497 | PyDoc_STRVAR(doc_context, |
| 498 | "Context(prec=None, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None)\n--\n\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 499 | The context affects almost all operations and controls rounding,\n\ |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 500 | Over/Underflow, raising of exceptions and much more. A new context\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 501 | can be constructed as follows:\n\ |
| 502 | \n\ |
| 503 | >>> c = Context(prec=28, Emin=-425000000, Emax=425000000,\n\ |
| 504 | ... rounding=ROUND_HALF_EVEN, capitals=1, clamp=1,\n\ |
| 505 | ... traps=[InvalidOperation, DivisionByZero, Overflow],\n\ |
| 506 | ... flags=[])\n\ |
| 507 | >>>\n\ |
| 508 | \n\ |
| 509 | \n"); |
| 510 | |
| 511 | #ifdef EXTRA_FUNCTIONALITY |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 512 | PyDoc_STRVAR(doc_ctx_apply, |
| 513 | "apply($self, x, /)\n--\n\n\ |
| 514 | Apply self to Decimal x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 515 | \n"); |
| 516 | #endif |
| 517 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 518 | PyDoc_STRVAR(doc_ctx_clear_flags, |
| 519 | "clear_flags($self, /)\n--\n\n\ |
| 520 | Reset all flags to False.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 521 | \n"); |
| 522 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 523 | PyDoc_STRVAR(doc_ctx_clear_traps, |
| 524 | "clear_traps($self, /)\n--\n\n\ |
| 525 | Set all traps to False.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 526 | \n"); |
| 527 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 528 | PyDoc_STRVAR(doc_ctx_copy, |
| 529 | "copy($self, /)\n--\n\n\ |
| 530 | Return a duplicate of the context with all flags cleared.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 531 | \n"); |
| 532 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 533 | PyDoc_STRVAR(doc_ctx_copy_decimal, |
| 534 | "copy_decimal($self, x, /)\n--\n\n\ |
| 535 | Return a copy of Decimal x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 536 | \n"); |
| 537 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 538 | PyDoc_STRVAR(doc_ctx_create_decimal, |
| 539 | "create_decimal($self, num=\"0\", /)\n--\n\n\ |
| 540 | Create a new Decimal instance from num, using self as the context. Unlike the\n\ |
| 541 | Decimal constructor, this function observes the context limits.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 542 | \n"); |
| 543 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 544 | PyDoc_STRVAR(doc_ctx_create_decimal_from_float, |
| 545 | "create_decimal_from_float($self, f, /)\n--\n\n\ |
| 546 | Create a new Decimal instance from float f. Unlike the Decimal.from_float()\n\ |
| 547 | class method, this function observes the context limits.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 548 | \n"); |
| 549 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 550 | PyDoc_STRVAR(doc_ctx_Etiny, |
| 551 | "Etiny($self, /)\n--\n\n\ |
| 552 | Return a value equal to Emin - prec + 1, which is the minimum exponent value\n\ |
| 553 | for subnormal results. When underflow occurs, the exponent is set to Etiny.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 554 | \n"); |
| 555 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 556 | PyDoc_STRVAR(doc_ctx_Etop, |
| 557 | "Etop($self, /)\n--\n\n\ |
| 558 | Return a value equal to Emax - prec + 1. This is the maximum exponent\n\ |
| 559 | if the _clamp field of the context is set to 1 (IEEE clamp mode). Etop()\n\ |
| 560 | must not be negative.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 561 | \n"); |
| 562 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 563 | PyDoc_STRVAR(doc_ctx_abs, |
| 564 | "abs($self, x, /)\n--\n\n\ |
| 565 | Return the absolute value of x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 566 | \n"); |
| 567 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 568 | PyDoc_STRVAR(doc_ctx_add, |
| 569 | "add($self, x, y, /)\n--\n\n\ |
| 570 | Return the sum of x and y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 571 | \n"); |
| 572 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 573 | PyDoc_STRVAR(doc_ctx_canonical, |
| 574 | "canonical($self, x, /)\n--\n\n\ |
| 575 | Return a new instance of x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 576 | \n"); |
| 577 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 578 | PyDoc_STRVAR(doc_ctx_compare, |
| 579 | "compare($self, x, y, /)\n--\n\n\ |
| 580 | Compare x and y numerically.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 581 | \n"); |
| 582 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 583 | PyDoc_STRVAR(doc_ctx_compare_signal, |
| 584 | "compare_signal($self, x, y, /)\n--\n\n\ |
| 585 | Compare x and y numerically. All NaNs signal.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 586 | \n"); |
| 587 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 588 | PyDoc_STRVAR(doc_ctx_compare_total, |
| 589 | "compare_total($self, x, y, /)\n--\n\n\ |
| 590 | Compare x and y using their abstract representation.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 591 | \n"); |
| 592 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 593 | PyDoc_STRVAR(doc_ctx_compare_total_mag, |
| 594 | "compare_total_mag($self, x, y, /)\n--\n\n\ |
| 595 | Compare x and y using their abstract representation, ignoring sign.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 596 | \n"); |
| 597 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 598 | PyDoc_STRVAR(doc_ctx_copy_abs, |
| 599 | "copy_abs($self, x, /)\n--\n\n\ |
| 600 | Return a copy of x with the sign set to 0.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 601 | \n"); |
| 602 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 603 | PyDoc_STRVAR(doc_ctx_copy_negate, |
| 604 | "copy_negate($self, x, /)\n--\n\n\ |
| 605 | Return a copy of x with the sign inverted.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 606 | \n"); |
| 607 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 608 | PyDoc_STRVAR(doc_ctx_copy_sign, |
| 609 | "copy_sign($self, x, y, /)\n--\n\n\ |
| 610 | Copy the sign from y to x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 611 | \n"); |
| 612 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 613 | PyDoc_STRVAR(doc_ctx_divide, |
| 614 | "divide($self, x, y, /)\n--\n\n\ |
| 615 | Return x divided by y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 616 | \n"); |
| 617 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 618 | PyDoc_STRVAR(doc_ctx_divide_int, |
| 619 | "divide_int($self, x, y, /)\n--\n\n\ |
| 620 | Return x divided by y, truncated to an integer.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 621 | \n"); |
| 622 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 623 | PyDoc_STRVAR(doc_ctx_divmod, |
| 624 | "divmod($self, x, y, /)\n--\n\n\ |
| 625 | Return quotient and remainder of the division x / y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 626 | \n"); |
| 627 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 628 | PyDoc_STRVAR(doc_ctx_exp, |
| 629 | "exp($self, x, /)\n--\n\n\ |
| 630 | Return e ** x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 631 | \n"); |
| 632 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 633 | PyDoc_STRVAR(doc_ctx_fma, |
| 634 | "fma($self, x, y, z, /)\n--\n\n\ |
| 635 | Return x multiplied by y, plus z.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 636 | \n"); |
| 637 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 638 | PyDoc_STRVAR(doc_ctx_is_canonical, |
| 639 | "is_canonical($self, x, /)\n--\n\n\ |
| 640 | Return True if x is canonical, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 641 | \n"); |
| 642 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 643 | PyDoc_STRVAR(doc_ctx_is_finite, |
| 644 | "is_finite($self, x, /)\n--\n\n\ |
| 645 | Return True if x is finite, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 646 | \n"); |
| 647 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 648 | PyDoc_STRVAR(doc_ctx_is_infinite, |
| 649 | "is_infinite($self, x, /)\n--\n\n\ |
| 650 | Return True if x is infinite, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 651 | \n"); |
| 652 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 653 | PyDoc_STRVAR(doc_ctx_is_nan, |
| 654 | "is_nan($self, x, /)\n--\n\n\ |
| 655 | Return True if x is a qNaN or sNaN, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 656 | \n"); |
| 657 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 658 | PyDoc_STRVAR(doc_ctx_is_normal, |
| 659 | "is_normal($self, x, /)\n--\n\n\ |
| 660 | Return True if x is a normal number, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 661 | \n"); |
| 662 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 663 | PyDoc_STRVAR(doc_ctx_is_qnan, |
| 664 | "is_qnan($self, x, /)\n--\n\n\ |
| 665 | Return True if x is a quiet NaN, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 666 | \n"); |
| 667 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 668 | PyDoc_STRVAR(doc_ctx_is_signed, |
| 669 | "is_signed($self, x, /)\n--\n\n\ |
| 670 | Return True if x is negative, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 671 | \n"); |
| 672 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 673 | PyDoc_STRVAR(doc_ctx_is_snan, |
| 674 | "is_snan($self, x, /)\n--\n\n\ |
| 675 | Return True if x is a signaling NaN, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 676 | \n"); |
| 677 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 678 | PyDoc_STRVAR(doc_ctx_is_subnormal, |
| 679 | "is_subnormal($self, x, /)\n--\n\n\ |
| 680 | Return True if x is subnormal, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 681 | \n"); |
| 682 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 683 | PyDoc_STRVAR(doc_ctx_is_zero, |
| 684 | "is_zero($self, x, /)\n--\n\n\ |
| 685 | Return True if x is a zero, False otherwise.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 686 | \n"); |
| 687 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 688 | PyDoc_STRVAR(doc_ctx_ln, |
| 689 | "ln($self, x, /)\n--\n\n\ |
| 690 | Return the natural (base e) logarithm of x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 691 | \n"); |
| 692 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 693 | PyDoc_STRVAR(doc_ctx_log10, |
| 694 | "log10($self, x, /)\n--\n\n\ |
| 695 | Return the base 10 logarithm of x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 696 | \n"); |
| 697 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 698 | PyDoc_STRVAR(doc_ctx_logb, |
| 699 | "logb($self, x, /)\n--\n\n\ |
| 700 | Return the exponent of the magnitude of the operand's MSD.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 701 | \n"); |
| 702 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 703 | PyDoc_STRVAR(doc_ctx_logical_and, |
| 704 | "logical_and($self, x, y, /)\n--\n\n\ |
| 705 | Digit-wise and of x and y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 706 | \n"); |
| 707 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 708 | PyDoc_STRVAR(doc_ctx_logical_invert, |
| 709 | "logical_invert($self, x, /)\n--\n\n\ |
| 710 | Invert all digits of x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 711 | \n"); |
| 712 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 713 | PyDoc_STRVAR(doc_ctx_logical_or, |
| 714 | "logical_or($self, x, y, /)\n--\n\n\ |
| 715 | Digit-wise or of x and y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 716 | \n"); |
| 717 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 718 | PyDoc_STRVAR(doc_ctx_logical_xor, |
| 719 | "logical_xor($self, x, y, /)\n--\n\n\ |
| 720 | Digit-wise xor of x and y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 721 | \n"); |
| 722 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 723 | PyDoc_STRVAR(doc_ctx_max, |
| 724 | "max($self, x, y, /)\n--\n\n\ |
| 725 | Compare the values numerically and return the maximum.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 726 | \n"); |
| 727 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 728 | PyDoc_STRVAR(doc_ctx_max_mag, |
| 729 | "max_mag($self, x, y, /)\n--\n\n\ |
| 730 | Compare the values numerically with their sign ignored.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 731 | \n"); |
| 732 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 733 | PyDoc_STRVAR(doc_ctx_min, |
| 734 | "min($self, x, y, /)\n--\n\n\ |
| 735 | Compare the values numerically and return the minimum.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 736 | \n"); |
| 737 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 738 | PyDoc_STRVAR(doc_ctx_min_mag, |
| 739 | "min_mag($self, x, y, /)\n--\n\n\ |
| 740 | Compare the values numerically with their sign ignored.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 741 | \n"); |
| 742 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 743 | PyDoc_STRVAR(doc_ctx_minus, |
| 744 | "minus($self, x, /)\n--\n\n\ |
| 745 | Minus corresponds to the unary prefix minus operator in Python, but applies\n\ |
| 746 | the context to the result.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 747 | \n"); |
| 748 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 749 | PyDoc_STRVAR(doc_ctx_multiply, |
| 750 | "multiply($self, x, y, /)\n--\n\n\ |
| 751 | Return the product of x and y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 752 | \n"); |
| 753 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 754 | PyDoc_STRVAR(doc_ctx_next_minus, |
| 755 | "next_minus($self, x, /)\n--\n\n\ |
| 756 | Return the largest representable number smaller than x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 757 | \n"); |
| 758 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 759 | PyDoc_STRVAR(doc_ctx_next_plus, |
| 760 | "next_plus($self, x, /)\n--\n\n\ |
| 761 | Return the smallest representable number larger than x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 762 | \n"); |
| 763 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 764 | PyDoc_STRVAR(doc_ctx_next_toward, |
| 765 | "next_toward($self, x, y, /)\n--\n\n\ |
| 766 | Return the number closest to x, in the direction towards y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 767 | \n"); |
| 768 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 769 | PyDoc_STRVAR(doc_ctx_normalize, |
| 770 | "normalize($self, x, /)\n--\n\n\ |
| 771 | Reduce x to its simplest form. Alias for reduce(x).\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 772 | \n"); |
| 773 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 774 | PyDoc_STRVAR(doc_ctx_number_class, |
| 775 | "number_class($self, x, /)\n--\n\n\ |
| 776 | Return an indication of the class of x.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 777 | \n"); |
| 778 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 779 | PyDoc_STRVAR(doc_ctx_plus, |
| 780 | "plus($self, x, /)\n--\n\n\ |
| 781 | Plus corresponds to the unary prefix plus operator in Python, but applies\n\ |
| 782 | the context to the result.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 783 | \n"); |
| 784 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 785 | PyDoc_STRVAR(doc_ctx_power, |
| 786 | "power($self, /, a, b, modulo=None)\n--\n\n\ |
| 787 | Compute a**b. If 'a' is negative, then 'b' must be integral. The result\n\ |
| 788 | will be inexact unless 'a' is integral and the result is finite and can\n\ |
| 789 | be expressed exactly in 'precision' digits. In the Python version the\n\ |
| 790 | result is always correctly rounded, in the C version the result is almost\n\ |
| 791 | always correctly rounded.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 792 | \n\ |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 793 | If modulo is given, compute (a**b) % modulo. The following restrictions\n\ |
| 794 | hold:\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 795 | \n\ |
| 796 | * all three arguments must be integral\n\ |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 797 | * 'b' must be nonnegative\n\ |
| 798 | * at least one of 'a' or 'b' must be nonzero\n\ |
| 799 | * modulo must be nonzero and less than 10**prec in absolute value\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 800 | \n\ |
| 801 | \n"); |
| 802 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 803 | PyDoc_STRVAR(doc_ctx_quantize, |
| 804 | "quantize($self, x, y, /)\n--\n\n\ |
| 805 | Return a value equal to x (rounded), having the exponent of y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 806 | \n"); |
| 807 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 808 | PyDoc_STRVAR(doc_ctx_radix, |
| 809 | "radix($self, /)\n--\n\n\ |
| 810 | Return 10.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 811 | \n"); |
| 812 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 813 | PyDoc_STRVAR(doc_ctx_remainder, |
| 814 | "remainder($self, x, y, /)\n--\n\n\ |
| 815 | Return the remainder from integer division. The sign of the result,\n\ |
| 816 | if non-zero, is the same as that of the original dividend.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 817 | \n"); |
| 818 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 819 | PyDoc_STRVAR(doc_ctx_remainder_near, |
| 820 | "remainder_near($self, x, y, /)\n--\n\n\ |
| 821 | Return x - y * n, where n is the integer nearest the exact value of x / y\n\ |
| 822 | (if the result is 0 then its sign will be the sign of x).\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 823 | \n"); |
| 824 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 825 | PyDoc_STRVAR(doc_ctx_rotate, |
| 826 | "rotate($self, x, y, /)\n--\n\n\ |
| 827 | Return a copy of x, rotated by y places.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 828 | \n"); |
| 829 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 830 | PyDoc_STRVAR(doc_ctx_same_quantum, |
| 831 | "same_quantum($self, x, y, /)\n--\n\n\ |
| 832 | Return True if the two operands have the same exponent.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 833 | \n"); |
| 834 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 835 | PyDoc_STRVAR(doc_ctx_scaleb, |
| 836 | "scaleb($self, x, y, /)\n--\n\n\ |
| 837 | Return the first operand after adding the second value to its exp.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 838 | \n"); |
| 839 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 840 | PyDoc_STRVAR(doc_ctx_shift, |
| 841 | "shift($self, x, y, /)\n--\n\n\ |
| 842 | Return a copy of x, shifted by y places.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 843 | \n"); |
| 844 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 845 | PyDoc_STRVAR(doc_ctx_sqrt, |
| 846 | "sqrt($self, x, /)\n--\n\n\ |
| 847 | Square root of a non-negative number to context precision.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 848 | \n"); |
| 849 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 850 | PyDoc_STRVAR(doc_ctx_subtract, |
| 851 | "subtract($self, x, y, /)\n--\n\n\ |
| 852 | Return the difference between x and y.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 853 | \n"); |
| 854 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 855 | PyDoc_STRVAR(doc_ctx_to_eng_string, |
| 856 | "to_eng_string($self, x, /)\n--\n\n\ |
| 857 | Convert a number to a string, using engineering notation.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 858 | \n"); |
| 859 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 860 | PyDoc_STRVAR(doc_ctx_to_integral, |
| 861 | "to_integral($self, x, /)\n--\n\n\ |
| 862 | Identical to to_integral_value(x).\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 863 | \n"); |
| 864 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 865 | PyDoc_STRVAR(doc_ctx_to_integral_exact, |
| 866 | "to_integral_exact($self, x, /)\n--\n\n\ |
| 867 | Round to an integer. Signal if the result is rounded or inexact.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 868 | \n"); |
| 869 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 870 | PyDoc_STRVAR(doc_ctx_to_integral_value, |
| 871 | "to_integral_value($self, x, /)\n--\n\n\ |
| 872 | Round to an integer.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 873 | \n"); |
| 874 | |
Stefan Krah | 5de1f82 | 2014-05-01 15:53:42 +0200 | [diff] [blame] | 875 | PyDoc_STRVAR(doc_ctx_to_sci_string, |
| 876 | "to_sci_string($self, x, /)\n--\n\n\ |
| 877 | Convert a number to a string using scientific notation.\n\ |
Stefan Krah | 1919b7e | 2012-03-21 18:25:23 +0100 | [diff] [blame] | 878 | \n"); |
| 879 | |
| 880 | |
| 881 | #endif /* DOCSTRINGS_H */ |
| 882 | |
| 883 | |
| 884 | |