{{ message }}
-
Notifications
You must be signed in to change notification settings - Fork 4
Expand file tree
/
Copy pathdecimal.po
More file actions
2380 lines (1993 loc) · 76.5 KB
/
Copy pathdecimal.po
File metadata and controls
2380 lines (1993 loc) · 76.5 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# Vladimir, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-01 17:31+0000\n"
"PO-Revision-Date: 2025-09-16 00:01+0000\n"
"Last-Translator: Vladimir, 2025\n"
"Language-Team: Russian (https://app.transifex.com/python-doc/teams/5390/"
"ru/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ru\n"
"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
"n%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || "
"(n%100>=11 && n%100<=14)? 2 : 3);\n"
msgid ":mod:`!decimal` --- Decimal fixed-point and floating-point arithmetic"
msgstr ""
msgid "**Source code:** :source:`Lib/decimal.py`"
msgstr ""
msgid ""
"The :mod:`!decimal` module provides support for fast correctly rounded "
"decimal floating-point arithmetic. It offers several advantages over the :"
"class:`float` datatype:"
msgstr ""
msgid ""
"Decimal \"is based on a `floating-point model <https://speleotrove.com/"
"decimal/damodel.html#refnumber>`__ which was designed with people in mind, "
"and necessarily has a paramount guiding principle -- computers must provide "
"an arithmetic that works in the same way as the arithmetic that people learn "
"at school.\" -- excerpt from the decimal arithmetic specification."
msgstr ""
msgid ""
"Decimal numbers can be represented exactly. In contrast, numbers like "
"``1.1`` and ``2.2`` do not have exact representations in binary floating "
"point. End users typically would not expect ``1.1 + 2.2`` to display as "
"``3.3000000000000003`` as it does with binary floating point."
msgstr ""
msgid ""
"The exactness carries over into arithmetic. In decimal floating point, "
"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero. In binary floating "
"point, the result is ``5.5511151231257827e-017``. While near to zero, the "
"differences prevent reliable equality testing and differences can "
"accumulate. For this reason, decimal is preferred in accounting applications "
"which have strict equality invariants."
msgstr ""
msgid ""
"The decimal module incorporates a notion of significant places so that "
"``1.30 + 1.20`` is ``2.50``. The trailing zero is kept to indicate "
"significance. This is the customary presentation for monetary applications. "
"For multiplication, the \"schoolbook\" approach uses all the figures in the "
"multiplicands. For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 * "
"1.20`` gives ``1.5600``."
msgstr ""
msgid ""
"Unlike hardware based binary floating point, the decimal module has a user "
"alterable precision (defaulting to 28 places) which can be as large as "
"needed for a given problem:"
msgstr ""
msgid ""
"Both binary and decimal floating point are implemented in terms of published "
"standards. While the built-in float type exposes only a modest portion of "
"its capabilities, the decimal module exposes all required parts of the "
"standard. When needed, the programmer has full control over rounding and "
"signal handling. This includes an option to enforce exact arithmetic by "
"using exceptions to block any inexact operations."
msgstr ""
msgid ""
"The decimal module was designed to support \"without prejudice, both exact "
"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "
"rounded floating-point arithmetic.\" -- excerpt from the decimal arithmetic "
"specification."
msgstr ""
msgid ""
"The module design is centered around three concepts: the decimal number, "
"the context for arithmetic, and signals."
msgstr ""
msgid ""
"A decimal number is immutable. It has a sign, coefficient digits, and an "
"exponent. To preserve significance, the coefficient digits do not truncate "
"trailing zeros. Decimals also include special values such as ``Infinity``, "
"``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from "
"``+0``."
msgstr ""
msgid ""
"The context for arithmetic is an environment specifying precision, rounding "
"rules, limits on exponents, flags indicating the results of operations, and "
"trap enablers which determine whether signals are treated as exceptions. "
"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:"
"`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:"
"`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."
msgstr ""
msgid ""
"Signals are groups of exceptional conditions arising during the course of "
"computation. Depending on the needs of the application, signals may be "
"ignored, considered as informational, or treated as exceptions. The signals "
"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, :"
"const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, :const:"
"`Subnormal`, :const:`Overflow`, :const:`Underflow` and :const:"
"`FloatOperation`."
msgstr ""
msgid ""
"For each signal there is a flag and a trap enabler. When a signal is "
"encountered, its flag is set to one, then, if the trap enabler is set to "
"one, an exception is raised. Flags are sticky, so the user needs to reset "
"them before monitoring a calculation."
msgstr ""
msgid ""
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
msgstr ""
msgid "Quick-start tutorial"
msgstr ""
msgid ""
"The usual start to using decimals is importing the module, viewing the "
"current context with :func:`getcontext` and, if necessary, setting new "
"values for precision, rounding, or enabled traps::"
msgstr ""
msgid ""
">>> from decimal import *\n"
">>> getcontext()\n"
"Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"
" capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,\n"
" InvalidOperation])\n"
"\n"
">>> getcontext().prec = 7 # Set a new precision"
msgstr ""
msgid ""
"Decimal instances can be constructed from integers, strings, floats, or "
"tuples. Construction from an integer or a float performs an exact conversion "
"of the value of that integer or float. Decimal numbers include special "
"values such as ``NaN`` which stands for \"Not a number\", positive and "
"negative ``Infinity``, and ``-0``::"
msgstr ""
msgid ""
">>> getcontext().prec = 28\n"
">>> Decimal(10)\n"
"Decimal('10')\n"
">>> Decimal('3.14')\n"
"Decimal('3.14')\n"
">>> Decimal(3.14)\n"
"Decimal('3.140000000000000124344978758017532527446746826171875')\n"
">>> Decimal((0, (3, 1, 4), -2))\n"
"Decimal('3.14')\n"
">>> Decimal(str(2.0 ** 0.5))\n"
"Decimal('1.4142135623730951')\n"
">>> Decimal(2) ** Decimal('0.5')\n"
"Decimal('1.414213562373095048801688724')\n"
">>> Decimal('NaN')\n"
"Decimal('NaN')\n"
">>> Decimal('-Infinity')\n"
"Decimal('-Infinity')"
msgstr ""
msgid ""
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
"decimals and floats in constructors or ordering comparisons raises an "
"exception::"
msgstr ""
msgid ""
">>> c = getcontext()\n"
">>> c.traps[FloatOperation] = True\n"
">>> Decimal(3.14)\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 1, in <module>\n"
"decimal.FloatOperation: [<class 'decimal.FloatOperation'>]\n"
">>> Decimal('3.5') < 3.7\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 1, in <module>\n"
"decimal.FloatOperation: [<class 'decimal.FloatOperation'>]\n"
">>> Decimal('3.5') == 3.5\n"
"True"
msgstr ""
msgid ""
"The significance of a new Decimal is determined solely by the number of "
"digits input. Context precision and rounding only come into play during "
"arithmetic operations."
msgstr ""
msgid ""
">>> getcontext().prec = 6\n"
">>> Decimal('3.0')\n"
"Decimal('3.0')\n"
">>> Decimal('3.1415926535')\n"
"Decimal('3.1415926535')\n"
">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n"
"Decimal('5.85987')\n"
">>> getcontext().rounding = ROUND_UP\n"
">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n"
"Decimal('5.85988')"
msgstr ""
msgid ""
"If the internal limits of the C version are exceeded, constructing a decimal "
"raises :class:`InvalidOperation`::"
msgstr ""
msgid ""
">>> Decimal(\"1e9999999999999999999\")\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 1, in <module>\n"
"decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]"
msgstr ""
msgid ""
"Decimals interact well with much of the rest of Python. Here is a small "
"decimal floating-point flying circus:"
msgstr ""
msgid ""
">>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))\n"
">>> max(data)\n"
"Decimal('9.25')\n"
">>> min(data)\n"
"Decimal('0.03')\n"
">>> sorted(data)\n"
"[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),\n"
" Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]\n"
">>> sum(data)\n"
"Decimal('19.29')\n"
">>> a,b,c = data[:3]\n"
">>> str(a)\n"
"'1.34'\n"
">>> float(a)\n"
"1.34\n"
">>> round(a, 1)\n"
"Decimal('1.3')\n"
">>> int(a)\n"
"1\n"
">>> a * 5\n"
"Decimal('6.70')\n"
">>> a * b\n"
"Decimal('2.5058')\n"
">>> c % a\n"
"Decimal('0.77')"
msgstr ""
msgid ""
"Decimals can be formatted (with :func:`format` built-in or :ref:`f-strings`) "
"in fixed-point or scientific notation, using the same formatting syntax "
"(see :ref:`formatspec`) as builtin :class:`float` type:"
msgstr ""
msgid ""
">>> format(Decimal('2.675'), \"f\")\n"
"'2.675'\n"
">>> format(Decimal('2.675'), \".2f\")\n"
"'2.68'\n"
">>> f\"{Decimal('2.675'):.2f}\"\n"
"'2.68'\n"
">>> format(Decimal('2.675'), \".2e\")\n"
"'2.68e+0'\n"
">>> with localcontext() as ctx:\n"
"... ctx.rounding = ROUND_DOWN\n"
"... print(format(Decimal('2.675'), \".2f\"))\n"
"...\n"
"2.67"
msgstr ""
msgid "And some mathematical functions are also available to Decimal:"
msgstr ""
msgid ""
"The :meth:`~Decimal.quantize` method rounds a number to a fixed exponent. "
"This method is useful for monetary applications that often round results to "
"a fixed number of places:"
msgstr ""
msgid ""
"As shown above, the :func:`getcontext` function accesses the current context "
"and allows the settings to be changed. This approach meets the needs of "
"most applications."
msgstr ""
msgid ""
"For more advanced work, it may be useful to create alternate contexts using "
"the :meth:`Context` constructor. To make an alternate active, use the :func:"
"`setcontext` function."
msgstr ""
msgid ""
"In accordance with the standard, the :mod:`!decimal` module provides two "
"ready to use standard contexts, :const:`BasicContext` and :const:"
"`ExtendedContext`. The former is especially useful for debugging because "
"many of the traps are enabled:"
msgstr ""
msgid ""
">>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)\n"
">>> setcontext(myothercontext)\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857142857142857142857142857')\n"
"\n"
">>> ExtendedContext\n"
"Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"
" capitals=1, clamp=0, flags=[], traps=[])\n"
">>> setcontext(ExtendedContext)\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857143')\n"
">>> Decimal(42) / Decimal(0)\n"
"Decimal('Infinity')\n"
"\n"
">>> setcontext(BasicContext)\n"
">>> Decimal(42) / Decimal(0)\n"
"Traceback (most recent call last):\n"
" File \"<pyshell#143>\", line 1, in -toplevel-\n"
" Decimal(42) / Decimal(0)\n"
"DivisionByZero: x / 0"
msgstr ""
msgid ""
"Contexts also have signal flags for monitoring exceptional conditions "
"encountered during computations. The flags remain set until explicitly "
"cleared, so it is best to clear the flags before each set of monitored "
"computations by using the :meth:`~Context.clear_flags` method. ::"
msgstr ""
msgid ""
">>> setcontext(ExtendedContext)\n"
">>> getcontext().clear_flags()\n"
">>> Decimal(355) / Decimal(113)\n"
"Decimal('3.14159292')\n"
">>> getcontext()\n"
"Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"
" capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])"
msgstr ""
msgid ""
"The *flags* entry shows that the rational approximation to pi was rounded "
"(digits beyond the context precision were thrown away) and that the result "
"is inexact (some of the discarded digits were non-zero)."
msgstr ""
msgid ""
"Individual traps are set using the dictionary in the :attr:`~Context.traps` "
"attribute of a context:"
msgstr ""
msgid ""
">>> setcontext(ExtendedContext)\n"
">>> Decimal(1) / Decimal(0)\n"
"Decimal('Infinity')\n"
">>> getcontext().traps[DivisionByZero] = 1\n"
">>> Decimal(1) / Decimal(0)\n"
"Traceback (most recent call last):\n"
" File \"<pyshell#112>\", line 1, in -toplevel-\n"
" Decimal(1) / Decimal(0)\n"
"DivisionByZero: x / 0"
msgstr ""
msgid ""
"Most programs adjust the current context only once, at the beginning of the "
"program. And, in many applications, data is converted to :class:`Decimal` "
"with a single cast inside a loop. With context set and decimals created, "
"the bulk of the program manipulates the data no differently than with other "
"Python numeric types."
msgstr ""
msgid "Decimal objects"
msgstr ""
msgid "Construct a new :class:`Decimal` object based from *value*."
msgstr ""
msgid ""
"*value* can be an integer, string, tuple, :class:`float`, or another :class:"
"`Decimal` object. If no *value* is given, returns ``Decimal('0')``. If "
"*value* is a string, it should conform to the decimal numeric string syntax "
"after leading and trailing whitespace characters, as well as underscores "
"throughout, are removed::"
msgstr ""
msgid ""
"sign ::= '+' | '-'\n"
"digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | "
"'9'\n"
"indicator ::= 'e' | 'E'\n"
"digits ::= digit [digit]...\n"
"decimal-part ::= digits '.' [digits] | ['.'] digits\n"
"exponent-part ::= indicator [sign] digits\n"
"infinity ::= 'Infinity' | 'Inf'\n"
"nan ::= 'NaN' [digits] | 'sNaN' [digits]\n"
"numeric-value ::= decimal-part [exponent-part] | infinity\n"
"numeric-string ::= [sign] numeric-value | [sign] nan"
msgstr ""
msgid ""
"Other Unicode decimal digits are also permitted where ``digit`` appears "
"above. These include decimal digits from various other alphabets (for "
"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "
"``'\\uff10'`` through ``'\\uff19'``. Case is not significant, so, for "
"example, ``inf``, ``Inf``, ``INFINITY``, and ``iNfINity`` are all acceptable "
"spellings for positive infinity."
msgstr ""
msgid ""
"If *value* is a :class:`tuple`, it should have three components, a sign "
"(``0`` for positive or ``1`` for negative), a :class:`tuple` of digits, and "
"an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))`` returns "
"``Decimal('1.414')``."
msgstr ""
msgid ""
"If *value* is a :class:`float`, the binary floating-point value is "
"losslessly converted to its exact decimal equivalent. This conversion can "
"often require 53 or more digits of precision. For example, "
"``Decimal(float('1.1'))`` converts to "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."
msgstr ""
msgid ""
"The *context* precision does not affect how many digits are stored. That is "
"determined exclusively by the number of digits in *value*. For example, "
"``Decimal('3.00000')`` records all five zeros even if the context precision "
"is only three."
msgstr ""
msgid ""
"The purpose of the *context* argument is determining what to do if *value* "
"is a malformed string. If the context traps :const:`InvalidOperation`, an "
"exception is raised; otherwise, the constructor returns a new Decimal with "
"the value of ``NaN``."
msgstr ""
msgid "Once constructed, :class:`Decimal` objects are immutable."
msgstr ""
msgid ""
"The argument to the constructor is now permitted to be a :class:`float` "
"instance."
msgstr ""
msgid ""
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
"trap is set. By default the trap is off."
msgstr ""
msgid ""
"Underscores are allowed for grouping, as with integral and floating-point "
"literals in code."
msgstr ""
msgid ""
"Decimal floating-point objects share many properties with the other built-in "
"numeric types such as :class:`float` and :class:`int`. All of the usual "
"math operations and special methods apply. Likewise, decimal objects can be "
"copied, pickled, printed, used as dictionary keys, used as set elements, "
"compared, sorted, and coerced to another type (such as :class:`float` or :"
"class:`int`)."
msgstr ""
msgid ""
"There are some small differences between arithmetic on Decimal objects and "
"arithmetic on integers and floats. When the remainder operator ``%`` is "
"applied to Decimal objects, the sign of the result is the sign of the "
"*dividend* rather than the sign of the divisor::"
msgstr ""
msgid ""
">>> (-7) % 4\n"
"1\n"
">>> Decimal(-7) % Decimal(4)\n"
"Decimal('-3')"
msgstr ""
msgid ""
"The integer division operator ``//`` behaves analogously, returning the "
"integer part of the true quotient (truncating towards zero) rather than its "
"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
msgstr ""
msgid ""
">>> -7 // 4\n"
"-2\n"
">>> Decimal(-7) // Decimal(4)\n"
"Decimal('-1')"
msgstr ""
msgid ""
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
"integer`` operations (respectively) as described in the specification."
msgstr ""
msgid ""
"Decimal objects cannot generally be combined with floats or instances of :"
"class:`fractions.Fraction` in arithmetic operations: an attempt to add a :"
"class:`Decimal` to a :class:`float`, for example, will raise a :exc:"
"`TypeError`. However, it is possible to use Python's comparison operators "
"to compare a :class:`Decimal` instance ``x`` with another number ``y``. "
"This avoids confusing results when doing equality comparisons between "
"numbers of different types."
msgstr ""
msgid ""
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
"types are now fully supported."
msgstr ""
msgid ""
"In addition to the standard numeric properties, decimal floating-point "
"objects also have a number of specialized methods:"
msgstr ""
msgid ""
"Return the adjusted exponent after shifting out the coefficient's rightmost "
"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "
"returns seven. Used for determining the position of the most significant "
"digit with respect to the decimal point."
msgstr ""
msgid ""
"Return a pair ``(n, d)`` of integers that represent the given :class:"
"`Decimal` instance as a fraction, in lowest terms and with a positive "
"denominator::"
msgstr ""
msgid ""
">>> Decimal('-3.14').as_integer_ratio()\n"
"(-157, 50)"
msgstr ""
msgid ""
"The conversion is exact. Raise OverflowError on infinities and ValueError "
"on NaNs."
msgstr ""
msgid ""
"Return a :term:`named tuple` representation of the number: "
"``DecimalTuple(sign, digits, exponent)``."
msgstr ""
msgid ""
"Return the canonical encoding of the argument. Currently, the encoding of "
"a :class:`Decimal` instance is always canonical, so this operation returns "
"its argument unchanged."
msgstr ""
msgid ""
"Compare the values of two Decimal instances. :meth:`compare` returns a "
"Decimal instance, and if either operand is a NaN then the result is a NaN::"
msgstr ""
msgid ""
"a or b is a NaN ==> Decimal('NaN')\n"
"a < b ==> Decimal('-1')\n"
"a == b ==> Decimal('0')\n"
"a > b ==> Decimal('1')"
msgstr ""
msgid ""
"This operation is identical to the :meth:`compare` method, except that all "
"NaNs signal. That is, if neither operand is a signaling NaN then any quiet "
"NaN operand is treated as though it were a signaling NaN."
msgstr ""
msgid ""
"Compare two operands using their abstract representation rather than their "
"numerical value. Similar to the :meth:`compare` method, but the result "
"gives a total ordering on :class:`Decimal` instances. Two :class:`Decimal` "
"instances with the same numeric value but different representations compare "
"unequal in this ordering:"
msgstr ""
msgid ""
"Quiet and signaling NaNs are also included in the total ordering. The "
"result of this function is ``Decimal('0')`` if both operands have the same "
"representation, ``Decimal('-1')`` if the first operand is lower in the total "
"order than the second, and ``Decimal('1')`` if the first operand is higher "
"in the total order than the second operand. See the specification for "
"details of the total order."
msgstr ""
msgid ""
"This operation is unaffected by context and is quiet: no flags are changed "
"and no rounding is performed. As an exception, the C version may raise "
"InvalidOperation if the second operand cannot be converted exactly."
msgstr ""
msgid ""
"Compare two operands using their abstract representation rather than their "
"value as in :meth:`compare_total`, but ignoring the sign of each operand. "
"``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."
"copy_abs())``."
msgstr ""
msgid ""
"Just returns self, this method is only to comply with the Decimal "
"Specification."
msgstr ""
msgid ""
"Return the absolute value of the argument. This operation is unaffected by "
"the context and is quiet: no flags are changed and no rounding is performed."
msgstr ""
msgid ""
"Return the negation of the argument. This operation is unaffected by the "
"context and is quiet: no flags are changed and no rounding is performed."
msgstr ""
msgid ""
"Return a copy of the first operand with the sign set to be the same as the "
"sign of the second operand. For example:"
msgstr ""
msgid ""
"Return the value of the (natural) exponential function ``e**x`` at the given "
"number. The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "
"rounding mode."
msgstr ""
msgid ""
"Alternative constructor that only accepts instances of :class:`float` or :"
"class:`int`."
msgstr ""
msgid ""
"Note ``Decimal.from_float(0.1)`` is not the same as ``Decimal('0.1')``. "
"Since 0.1 is not exactly representable in binary floating point, the value "
"is stored as the nearest representable value which is "
"``0x1.999999999999ap-4``. That equivalent value in decimal is "
"``0.1000000000000000055511151231257827021181583404541015625``."
msgstr ""
msgid ""
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
"directly from a :class:`float`."
msgstr ""
msgid ""
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
">>> Decimal.from_float(float('nan'))\n"
"Decimal('NaN')\n"
">>> Decimal.from_float(float('inf'))\n"
"Decimal('Infinity')\n"
">>> Decimal.from_float(float('-inf'))\n"
"Decimal('-Infinity')"
msgstr ""
msgid ""
"Alternative constructor that only accepts instances of :class:`float`, :"
"class:`int` or :class:`Decimal`, but not strings or tuples."
msgstr ""
msgid ""
">>> Decimal.from_number(314)\n"
"Decimal('314')\n"
">>> Decimal.from_number(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
">>> Decimal.from_number(Decimal('3.14'))\n"
"Decimal('3.14')"
msgstr ""
msgid ""
"Fused multiply-add. Return self*other+third with no rounding of the "
"intermediate product self*other."
msgstr ""
msgid ""
"Return :const:`True` if the argument is canonical and :const:`False` "
"otherwise. Currently, a :class:`Decimal` instance is always canonical, so "
"this operation always returns :const:`True`."
msgstr ""
msgid ""
"Return :const:`True` if the argument is a finite number, and :const:`False` "
"if the argument is an infinity or a NaN."
msgstr ""
msgid ""
"Return :const:`True` if the argument is either positive or negative infinity "
"and :const:`False` otherwise."
msgstr ""
msgid ""
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
"const:`False` otherwise."
msgstr ""
msgid ""
"Return :const:`True` if the argument is a *normal* finite number. Return :"
"const:`False` if the argument is zero, subnormal, infinite or a NaN."
msgstr ""
msgid ""
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
"otherwise."
msgstr ""
msgid ""
"Return :const:`True` if the argument has a negative sign and :const:`False` "
"otherwise. Note that zeros and NaNs can both carry signs."
msgstr ""
msgid ""
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
"otherwise."
msgstr ""
msgid ""
"Return :const:`True` if the argument is subnormal, and :const:`False` "
"otherwise."
msgstr ""
msgid ""
"Return :const:`True` if the argument is a (positive or negative) zero and :"
"const:`False` otherwise."
msgstr ""
msgid ""
"Return the natural (base e) logarithm of the operand. The result is "
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
msgid ""
"Return the base ten logarithm of the operand. The result is correctly "
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
msgid ""
"For a nonzero number, return the adjusted exponent of its operand as a :"
"class:`Decimal` instance. If the operand is a zero then ``Decimal('-"
"Infinity')`` is returned and the :const:`DivisionByZero` flag is raised. If "
"the operand is an infinity then ``Decimal('Infinity')`` is returned."
msgstr ""
msgid ""
":meth:`logical_and` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`). The result is the digit-wise "
"``and`` of the two operands."
msgstr ""
msgid ""
":meth:`logical_invert` is a logical operation. The result is the digit-wise "
"inversion of the operand."
msgstr ""
msgid ""
":meth:`logical_or` is a logical operation which takes two *logical operands* "
"(see :ref:`logical_operands_label`). The result is the digit-wise ``or`` of "
"the two operands."
msgstr ""
msgid ""
":meth:`logical_xor` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`). The result is the digit-wise "
"exclusive or of the two operands."
msgstr ""
msgid ""
"Like ``max(self, other)`` except that the context rounding rule is applied "
"before returning and that ``NaN`` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""
msgid ""
"Similar to the :meth:`.max` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""
msgid ""
"Like ``min(self, other)`` except that the context rounding rule is applied "
"before returning and that ``NaN`` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""
msgid ""
"Similar to the :meth:`.min` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""
msgid ""
"Return the largest number representable in the given context (or in the "
"current thread's context if no context is given) that is smaller than the "
"given operand."
msgstr ""
msgid ""
"Return the smallest number representable in the given context (or in the "
"current thread's context if no context is given) that is larger than the "
"given operand."
msgstr ""
msgid ""
"If the two operands are unequal, return the number closest to the first "
"operand in the direction of the second operand. If both operands are "
"numerically equal, return a copy of the first operand with the sign set to "
"be the same as the sign of the second operand."
msgstr ""
msgid ""
"Used for producing canonical values of an equivalence class within either "
"the current context or the specified context."
msgstr ""
msgid ""
"This has the same semantics as the unary plus operation, except that if the "
"final result is finite it is reduced to its simplest form, with all trailing "
"zeros removed and its sign preserved. That is, while the coefficient is non-"
"zero and a multiple of ten the coefficient is divided by ten and the "
"exponent is incremented by 1. Otherwise (the coefficient is zero) the "
"exponent is set to 0. In all cases the sign is unchanged."
msgstr ""
msgid ""
"For example, ``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both "
"normalize to the equivalent value ``Decimal('32.1')``."
msgstr ""
msgid "Note that rounding is applied *before* reducing to simplest form."
msgstr ""
msgid ""
"In the latest versions of the specification, this operation is also known as "
"``reduce``."
msgstr ""
msgid ""
"Return a string describing the *class* of the operand. The returned value "
"is one of the following ten strings."
msgstr ""
msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."
msgstr ""
msgid ""
"``\"-Normal\"``, indicating that the operand is a negative normal number."
msgstr ""
msgid ""
"``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
msgstr ""
msgid "``\"-Zero\"``, indicating that the operand is a negative zero."
msgstr ""
msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
msgstr ""
msgid ""
"``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
msgstr ""
msgid ""
"``\"+Normal\"``, indicating that the operand is a positive normal number."
msgstr ""
msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."
msgstr ""
msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
msgstr ""
msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
msgstr ""
msgid ""
"Return a value equal to the first operand after rounding and having the "
"exponent of the second operand."
msgstr ""
msgid ""
"Unlike other operations, if the length of the coefficient after the quantize "
"operation would be greater than precision, then an :const:`InvalidOperation` "
"is signaled. This guarantees that, unless there is an error condition, the "
"quantized exponent is always equal to that of the right-hand operand."
msgstr ""
msgid ""
"Also unlike other operations, quantize never signals Underflow, even if the "
"result is subnormal and inexact."
msgstr ""
msgid ""
"If the exponent of the second operand is larger than that of the first then "
"rounding may be necessary. In this case, the rounding mode is determined by "
"the ``rounding`` argument if given, else by the given ``context`` argument; "
"if neither argument is given the rounding mode of the current thread's "
"context is used."
msgstr ""
msgid ""
"An error is returned whenever the resulting exponent is greater than :attr:"
"`~Context.Emax` or less than :meth:`~Context.Etiny`."
msgstr ""
msgid ""
"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "
"does all its arithmetic. Included for compatibility with the specification."
msgstr ""
msgid ""
"Return the remainder from dividing *self* by *other*. This differs from "
"``self % other`` in that the sign of the remainder is chosen so as to "
"minimize its absolute value. More precisely, the return value is ``self - n "
"* other`` where ``n`` is the integer nearest to the exact value of ``self / "
"other``, and if two integers are equally near then the even one is chosen."
msgstr ""
msgid "If the result is zero then its sign will be the sign of *self*."
msgstr ""
msgid ""
"Return the result of rotating the digits of the first operand by an amount "
"specified by the second operand. The second operand must be an integer in "
"the range -precision through precision. The absolute value of the second "
"operand gives the number of places to rotate. If the second operand is "
"positive then rotation is to the left; otherwise rotation is to the right. "
"The coefficient of the first operand is padded on the left with zeros to "
"length precision if necessary. The sign and exponent of the first operand "
"are unchanged."
msgstr ""
msgid ""
"Test whether self and other have the same exponent or whether both are "
"``NaN``."
msgstr ""
msgid ""
"Return the first operand with exponent adjusted by the second. Equivalently, "
"return the first operand multiplied by ``10**other``. The second operand "
"must be an integer."
msgstr ""
msgid ""
"Return the result of shifting the digits of the first operand by an amount "
"specified by the second operand. The second operand must be an integer in "
"the range -precision through precision. The absolute value of the second "
"operand gives the number of places to shift. If the second operand is "
"positive then the shift is to the left; otherwise the shift is to the "
"right. Digits shifted into the coefficient are zeros. The sign and "
"exponent of the first operand are unchanged."
msgstr ""
msgid "Return the square root of the argument to full precision."
msgstr ""
msgid ""
"Convert to a string, using engineering notation if an exponent is needed."
msgstr ""
msgid ""
"Engineering notation has an exponent which is a multiple of 3. This can "
"leave up to 3 digits to the left of the decimal place and may require the "
"addition of either one or two trailing zeros."
msgstr ""
msgid ""
"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
msgstr ""
msgid ""
"Identical to the :meth:`to_integral_value` method. The ``to_integral`` name "
"has been kept for compatibility with older versions."
msgstr ""
msgid ""
"Round to the nearest integer, signaling :const:`Inexact` or :const:`Rounded` "
"as appropriate if rounding occurs. The rounding mode is determined by the "
"``rounding`` parameter if given, else by the given ``context``. If neither "
"parameter is given then the rounding mode of the current context is used."
msgstr ""
msgid ""
"Round to the nearest integer without signaling :const:`Inexact` or :const:"
"`Rounded`. If given, applies *rounding*; otherwise, uses the rounding "
You can’t perform that action at this time.