{{ message }}
-
-
Notifications
You must be signed in to change notification settings - Fork 412
Expand file tree
/
Copy pathdecimal.po
More file actions
2859 lines (2526 loc) · 126 KB
/
Copy pathdecimal.po
File metadata and controls
2859 lines (2526 loc) · 126 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
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-12-15 23:37-0500\n"
"Last-Translator: Adolfo Hristo David Roque Gámez <aroquega@gmail.com>\n"
"Language: es_ES\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"
#: ../Doc/library/decimal.rst:2
msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
msgstr ":mod:`decimal` --- Aritmética decimal de coma fija y coma flotante"
#: ../Doc/library/decimal.rst:15
msgid "**Source code:** :source:`Lib/decimal.py`"
msgstr "**Código fuente:** :source:`Lib/decimal.py`"
#: ../Doc/library/decimal.rst:33
#, fuzzy
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 ""
"El módulo :mod:`decimal` proporciona soporte para aritmética decimal de coma "
"flotante rápida y con redondeo matemáticamente correcto. Ofrece varias "
"ventajas en comparación con el tipo de dato :class:`float`:"
#: ../Doc/library/decimal.rst:37
msgid ""
"Decimal \"is based on a floating-point model 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 ""
"Decimal \"se basa en un modelo de coma flotante que se diseñó pensando en "
"las personas, y necesariamente tiene un principio rector supremo: las "
"computadoras deben proporcionar una aritmética que funcione de la misma "
"manera que la aritmética que las personas aprenden en la escuela.\" -- "
"extracto (traducido) de la especificación de la aritmética decimal."
#: ../Doc/library/decimal.rst:42
msgid ""
"Decimal numbers can be represented exactly. In contrast, numbers like :"
"const:`1.1` and :const:`2.2` do not have exact representations in binary "
"floating point. End users typically would not expect ``1.1 + 2.2`` to "
"display as :const:`3.3000000000000003` as it does with binary floating point."
msgstr ""
"Los números decimales se pueden representar de forma exacta en coma flotante "
"decimal. En cambio, números como :const:`1.1` y :const:`2.2` no tienen "
"representaciones exactas en coma flotante binaria. Los usuarios finales "
"normalmente no esperaran que ``1.1 + 2.2`` se muestre como :const:"
"`3.3000000000000003`, como ocurre al usar la representación binaria en coma "
"flotante."
#: ../Doc/library/decimal.rst:47
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 :const:`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 ""
"La exactitud se traslada a la aritmética. En coma flotante decimal, ``0.1 + "
"0.1 + 0.1 - 0.3`` es exactamente igual a cero. En coma flotante binaria, el "
"resultado es :const:`5.5511151231257827e-017`. Aunque cercanas a cero, las "
"diferencias impiden pruebas de igualdad confiables y las diferencias pueden "
"acumularse. Por estas razones, se recomienda el uso de decimal en "
"aplicaciones de contabilidad con estrictas restricciones de confiabilidad."
#: ../Doc/library/decimal.rst:54
msgid ""
"The decimal module incorporates a notion of significant places so that "
"``1.30 + 1.20`` is :const:`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 :const:`1.56` while ``1.30 "
"* 1.20`` gives :const:`1.5600`."
msgstr ""
"El módulo decimal incorpora una noción de dígitos significativos, de modo "
"que ``1.30 + 1.20`` es :const:`2.50`. El cero final se mantiene para indicar "
"el número de dígitos significativos. Esta es la representación habitual en "
"aplicaciones monetarias. Para la multiplicación, el método de \"libro "
"escolar\" utilizado usa todas las cifras de los multiplicandos. Por ejemplo, "
"``1.3 * 1.2`` es igual a :const:`1.56`, mientras que ``1.30 * 1.20`` es "
"igual a :const:`1.5600`."
#: ../Doc/library/decimal.rst:61
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 ""
"A diferencia del punto flotante binario basado en hardware, el módulo "
"decimal tiene una precisión modificable por el usuario (por defecto es de 28 "
"dígitos decimales) que puede ser tan grande como sea necesario para un "
"problema dado:"
#: ../Doc/library/decimal.rst:73
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 ""
"Tanto la representación en coma flotante binaria como la decimal se "
"implementan de acuerdo a estándares publicados. Mientras que el tipo float "
"expone solo una pequeña parte de sus capacidades, el módulo decimal expone "
"todos los componentes requeridos del estándar. Cuando es necesario, el "
"desarrollador tiene control total sobre el redondeo y la gestión de las "
"señales. Esto incluye la capacidad de forzar la aritmética exacta, "
"utilizando excepciones para bloquear cualquier operación inexacta."
#: ../Doc/library/decimal.rst:80
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 ""
"El módulo decimal fue diseñado para admitir \"indiscriminadamente, tanto "
"aritmética decimal exacta sin redondeo (a veces llamada aritmética de coma "
"fija) como la aritmética de coma flotante con redondeo.\" -- extracto "
"(traducido) de la especificación de la aritmética decimal."
#: ../Doc/library/decimal.rst:85
msgid ""
"The module design is centered around three concepts: the decimal number, "
"the context for arithmetic, and signals."
msgstr ""
"El módulo está diseñado en torno a tres conceptos: el número decimal, el "
"contexto aritmético y las señales."
#: ../Doc/library/decimal.rst:88
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 :const:"
"`Infinity`, :const:`-Infinity`, and :const:`NaN`. The standard also "
"differentiates :const:`-0` from :const:`+0`."
msgstr ""
"Un número decimal es inmutable. Tiene un signo, un coeficiente y un "
"exponente. Para conservar el número de dígitos significativos, los ceros "
"iniciales no se truncan. Los números decimales también incluyen valores "
"especiales como :const:`Infinity`, :const:`-Infinity` y :const:`NaN`. El "
"estándar también marca la diferencia entre :const:`-0` y :const:`+0`."
#: ../Doc/library/decimal.rst:94
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 ""
"El contexto aritmético es un entorno que permite especificar una precisión, "
"reglas de redondeo, límites en los exponentes, flags que indican el "
"resultado de las operaciones y habilitadores de trampas que especifican si "
"las señales (reportadas durante operaciones ilegales) son tratadas o no como "
"excepciones de Python. Las opciones de redondeo incluyen :const:"
"`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:`ROUND_FLOOR`, :const:"
"`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:`ROUND_HALF_UP`, :const:"
"`ROUND_UP` y :const:`ROUND_05UP`."
#: ../Doc/library/decimal.rst:101
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 ""
"Las señales son grupos de condiciones excepcionales que ocurren durante el "
"cálculo. Dependiendo de las necesidades de la aplicación, las señales pueden "
"ignorarse, tratarse como información o tratarse como excepciones. Las "
"señales existentes en el módulo decimal son :const:`Clamped`, :const:"
"`InvalidOperation`, :const:`DivisionByZero`, :const:`Inexact`, :const:"
"`Rounded`, :const:`Subnormal`, :const:`Overflow`, :const:`Underflow` y :"
"const:`FloatOperation`."
#: ../Doc/library/decimal.rst:108
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 ""
"Por cada señal hay un flag y un habilitador de trampa. Cuando ocurre una "
"operación ilegal, su flag se establece en uno, luego, si su habilitador de "
"trampa está establecido en uno, se lanza una excepción. La configuración de "
"los flags es persistente, por lo que el usuario debe restablecerlos antes de "
"comenzar un cálculo que desee monitorear."
#: ../Doc/library/decimal.rst:116
#, fuzzy
msgid ""
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
msgstr ""
"Especificación general de la aritmética decimal de IBM, `The General Decimal "
"Arithmetic Specification <http://speleotrove.com/decimal/decarith.html>`_."
#: ../Doc/library/decimal.rst:125
msgid "Quick-start Tutorial"
msgstr "Tutorial de inicio rápido"
#: ../Doc/library/decimal.rst:127
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 ""
"El punto de partida habitual para usar decimales es importar el módulo, ver "
"el contexto actual con :func:`getcontext` y, si es necesario, establecer "
"nuevos valores para la precisión, el redondeo o trampas de señales "
"habilitadas::"
#: ../Doc/library/decimal.rst:139
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 :const:`NaN` which stands for \"Not a number\", positive and "
"negative :const:`Infinity`, and :const:`-0`::"
msgstr ""
"Las instancias de la clase Decimal se pueden construir a partir de números "
"enteros, cadenas de caracteres, flotantes o tuplas. La construcción a partir "
"de un número entero o flotante realiza una conversión exacta del valor de "
"ese número. Los números decimales incluyen valores especiales como :const:"
"`NaN`, que significa \"No es un número\", :const:`Infinity` positivo y "
"negativo o :const:`-0`::"
#: ../Doc/library/decimal.rst:163
msgid ""
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
"decimals and floats in constructors or ordering comparisons raises an "
"exception::"
msgstr ""
"Si la señal :exc:`FloatOperation` es atrapada, la mezcla accidental de "
"decimales y flotantes en constructores o comparaciones de orden lanzará una "
"excepción::"
#: ../Doc/library/decimal.rst:182
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 ""
"La significación de un nuevo objeto Decimal es determinada únicamente por el "
"número de dígitos ingresados. La precisión y el redondeo establecidos en el "
"contexto solo entran en juego durante las operaciones aritméticas."
#: ../Doc/library/decimal.rst:199
msgid ""
"If the internal limits of the C version are exceeded, constructing a decimal "
"raises :class:`InvalidOperation`::"
msgstr ""
"Se lanza una excepción :class:`InvalidOperation` si durante la construcción "
"de un objeto Decimal se exceden los límites internos de la versión de C::"
#: ../Doc/library/decimal.rst:209
msgid ""
"Decimals interact well with much of the rest of Python. Here is a small "
"decimal floating point flying circus:"
msgstr ""
"Los objetos Decimal interactúan bien con gran parte del resto de Python. "
"Aquí hay un pequeño circo volador de punto flotante decimal:"
#: ../Doc/library/decimal.rst:241
msgid "And some mathematical functions are also available to Decimal:"
msgstr ""
"Y algunas funciones matemáticas también están disponibles para Decimal:"
#: ../Doc/library/decimal.rst:253
msgid ""
"The :meth:`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 ""
"El método :meth:`quantize` redondea un número a un exponente fijo. Este "
"método es útil para aplicaciones monetarias, que a menudo redondean los "
"resultados a un número fijo de dígitos significativos:"
#: ../Doc/library/decimal.rst:262
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 ""
"Como se muestra arriba, la función :func:`getcontext` accede al contexto "
"actual y permite cambiar la configuración. Este enfoque satisface las "
"necesidades de la mayoría de las aplicaciones."
#: ../Doc/library/decimal.rst:266
msgid ""
"For more advanced work, it may be useful to create alternate contexts using "
"the Context() constructor. To make an alternate active, use the :func:"
"`setcontext` function."
msgstr ""
"Para trabajos más avanzados, puede resultar útil crear contextos "
"alternativos utilizando el constructor Context(). Para activar un contexto "
"alternativo, usa la función :func:`setcontext`."
#: ../Doc/library/decimal.rst:270
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 ""
"De acuerdo con el estándar, el módulo :mod:`decimal` proporciona dos "
"contextos estándar listos para usar, :const:`BasicContext` y :const:"
"`ExtendedContext`. El primero es particularmente útil para la depuración, ya "
"que muchas de las trampas de señales están habilitadas por defecto:"
#: ../Doc/library/decimal.rst:299
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:`clear_flags` method. ::"
msgstr ""
"Los objetos Context también tienen flags de señalización para detectar "
"condiciones excepcionales detectadas durante los cálculos. Estos flags "
"permanecen habilitados hasta que se restablecen explícitamente. Por esta "
"razón, suele ser buena idea restablecerlos mediante el método :meth:"
"`clear_flags` antes de proceder con cada conjunto de cálculos "
"monitorizados. ::"
#: ../Doc/library/decimal.rst:312
msgid ""
"The *flags* entry shows that the rational approximation to :const:`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 ""
"La entrada *flags* muestra que la aproximación racional de :const:`Pi` fue "
"redondeada (los dígitos más allá de la precisión especificada por el "
"contexto se descartaron) y que el resultado es inexacto (algunos de los "
"dígitos descartados no eran cero)."
#: ../Doc/library/decimal.rst:316
msgid ""
"Individual traps are set using the dictionary in the :attr:`traps` field of "
"a context:"
msgstr ""
"Las trampas de señales se habilitan a través del diccionario expuesto por el "
"atributo :attr:`traps` del objeto Context:"
#: ../Doc/library/decimal.rst:331
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 ""
"La mayoría de los programas ajustan el contexto actual una sola vez, al "
"comienzo del programa. Y, en muchas aplicaciones, los datos se convierten a :"
"class:`Decimal` mediante una única conversión dentro de un bucle. Con el "
"contexto establecido y los decimales creados, la mayor parte del programa "
"manipula los datos de la misma forma que con otros tipos numéricos de Python."
#: ../Doc/library/decimal.rst:343
msgid "Decimal objects"
msgstr "Objetos Decimal"
#: ../Doc/library/decimal.rst:348
msgid "Construct a new :class:`Decimal` object based from *value*."
msgstr "Construye un nuevo objeto :class:`Decimal` basado en *value*."
#: ../Doc/library/decimal.rst:350
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 ""
"*value* puede ser un entero, una cadena de caracteres, una tupla, un :class:"
"`float` u otro objeto :class:`Decimal`. Si no se proporciona *value*, "
"retorna ``Decimal('0')``. Si *value* es una cadena, debe ajustarse a la "
"sintaxis de cadena numérica decimal después de que los espacios en blanco "
"iniciales y finales, así como los guiones bajos, sean eliminados::"
#: ../Doc/library/decimal.rst:366
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'``."
msgstr ""
"También se permiten otros dígitos decimales Unicode en aquellos lugares en "
"los que arriba aparece ``digit``. Estos incluyen dígitos decimales de otros "
"alfabetos (por ejemplo, dígitos del alfabeto árabe-índico y devanāgarī) "
"junto con los dígitos de ancho completo desde ``'\\uff10'`` a ``'\\uff19'``."
#: ../Doc/library/decimal.rst:371
msgid ""
"If *value* is a :class:`tuple`, it should have three components, a sign (:"
"const:`0` for positive or :const:`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 ""
"Si *value* es un objeto :class:`tuple`, debe tener tres componentes, un "
"signo (:const:`0` para positivo o :const:`1` para negativo), un objeto :"
"class:`tuple` con los dígitos y un exponente entero. Por ejemplo, "
"``Decimal((0, (1, 4, 1, 4), -3))`` retorna ``Decimal('1.414')``."
#: ../Doc/library/decimal.rst:376
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 ""
"Si *value* es un :class:`float`, el valor binario de coma flotante se "
"convierte sin pérdidas a su equivalente decimal exacto. Esta conversión a "
"menudo puede requerir 53 o más dígitos de precisión. Por ejemplo, "
"``Decimal(float('1.1'))`` se convierte en "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."
#: ../Doc/library/decimal.rst:382
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 ""
"La precisión de *context* no afecta a la cantidad de dígitos almacenados. "
"Eso está determinado exclusivamente por el número de dígitos en *value*. Por "
"ejemplo, ``Decimal('3.00000')`` registra los cinco ceros incluso si la "
"precisión del contexto es solo tres."
#: ../Doc/library/decimal.rst:387
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 :const:`NaN`."
msgstr ""
"El propósito del argumento *context* es determinar qué hacer si *value* es "
"una cadena de caracteres mal formada. Si el contexto atrapa la señal :const:"
"`InvalidOperation`, se genera una excepción; de lo contrario, el constructor "
"retorna un nuevo decimal con el valor :const:`NaN`."
#: ../Doc/library/decimal.rst:392
msgid "Once constructed, :class:`Decimal` objects are immutable."
msgstr "Una vez construidos, los objetos :class:`Decimal` son inmutables."
#: ../Doc/library/decimal.rst:394
msgid ""
"The argument to the constructor is now permitted to be a :class:`float` "
"instance."
msgstr ""
"Ahora se permite que el argumento del constructor sea una instancia :class:"
"`float`."
#: ../Doc/library/decimal.rst:398
msgid ""
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
"trap is set. By default the trap is off."
msgstr ""
"Los argumentos :class:`float` ahora generan una excepción si se establece la "
"trampa :exc:`FloatOperation`. Por defecto, la trampa está desactivada."
#: ../Doc/library/decimal.rst:402
msgid ""
"Underscores are allowed for grouping, as with integral and floating-point "
"literals in code."
msgstr ""
"Se permiten guiones bajos para la agrupación, como ocurre en el código con "
"los literales enteros y de punto flotante."
#: ../Doc/library/decimal.rst:406
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 ""
"Los objetos de coma flotante decimal comparten muchas propiedades con los "
"otros tipos numéricos integrados, como :class:`float` e :class:`int`. Se "
"aplican todas las operaciones matemáticas habituales y los métodos "
"especiales. Asimismo, los objetos decimales se pueden copiar, serializar con "
"pickle, imprimir, usar como claves de un diccionario o como elementos de un "
"conjunto, comparar, ordenar y convertir a otros tipos (como :class:`float` "
"o :class:`int`)."
#: ../Doc/library/decimal.rst:413
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 ""
"Hay algunas pequeñas diferencias entre la aritmética en objetos decimales y "
"la aritmética en enteros y flotantes. Cuando el operador de resto ``%`` se "
"aplica a objetos Decimal, el signo del resultado es el signo del *dividendo* "
"en lugar del signo del divisor::"
#: ../Doc/library/decimal.rst:423
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 ""
"El operador de división entera ``//`` se comporta de manera análoga, "
"retornando la parte entera del cociente verdadero (truncando hacia cero) en "
"lugar del resultado de aplicarle la función suelo. Esto se hace con la "
"finalidad de preservar la identidad habitual ``x == (x // y) * y + x % y``::"
#: ../Doc/library/decimal.rst:432
msgid ""
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
"integer`` operations (respectively) as described in the specification."
msgstr ""
"Los operadores ``%`` y ``//`` implementan las operaciones ``remainder`` y "
"``divide-integer`` (respectivamente) como se describe en la especificación."
#: ../Doc/library/decimal.rst:436
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 ""
"Los objetos de la clase Decimal generalmente no se pueden combinar con "
"flotantes o instancias de :class:`fractions.Fraction` en operaciones "
"aritméticas: un intento de agregar un objeto :class:`Decimal` a un :class:"
"`float`, por ejemplo, lanzará una excepción :exc:`TypeError`. Sin embargo, "
"es posible usar los operadores de comparación de Python para comparar una "
"instancia de :class:`Decimal` ``x`` con otro número ``y``. Esto evita "
"resultados confusos al hacer comparaciones de igualdad entre números de "
"diferentes tipos."
#: ../Doc/library/decimal.rst:444
msgid ""
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
"types are now fully supported."
msgstr ""
"Las comparaciones de tipo mixto entre instancias de :class:`Decimal` y otros "
"tipos numéricos ahora son totalmente compatibles."
#: ../Doc/library/decimal.rst:448
msgid ""
"In addition to the standard numeric properties, decimal floating point "
"objects also have a number of specialized methods:"
msgstr ""
"Además de las propiedades numéricas estándar, los objetos de coma flotante "
"decimal también tienen varios métodos especializados:"
#: ../Doc/library/decimal.rst:454
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 ""
"Retorna el exponente ajustado después de desplazar los dígitos del extremo "
"derecho del coeficiente hasta que solo quede el dígito principal: "
"``Decimal('321e+5').adjusted()`` retorna siete. Se utiliza para determinar "
"la posición del dígito más significativo con respecto al punto decimal."
#: ../Doc/library/decimal.rst:461
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 ""
"Retorna un par de enteros ``(n, d)`` que representan la instancia de :class:"
"`Decimal` proporcionada como una fracción irreducible y con un denominador "
"positivo::"
#: ../Doc/library/decimal.rst:468
msgid ""
"The conversion is exact. Raise OverflowError on infinities and ValueError "
"on NaNs."
msgstr ""
"La conversión es exacta. Lanza una excepción OverflowError si se "
"proporcionan valores infinitos y ValueError con valores NaN."
#: ../Doc/library/decimal.rst:475
msgid ""
"Return a :term:`named tuple` representation of the number: "
"``DecimalTuple(sign, digits, exponent)``."
msgstr ""
"Retorna una representación en forma de :term:`named tuple` del número: "
"``DecimalTuple(sign, digits, exponent)``."
#: ../Doc/library/decimal.rst:481
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 ""
"Retorna la codificación canónica del argumento. Actualmente, la codificación "
"de una instancia de :class:`Decimal` es siempre canónica, por lo que esta "
"operación retorna su argumento sin cambios."
#: ../Doc/library/decimal.rst:487
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 ""
"Compara los valores de dos instancias de Decimal. El método :meth:`compare` "
"retorna una instancia de Decimal, y si alguno de los operandos es un NaN, el "
"resultado es un NaN::"
#: ../Doc/library/decimal.rst:498
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 ""
"Esta operación es idéntica al método :meth:`compare`, excepto que todos los "
"valores NaN generan una señal. Es decir, si ninguno de los operandos es un "
"NaN señalizador, cualquier operando de NaN silencioso se trata como si fuera "
"un NaN señalizador."
#: ../Doc/library/decimal.rst:504
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 ""
"Compara dos operandos utilizando su representación abstracta en lugar de su "
"valor numérico. Similar al método :meth:`compare`, pero el resultado "
"proporciona un ordenamiento total en las instancias de :class:`Decimal`. Dos "
"instancias de :class:`Decimal` con el mismo valor numérico, pero diferentes "
"representaciones, se comparan como desiguales usando este orden:"
#: ../Doc/library/decimal.rst:513
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 ""
"Los NaN silenciosos y señalizadores también se incluyen en el ordenamiento "
"total. El resultado de esta función es ``Decimal('0')`` si ambos operandos "
"tienen la misma representación, ``Decimal('-1')`` si el primer operando es "
"menor en el orden total que el segundo y ``Decimal('1')`` si el primer "
"operando es mayor en el orden total que el segundo operando. Consulta las "
"especificaciones para obtener detalles sobre el ordenamiento total."
#: ../Doc/library/decimal.rst:520 ../Doc/library/decimal.rst:531
#: ../Doc/library/decimal.rst:559 ../Doc/library/decimal.rst:835
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 ""
"Esta operación no se ve afectada por el contexto y es silenciosa: no se "
"cambian los flags y no se realiza ningún redondeo. Como excepción, la "
"versión de C puede lanzar InvalidOperation si el segundo operando no se "
"puede convertir exactamente."
#: ../Doc/library/decimal.rst:526
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 ""
"Compara dos operandos usando su representación abstracta en lugar de su "
"valor, como en :meth:`compare_total`, pero ignorando el signo de cada "
"operando. ``x.compare_total_mag(y)`` es equivalente a ``x.copy_abs()."
"compare_total(y.copy_abs())``."
#: ../Doc/library/decimal.rst:537
msgid ""
"Just returns self, this method is only to comply with the Decimal "
"Specification."
msgstr ""
"Simplemente retorna self (el propio objeto al que pertenece el método "
"invocado). Este método existe solo para cumplir con la Especificación "
"decimal."
#: ../Doc/library/decimal.rst:542
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 ""
"Retorna el valor absoluto del argumento. Esta operación no se ve afectada "
"por el contexto y es silenciosa: no se modifican los flags y no se realiza "
"ningún redondeo."
#: ../Doc/library/decimal.rst:548
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 ""
"Retorna la negación del argumento. Esta operación no se ve afectada por el "
"contexto y es silenciosa: no se cambian los flags y no se realiza ningún "
"redondeo."
#: ../Doc/library/decimal.rst:553
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 ""
"Retorna una copia del primer operando pero con el signo establecido para que "
"sea el mismo que el del segundo operando. Por ejemplo:"
#: ../Doc/library/decimal.rst:565
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 ""
"Retorna el valor de la función exponencial (natural) ``e**x`` en el número "
"dado. El resultado es correctamente redondeado utilizando el modo de "
"redondeo :const:`ROUND_HALF_EVEN`."
#: ../Doc/library/decimal.rst:576
msgid ""
"Alternative constructor that only accepts instances of :class:`float` or :"
"class:`int`."
msgstr ""
#: ../Doc/library/decimal.rst:579
#, fuzzy
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 ""
"Nota que `Decimal.from_float (0.1)` no es lo mismo que `Decimal('0.1')`. "
"Dado que 0.1 no es exactamente representable en coma flotante binaria, el "
"valor se almacena como el valor representable más cercano, que es "
"`0x1.999999999999ap-4`. Ese valor equivalente en decimal es "
"`0.1000000000000000055511151231257827021181583404541015625`."
#: ../Doc/library/decimal.rst:585
msgid ""
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
"directly from a :class:`float`."
msgstr ""
"Desde Python 3.2 en adelante, una instancia de :class:`Decimal` también se "
"puede construir directamente desde una instancia de :class:`float`."
#: ../Doc/library/decimal.rst:603
msgid ""
"Fused multiply-add. Return self*other+third with no rounding of the "
"intermediate product self*other."
msgstr ""
"Fusión de la multiplicación y la suma. Retorna self*other+third sin redondeo "
"del producto intermedio self*other."
#: ../Doc/library/decimal.rst:611
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 ""
"Retorna :const:`True` si el argumento es canónico y :const:`False` en caso "
"contrario. Actualmente, una instancia de :class:`Decimal` es siempre "
"canónica, por lo que esta operación siempre retorna :const:`True`."
#: ../Doc/library/decimal.rst:617
msgid ""
"Return :const:`True` if the argument is a finite number, and :const:`False` "
"if the argument is an infinity or a NaN."
msgstr ""
"Retorna :const:`True` si el argumento es un número finito y :const:`False` "
"si el argumento es un valor infinito o un NaN."
#: ../Doc/library/decimal.rst:622
msgid ""
"Return :const:`True` if the argument is either positive or negative infinity "
"and :const:`False` otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un valor infinito positivo o "
"negativo y :const:`False` en caso contrario."
#: ../Doc/library/decimal.rst:627
msgid ""
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
"const:`False` otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un NaN (silencioso o señalizador) "
"y :const:`False` en caso contrario."
#: ../Doc/library/decimal.rst:632
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 ""
"Retorna :const:`True` si el argumento es un número finito *normal*. Retorna :"
"const:`False` si el argumento es cero, subnormal, infinito o un NaN."
#: ../Doc/library/decimal.rst:637
msgid ""
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
"otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un NaN silencioso y :const:`False` "
"en caso contrario."
#: ../Doc/library/decimal.rst:642
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 ""
"Retorna :const:`True` si el argumento tiene signo negativo y :const:`False` "
"en caso contrario. Ten en cuenta que tanto los ceros como los NaN pueden "
"tener signo."
#: ../Doc/library/decimal.rst:647
msgid ""
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
"otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un NaN señalizador y :const:`False` "
"en caso contrario."
#: ../Doc/library/decimal.rst:652
msgid ""
"Return :const:`True` if the argument is subnormal, and :const:`False` "
"otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es subnormal y :const:`False` en caso "
"contrario."
#: ../Doc/library/decimal.rst:657
msgid ""
"Return :const:`True` if the argument is a (positive or negative) zero and :"
"const:`False` otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un cero (positivo o negativo) y :"
"const:`False` en caso contrario."
#: ../Doc/library/decimal.rst:662
msgid ""
"Return the natural (base e) logarithm of the operand. The result is "
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
"Retorna el logaritmo natural (base e) del operando. El resultado es "
"correctamente redondeado utilizando el modo de redondeo :const:"
"`ROUND_HALF_EVEN`."
#: ../Doc/library/decimal.rst:667
msgid ""
"Return the base ten logarithm of the operand. The result is correctly "
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
"Retorna el logaritmo en base diez del operando. El resultado es "
"correctamente redondeado utilizando el modo de redondeo :const:"
"`ROUND_HALF_EVEN`."
#: ../Doc/library/decimal.rst:672
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 ""
"Para un número distinto de cero, retorna el exponente ajustado de su "
"operando como una instancia de :class:`Decimal`. Si el operando es cero, se "
"retorna ``Decimal('-Infinity')`` y se activa el flag :const:"
"`DivisionByZero`. Si el operando es infinito, se retorna "
"``Decimal('Infinity')``."
#: ../Doc/library/decimal.rst:680
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 ""
":meth:`logic_and` es una operación lógica que toma dos *operandos lógicos* "
"(consultar :ref:`logical_operands_label`). El resultado es el ``and`` dígito "
"por dígito de los dos operandos."
#: ../Doc/library/decimal.rst:686
msgid ""
":meth:`logical_invert` is a logical operation. The result is the digit-wise "
"inversion of the operand."
msgstr ""
":meth:`logic_invert` es una operación lógica. El resultado es la inversión "
"dígito a dígito del operando."
#: ../Doc/library/decimal.rst:691
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 ""
":meth:`logical_or` es una operación lógica que toma dos *operandos lógicos* "
"(consultar :ref:`logical_operands_label`). El resultado es un ``or`` dígito "
"a dígito de los dos operandos."
#: ../Doc/library/decimal.rst:697
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 ""
":meth:`logic_xor` es una operación lógica que toma dos *operandos lógicos* "
"(consultar :ref:`logical_operands_label`). El resultado es la disyunción "
"exclusiva (\"exclusive or\") dígito a dígito de ambos operandos."
#: ../Doc/library/decimal.rst:703
msgid ""
"Like ``max(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""
"Como ``max(self, other)``, excepto que la regla de redondeo del contexto se "
"aplica antes de retornar y que los valores :const:`NaN` generan una señal o "
"son ignorados (dependiendo del contexto y de si son señalizadores o "
"silenciosos)."
#: ../Doc/library/decimal.rst:710
msgid ""
"Similar to the :meth:`.max` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""
"Similar al método :meth:`.max`, pero la comparación se realiza utilizando "
"los valores absolutos de los operandos."
#: ../Doc/library/decimal.rst:715
msgid ""
"Like ``min(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""
"Como ``min(self, other)``, excepto que la regla de redondeo del contexto se "
"aplica antes de retornar y que los valores :const:`NaN` generan una señal o "
"se ignoran (según el contexto y si son señalizadores o no)."
#: ../Doc/library/decimal.rst:722
msgid ""
"Similar to the :meth:`.min` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""
"Similar al método :meth:`.min`, pero la comparación se realiza utilizando "
"los valores absolutos de los operandos."
#: ../Doc/library/decimal.rst:727
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 ""
"Retorna el número más grande representable en el contexto proporcionado (o "
"en el contexto del hilo actual si no se proporciona un contexto) que sea más "
"pequeño que el operando proporcionado."
#: ../Doc/library/decimal.rst:733
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 ""
"Retorna el número más pequeño representable en el contexto proporcionado (o "
"en el contexto del hilo actual si no se proporciona ningún contexto) que sea "
"más grande que el operando proporcionado."
#: ../Doc/library/decimal.rst:739
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 ""
"Si los dos operandos no son iguales, retorna el número más cercano al primer "
"operando en la dirección del segundo operando. Si ambos operandos son "
You can’t perform that action at this time.