mirror of
https://github.com/python/cpython.git
synced 2025-09-26 18:29:57 +00:00
Minor improvements, fixups and wording changes everywhere.
This commit is contained in:
Raymond Hettinger
parent
ad5206fc02
commit
65df07bf23
1 changed files with 169 additions and 163 deletions
|
|
@ -21,7 +21,7 @@ arithmetic. It offers several advantages over the \class{float()} datatype:
|
|||
\begin{itemize}
|
||||
|
||||
\item Decimal numbers can be represented exactly. In contrast, numbers like
|
||||
\constant{1.1} do not have an exact representations in binary floating point.
|
||||
\constant{1.1} do not have an exact representation in binary floating point.
|
||||
End users typically wound not expect \constant{1.1} to display as
|
||||
\constant{1.1000000000000001} as it does with binary floating point.
|
||||
|
||||
|
|
@ -70,14 +70,14 @@ trailing zeroes. Decimals also include special values such as
|
|||
also differentiates \constant{-0} from \constant{+0}.
|
||||
|
||||
The context for arithmetic is an environment specifying precision, rounding
|
||||
rules, limits on exponents, flags that indicate the results of operations,
|
||||
and trap enablers which determine whether signals are to be treated as
|
||||
rules, limits on exponents, flags indicating the results of operations,
|
||||
and trap enablers which determine whether signals are treated as
|
||||
exceptions. Rounding options include \constant{ROUND_CEILING},
|
||||
\constant{ROUND_DOWN}, \constant{ROUND_FLOOR}, \constant{ROUND_HALF_DOWN},
|
||||
\constant{ROUND_HALF_EVEN}, \constant{ROUND_HALF_UP}, and \constant{ROUND_UP}.
|
||||
|
||||
Signals are types of information that arise during the course of a
|
||||
computation. Depending on the needs of the application, some signals may be
|
||||
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: \constant{Clamped}, \constant{InvalidOperation},
|
||||
\constant{DivisionByZero}, \constant{Inexact}, \constant{Rounded},
|
||||
|
|
@ -104,26 +104,27 @@ needs to reset them before monitoring a calculation.
|
|||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
\subsection{Quick-start Tutorial \label{decimal-tutorial}}
|
||||
|
||||
The normal start to using decimals is to import the module, and then use
|
||||
\function{getcontext()} to view the context and, if necessary, set the context
|
||||
precision, rounding, or trap enablers:
|
||||
The usual start to using decimals is importing the module, viewing the current
|
||||
context with \function{getcontext()} and, if necessary, setting new values
|
||||
for precision, rounding, or enabled traps:
|
||||
|
||||
\begin{verbatim}
|
||||
>>> from decimal import *
|
||||
>>> getcontext()
|
||||
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
|
||||
capitals=1, flags=[], traps=[])
|
||||
capitals=1, flags=[], traps=[Overflow, InvalidOperation,
|
||||
DivisionByZero])
|
||||
|
||||
>>> getcontext().prec = 7
|
||||
>>> getcontext().prec = 7 # Set a new precision
|
||||
\end{verbatim}
|
||||
|
||||
|
||||
Decimal instances can be constructed from integers, strings or tuples. To
|
||||
create a Decimal from a \class{float}, first convert it to a string. This
|
||||
serves as an explicit reminder of the details of the conversion (including
|
||||
representation error). Malformed strings signal \constant{InvalidOperation}
|
||||
and return a special kind of Decimal called a \constant{NaN} which stands for
|
||||
``Not a number''. Positive and negative \constant{Infinity} is yet another
|
||||
special kind of Decimal.
|
||||
representation error). Decimal numbers include special values such as
|
||||
\constant{NaN} which stands for ``Not a number'', positive and negative
|
||||
\constant{Infinity}, and \constant{-0}.
|
||||
|
||||
\begin{verbatim}
|
||||
>>> Decimal(10)
|
||||
|
|
@ -140,14 +141,13 @@ Decimal("NaN")
|
|||
Decimal("-Infinity")
|
||||
\end{verbatim}
|
||||
|
||||
Creating decimals is unaffected by context precision. Their level of
|
||||
significance is completely determined by the number of digits input. It is
|
||||
the arithmetic operations that are governed by context.
|
||||
|
||||
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.
|
||||
|
||||
\begin{verbatim}
|
||||
>>> getcontext().prec = 6
|
||||
>>> Decimal('3.0000')
|
||||
Decimal("3.0000")
|
||||
>>> Decimal('3.0')
|
||||
Decimal("3.0")
|
||||
>>> Decimal('3.1415926535')
|
||||
|
|
@ -159,6 +159,7 @@ Decimal("5.85987")
|
|||
Decimal("5.85988")
|
||||
\end{verbatim}
|
||||
|
||||
|
||||
Decimals interact well with much of the rest of python. Here is a small
|
||||
decimal floating point flying circus:
|
||||
|
||||
|
|
@ -190,10 +191,24 @@ Decimal("2.5058")
|
|||
Decimal("0.77")
|
||||
\end{verbatim}
|
||||
|
||||
The \function{getcontext()} function accesses the current context. This one
|
||||
context is sufficient for many applications; however, for more advanced work,
|
||||
multiple contexts can be created using the Context() constructor. To make a
|
||||
new context active, use the \function{setcontext()} function.
|
||||
The \method{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:
|
||||
|
||||
\begin{verbatim}
|
||||
>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
|
||||
Decimal("7.32")
|
||||
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
|
||||
Decimal("8")
|
||||
\end{verbatim}
|
||||
|
||||
As shown above, the \function{getcontext()} function accesses the current
|
||||
context and allows the settings to be changed. This approach meets the
|
||||
needs of most applications.
|
||||
|
||||
For more advanced work, it may be useful to create alternate contexts using
|
||||
the Context() constructor. To make an alternate active, use the
|
||||
\function{setcontext()} function.
|
||||
|
||||
In accordance with the standard, the \module{Decimal} module provides two
|
||||
ready to use standard contexts, \constant{BasicContext} and
|
||||
|
|
@ -205,17 +220,19 @@ because many of the traps are enabled:
|
|||
>>> myothercontext
|
||||
Context(prec=60, rounding=ROUND_HALF_DOWN, Emin=-999999999, Emax=999999999,
|
||||
capitals=1, flags=[], traps=[])
|
||||
>>> ExtendedContext
|
||||
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
|
||||
capitals=1, flags=[], traps=[])
|
||||
>>> setcontext(myothercontext)
|
||||
>>> Decimal(1) / Decimal(7)
|
||||
Decimal("0.142857142857142857142857142857142857142857142857142857142857")
|
||||
|
||||
>>> ExtendedContext
|
||||
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
|
||||
capitals=1, flags=[], traps=[])
|
||||
>>> setcontext(ExtendedContext)
|
||||
>>> Decimal(1) / Decimal(7)
|
||||
Decimal("0.142857143")
|
||||
>>> Decimal(42) / Decimal(0)
|
||||
Decimal("Infinity")
|
||||
|
||||
>>> setcontext(BasicContext)
|
||||
>>> Decimal(42) / Decimal(0)
|
||||
Traceback (most recent call last):
|
||||
|
|
@ -224,14 +241,15 @@ Traceback (most recent call last):
|
|||
DivisionByZero: x / 0
|
||||
\end{verbatim}
|
||||
|
||||
Besides using contexts to control precision, rounding, and trapping signals,
|
||||
they can be used to monitor flags which give information collected during
|
||||
computation. The flags remain set until explicitly cleared, so it is best to
|
||||
clear the flags before each set of monitored computations by using the
|
||||
\method{clear_flags()} method.
|
||||
|
||||
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 \method{clear_flags()} method.
|
||||
|
||||
\begin{verbatim}
|
||||
>>> setcontext(ExtendedContext)
|
||||
>>> getcontext().clear_flags()
|
||||
>>> Decimal(355) / Decimal(113)
|
||||
Decimal("3.14159292")
|
||||
>>> getcontext()
|
||||
|
|
@ -239,10 +257,9 @@ Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
|
|||
capitals=1, flags=[Inexact, Rounded], traps=[])
|
||||
\end{verbatim}
|
||||
|
||||
The \var{flags} entry shows that the rational approximation to
|
||||
\constant{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).
|
||||
The \var{flags} entry shows that the rational approximation to \constant{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).
|
||||
|
||||
Individual traps are set using the dictionary in the \member{traps}
|
||||
field of a context:
|
||||
|
|
@ -259,26 +276,11 @@ Traceback (most recent call last):
|
|||
DivisionByZero: x / 0
|
||||
\end{verbatim}
|
||||
|
||||
To turn all the traps on or off all at once, use a loop. Also, the
|
||||
\method{dict.update()} method is useful for changing a handfull of values.
|
||||
|
||||
\begin{verbatim}
|
||||
>>> getcontext.clear_flags()
|
||||
>>> for sig in getcontext().traps:
|
||||
... getcontext().traps[sig] = 1
|
||||
|
||||
>>> getcontext().traps.update({Rounded:0, Inexact:0, Subnormal:0})
|
||||
>>> getcontext()
|
||||
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
|
||||
capitals=1, flags=[], traps=[Clamped, Underflow,
|
||||
InvalidOperation, DivisionByZero, Overflow])
|
||||
\end{verbatim}
|
||||
|
||||
Applications typically set the context once at the beginning of a program
|
||||
and no further changes are needed. For many applications, the data resides
|
||||
in a resource external to the program and is converted to \class{Decimal} with
|
||||
a single cast inside a loop. Afterwards, decimals are as easily manipulated
|
||||
as other Python numeric types.
|
||||
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.
|
||||
|
||||
|
||||
|
||||
|
|
@ -308,20 +310,18 @@ as other Python numeric types.
|
|||
|
||||
If \var{value} is a \class{tuple}, it should have three components,
|
||||
a sign (\constant{0} for positive or \constant{1} for negative),
|
||||
a \class{tuple} of digits, and an exponent represented as an integer.
|
||||
For example, \samp{Decimal((0, (1, 4, 1, 4), -3))} returns
|
||||
\code{Decimal("1.414")}.
|
||||
a \class{tuple} of digits, and an integer exponent. For example,
|
||||
\samp{Decimal((0, (1, 4, 1, 4), -3))} returns \code{Decimal("1.414")}.
|
||||
|
||||
The supplied \var{context} or, if not specified, the current context
|
||||
governs only the handling of malformed strings not conforming to the
|
||||
numeric string syntax. If the context traps \constant{InvalidOperation},
|
||||
an exception is raised; otherwise, the constructor returns a new Decimal
|
||||
with the value of \constant{NaN}.
|
||||
The \var{context} precision does not affect how many digits are stored.
|
||||
That is determined exclusively by the number of digits in \var{value}. For
|
||||
example, \samp{Decimal("3.00000")} records all five zeroes even if the
|
||||
context precision is only three.
|
||||
|
||||
The context serves no other purpose. The number of significant digits
|
||||
recorded is determined solely by the \var{value} and the \var{context}
|
||||
precision is not a factor. For example, \samp{Decimal("3.0000")} records
|
||||
all four zeroes even if the context precision is only three.
|
||||
The purpose of the \var{context} argument is determining what to do if
|
||||
\var{value} is a malformed string. If the context traps
|
||||
\constant{InvalidOperation}, an exception is raised; otherwise, the
|
||||
constructor returns a new Decimal with the value of \constant{NaN}.
|
||||
|
||||
Once constructed, \class{Decimal} objects are immutable.
|
||||
\end{classdesc}
|
||||
|
|
@ -334,13 +334,13 @@ compared, sorted, and coerced to another type (such as \class{float}
|
|||
or \class{long}).
|
||||
|
||||
In addition to the standard numeric properties, decimal floating point objects
|
||||
have a number of more specialized methods:
|
||||
also have a number of specialized methods:
|
||||
|
||||
\begin{methoddesc}{adjusted}{}
|
||||
Return the adjusted exponent after shifting out the coefficient's rightmost
|
||||
digits until only the lead digit remains: \code{Decimal("321e+5").adjusted()}
|
||||
returns seven. Used for determining the place value of the most significant
|
||||
digit.
|
||||
returns seven. Used for determining the position of the most significant
|
||||
digit with respect to the decimal point.
|
||||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{as_tuple}{}
|
||||
|
|
@ -389,7 +389,7 @@ have a number of more specialized methods:
|
|||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{remainder_near}{other\optional{, context}}
|
||||
Computed the modulo as either a positive or negative value depending
|
||||
Computes the modulo as either a positive or negative value depending
|
||||
on which is closest to zero. For instance,
|
||||
\samp{Decimal(10).remainder_near(6)} returns \code{Decimal("-2")}
|
||||
which is closer to zero than \code{Decimal("4")}.
|
||||
|
|
@ -422,13 +422,14 @@ have a number of more specialized methods:
|
|||
current context.
|
||||
\end{methoddesc}
|
||||
|
||||
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
\subsection{Context objects \label{decimal-decimal}}
|
||||
|
||||
Contexts are environments for arithmetic operations. They govern the precision,
|
||||
rules for rounding, determine which signals are treated as exceptions, and set limits
|
||||
on the range for exponents.
|
||||
Contexts are environments for arithmetic operations. They govern precision,
|
||||
set rules for rounding, determine which signals are treated as exceptions, and
|
||||
limit the range for exponents.
|
||||
|
||||
Each thread has its own current context which is accessed or changed using
|
||||
the \function{getcontext()} and \function{setcontext()} functions:
|
||||
|
|
@ -464,11 +465,11 @@ In addition, the module provides three pre-made contexts:
|
|||
Because the trapped are disabled, this context is useful for applications
|
||||
that prefer to have result value of \constant{NaN} or \constant{Infinity}
|
||||
instead of raising exceptions. This allows an application to complete a
|
||||
run in the presense of conditions that would otherwise halt the program.
|
||||
run in the presence of conditions that would otherwise halt the program.
|
||||
\end{classdesc*}
|
||||
|
||||
\begin{classdesc*}{DefaultContext}
|
||||
This class is used by the \class{Context} constructor as a prototype for
|
||||
This context is used by the \class{Context} constructor as a prototype for
|
||||
new contexts. Changing a field (such a precision) has the effect of
|
||||
changing the default for new contexts creating by the \class{Context}
|
||||
constructor.
|
||||
|
|
@ -479,10 +480,10 @@ In addition, the module provides three pre-made contexts:
|
|||
as it would require thread synchronization to prevent race conditions.
|
||||
|
||||
In single threaded environments, it is preferable to not use this context
|
||||
at all. Instead, simply create contexts explicitly. This is especially
|
||||
important because the default values context may change between releases
|
||||
(with initial release having precision=28, rounding=ROUND_HALF_EVEN,
|
||||
cleared flags, and no traps enabled).
|
||||
at all. Instead, simply create contexts explicitly as described below.
|
||||
|
||||
The default values are precision=28, rounding=ROUND_HALF_EVEN, and enabled
|
||||
traps for Overflow, InvalidOperation, and DivisionByZero.
|
||||
\end{classdesc*}
|
||||
|
||||
|
||||
|
|
@ -508,19 +509,20 @@ with the \class{Context} constructor.
|
|||
\constant{ROUND_HALF_UP} (away from zero), or
|
||||
\constant{ROUND_UP} (away from zero).
|
||||
|
||||
The \var{traps} and \var{flags} fields are mappings from signals
|
||||
to either \constant{0} or \constant{1}.
|
||||
The \var{traps} and \var{flags} fields list any signals to be set.
|
||||
Generally, new contexts should only set traps and leave the flags clear.
|
||||
|
||||
The \var{Emin} and \var{Emax} fields are integers specifying the outer
|
||||
limits allowable for exponents.
|
||||
|
||||
The \var{capitals} field is either \constant{0} or \constant{1} (the
|
||||
default). If set to \constant{1}, exponents are printed with a capital
|
||||
\constant{E}; otherwise, lowercase is used: \constant{Decimal('6.02e+23')}.
|
||||
\constant{E}; otherwise, a lowercase \constant{e} is used:
|
||||
\constant{Decimal('6.02e+23')}.
|
||||
\end{classdesc}
|
||||
|
||||
The \class{Context} class defines several general methods as well as a
|
||||
large number of methods for doing arithmetic directly from the context.
|
||||
The \class{Context} class defines several general purpose methods as well as a
|
||||
large number of methods for doing arithmetic directly in a given context.
|
||||
|
||||
\begin{methoddesc}{clear_flags}{}
|
||||
Sets all of the flags to \constant{0}.
|
||||
|
|
@ -531,18 +533,18 @@ large number of methods for doing arithmetic directly from the context.
|
|||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{create_decimal}{num}
|
||||
Creates a new Decimal instance but using \var{self} as context.
|
||||
Unlike the \class{Decimal} constructor, context precision,
|
||||
Creates a new Decimal instance from \var{num} but using \var{self} as
|
||||
context. Unlike the \class{Decimal} constructor, the context precision,
|
||||
rounding method, flags, and traps are applied to the conversion.
|
||||
|
||||
This is useful because constants are often given to a greater
|
||||
precision than is needed by the application.
|
||||
This is useful because constants are often given to a greater precision than
|
||||
is needed by the application.
|
||||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{Etiny}{}
|
||||
Returns a value equal to \samp{Emin - prec + 1} which is the minimum
|
||||
exponent value for subnormal results. When underflow occurs, the
|
||||
exponont is set to \constant{Etiny}.
|
||||
exponent is set to \constant{Etiny}.
|
||||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{Etop}{}
|
||||
|
|
@ -553,7 +555,7 @@ large number of methods for doing arithmetic directly from the context.
|
|||
The usual approach to working with decimals is to create \class{Decimal}
|
||||
instances and then apply arithmetic operations which take place within the
|
||||
current context for the active thread. An alternate approach is to use
|
||||
context methods for calculating within s specific context. The methods are
|
||||
context methods for calculating within a specific context. The methods are
|
||||
similar to those for the \class{Decimal} class and are only briefly recounted
|
||||
here.
|
||||
|
||||
|
|
@ -586,14 +588,14 @@ here.
|
|||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{max}{x, y}
|
||||
Compare two values numerically and returns the maximum.
|
||||
Compare two values numerically and return the maximum.
|
||||
|
||||
If they are numerically equal then the left-hand operand is chosen as the
|
||||
result.
|
||||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{min}{x, y}
|
||||
Compare two values numerically and returns the minimum.
|
||||
Compare two values numerically and return the minimum.
|
||||
|
||||
If they are numerically equal then the left-hand operand is chosen as the
|
||||
result.
|
||||
|
|
@ -636,14 +638,14 @@ here.
|
|||
\end{methoddesc}
|
||||
|
||||
\begin{methoddesc}{quantize}{x, y}
|
||||
Returns a value equal to \var{x} after rounding and having the
|
||||
exponent of v\var{y}.
|
||||
Returns a value equal to \var{x} after rounding and having the exponent of
|
||||
\var{y}.
|
||||
|
||||
Unlike other operations, if the length of the coefficient after the quantize
|
||||
operation would be greater than precision then an
|
||||
operation would be greater than precision, then an
|
||||
\constant{InvalidOperation} is signaled. This guarantees that, unless there
|
||||
is an error condition, the exponent of the result of a quantize is always
|
||||
equal to that of the right-hand operand.
|
||||
is an error condition, the quantized exponent is always equal to that of the
|
||||
right-hand operand.
|
||||
|
||||
Also unlike other operations, quantize never signals Underflow, even
|
||||
if the result is subnormal and inexact.
|
||||
|
|
@ -712,7 +714,7 @@ the next computation.
|
|||
|
||||
If the context's trap enabler is set for the signal, then the condition
|
||||
causes a Python exception to be raised. For example, if the
|
||||
\class{DivisionByZero} trap is set, the a \exception{DivisionByZero}
|
||||
\class{DivisionByZero} trap is set, then a \exception{DivisionByZero}
|
||||
exception is raised upon encountering the condition.
|
||||
|
||||
|
||||
|
|
@ -725,24 +727,25 @@ exception is raised upon encountering the condition.
|
|||
\end{classdesc*}
|
||||
|
||||
\begin{classdesc*}{DecimalException}
|
||||
Base class for other signals.
|
||||
Base class for other signals and is a subclass of
|
||||
\exception{ArithmeticError}.
|
||||
\end{classdesc*}
|
||||
|
||||
\begin{classdesc*}{DivisionByZero}
|
||||
Signals the division of a non-infinite number by zero.
|
||||
|
||||
Can occur with division, modulo division, or when raising a number to
|
||||
a negative power. If this signal is not trapped, return
|
||||
\constant{Infinity} or \constant{-Infinity} with sign determined by
|
||||
Can occur with division, modulo division, or when raising a number to a
|
||||
negative power. If this signal is not trapped, returns
|
||||
\constant{Infinity} or \constant{-Infinity} with the sign determined by
|
||||
the inputs to the calculation.
|
||||
\end{classdesc*}
|
||||
|
||||
\begin{classdesc*}{Inexact}
|
||||
Indicates that rounding occurred and the result is not exact.
|
||||
|
||||
Signals whenever non-zero digits were discarded during rounding.
|
||||
The rounded result is returned. The signal flag or trap is used
|
||||
to detect when results are inexact.
|
||||
Signals when non-zero digits were discarded during rounding. The rounded
|
||||
result is returned. The signal flag or trap is used to detect when
|
||||
results are inexact.
|
||||
\end{classdesc*}
|
||||
|
||||
\begin{classdesc*}{InvalidOperation}
|
||||
|
|
@ -820,7 +823,7 @@ The following table summarizes the hierarchy of signals:
|
|||
The \function{getcontext()} function accesses a different \class{Context}
|
||||
object for each thread. Having separate thread contexts means that threads
|
||||
may make changes (such as \code{getcontext.prec=10}) without interfering with
|
||||
other threads and without needing mutexes.
|
||||
other threads.
|
||||
|
||||
Likewise, the \function{setcontext()} function automatically assigns its target
|
||||
to the current thread.
|
||||
|
|
@ -829,20 +832,19 @@ If \function{setcontext()} has not been called before \function{getcontext()},
|
|||
then \function{getcontext()} will automatically create a new context for use
|
||||
in the current thread.
|
||||
|
||||
The new context is copied from a prototype context called \var{DefaultContext}.
|
||||
To control the defaults so that each thread will use the same values
|
||||
throughout the application, directly modify the \var{DefaultContext} object.
|
||||
This should be done \emph{before} any threads are started so that there won't
|
||||
be a race condition with threads calling \function{getcontext()}. For example:
|
||||
The new context is copied from a prototype context called
|
||||
\var{DefaultContext}. To control the defaults so that each thread will use the
|
||||
same values throughout the application, directly modify the
|
||||
\var{DefaultContext} object. This should be done \emph{before} any threads are
|
||||
started so that there won't be a race condition between threads calling
|
||||
\function{getcontext()}. For example:
|
||||
|
||||
\begin{verbatim}
|
||||
# Set applicationwide defaults for all threads about to be launched
|
||||
DefaultContext.prec=12
|
||||
DefaultContext.rounding=ROUND_DOWN
|
||||
DefaultContext.traps=dict.fromkeys(Signals, 0)
|
||||
DefaultContext = Context(prec=12, rounding=ROUND_DOWN, traps=[InvalidOperation])
|
||||
setcontext(DefaultContext)
|
||||
|
||||
# Now start all of the threads
|
||||
# Afterward, the threads can be started
|
||||
t1.start()
|
||||
t2.start()
|
||||
t3.start()
|
||||
|
|
@ -854,49 +856,49 @@ t3.start()
|
|||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
\subsection{Recipes \label{decimal-recipes}}
|
||||
|
||||
Here are some functions demonstrating ways to work with the
|
||||
\class{Decimal} class:
|
||||
Here are a few recipes that serve as utility functions and that demonstrate
|
||||
ways to work with the \class{Decimal} class:
|
||||
|
||||
\begin{verbatim}
|
||||
from decimal import Decimal, getcontext
|
||||
getcontext().prec = 28
|
||||
|
||||
def moneyfmt(value, places=2, curr='$', sep=',', dp='.', pos='', neg='-'):
|
||||
def moneyfmt(value, places=2, curr='', sep=',', dp='.',
|
||||
pos='', neg='-', trailneg=''):
|
||||
"""Convert Decimal to a money formatted string.
|
||||
|
||||
places: required number of places after the decimal point
|
||||
curr: optional currency symbol before the sign (may be blank)
|
||||
sep: optional grouping separator (comma, period, or blank)
|
||||
dp: decimal point indicator (comma or period)
|
||||
only set to blank if places is zero
|
||||
pos: optional sign for positive numbers ("+" or blank)
|
||||
neg: optional sign for negative numbers ("-" or blank)
|
||||
leave blank to separately add brackets or a trailing minus
|
||||
only specify as blank when places is zero
|
||||
pos: optional sign for positive numbers: "+", space or blank
|
||||
neg: optional sign for negative numbers: "-", "(", space or blank
|
||||
trailneg:optional trailing minus indicator: "-", ")", space or blank
|
||||
|
||||
>>> d = Decimal('-1234567.8901')
|
||||
>>> moneyfmt(d)
|
||||
>>> moneyfmt(d, curr='$')
|
||||
'-$1,234,567.89'
|
||||
>>> moneyfmt(d, places=0, curr='', sep='.', dp='')
|
||||
'-1.234.568'
|
||||
>>> '($%s)' % moneyfmt(d, curr='', neg='')
|
||||
>>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')
|
||||
'1.234.568-'
|
||||
>>> moneyfmt(d, curr='$', neg='(', trailneg=')')
|
||||
'($1,234,567.89)'
|
||||
|
||||
"""
|
||||
q = Decimal((0, (1,), -places)) # 2 places --> '0.01'
|
||||
sign, digits, exp = value.quantize(q).as_tuple()
|
||||
result = []
|
||||
digits = map(str, digits)
|
||||
build, next = result.append, digits.pop
|
||||
build, next = result.append, digits.pop
|
||||
if sign:
|
||||
build(trailneg)
|
||||
for i in range(places):
|
||||
build(next())
|
||||
build(dp)
|
||||
try:
|
||||
while 1:
|
||||
for i in range(3):
|
||||
build(next())
|
||||
if digits:
|
||||
build(sep)
|
||||
except IndexError:
|
||||
pass
|
||||
i = 0
|
||||
while digits:
|
||||
build(next())
|
||||
i += 1
|
||||
if i == 3:
|
||||
i = 0
|
||||
build(sep)
|
||||
build(curr)
|
||||
if sign:
|
||||
build(neg)
|
||||
|
|
@ -910,18 +912,19 @@ def pi():
|
|||
|
||||
>>> print pi()
|
||||
3.141592653589793238462643383
|
||||
|
||||
"""
|
||||
getcontext().prec += 2 # extra digits for intermediate steps
|
||||
three = Decimal(3) # substitute "three=3.0" for regular floats
|
||||
lastc, t, c, n, na, d, da = 0, three, 3, 1, 0, 0, 24
|
||||
while c != lastc:
|
||||
lastc = c
|
||||
lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
n, na = n+na, na+8
|
||||
d, da = d+da, da+32
|
||||
t = (t * n) / d
|
||||
c += t
|
||||
s += t
|
||||
getcontext().prec -= 2
|
||||
return c + 0 # Adding zero causes rounding to the new precision
|
||||
return +s # unary plus applies the new precision
|
||||
|
||||
def exp(x):
|
||||
"""Return e raised to the power of x. Result type matches input type.
|
||||
|
|
@ -934,17 +937,18 @@ def exp(x):
|
|||
7.38905609893
|
||||
>>> print exp(2+0j)
|
||||
(7.38905609893+0j)
|
||||
|
||||
"""
|
||||
getcontext().prec += 2 # extra digits for intermediate steps
|
||||
i, laste, e, fact, num = 0, 0, 1, 1, 1
|
||||
while e != laste:
|
||||
laste = e
|
||||
getcontext().prec += 2
|
||||
i, lasts, s, fact, num = 0, 0, 1, 1, 1
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
i += 1
|
||||
fact *= i
|
||||
num *= x
|
||||
e += num / fact
|
||||
s += num / fact
|
||||
getcontext().prec -= 2
|
||||
return e + 0
|
||||
return +s
|
||||
|
||||
def cos(x):
|
||||
"""Return the cosine of x as measured in radians.
|
||||
|
|
@ -955,18 +959,19 @@ def cos(x):
|
|||
0.87758256189
|
||||
>>> print cos(0.5+0j)
|
||||
(0.87758256189+0j)
|
||||
|
||||
"""
|
||||
getcontext().prec += 2 # extra digits for intermediate steps
|
||||
i, laste, e, fact, num, sign = 0, 0, 1, 1, 1, 1
|
||||
while e != laste:
|
||||
laste = e
|
||||
getcontext().prec += 2
|
||||
i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
i += 2
|
||||
fact *= i * (i-1)
|
||||
num *= x * x
|
||||
sign *= -1
|
||||
e += num / fact * sign
|
||||
s += num / fact * sign
|
||||
getcontext().prec -= 2
|
||||
return e + 0
|
||||
return +s
|
||||
|
||||
def sin(x):
|
||||
"""Return the cosine of x as measured in radians.
|
||||
|
|
@ -977,17 +982,18 @@ def sin(x):
|
|||
0.479425538604
|
||||
>>> print sin(0.5+0j)
|
||||
(0.479425538604+0j)
|
||||
|
||||
"""
|
||||
getcontext().prec += 2 # extra digits for intermediate steps
|
||||
i, laste, e, fact, num, sign = 1, 0, x, 1, x, 1
|
||||
while e != laste:
|
||||
laste = e
|
||||
getcontext().prec += 2
|
||||
i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
i += 2
|
||||
fact *= i * (i-1)
|
||||
num *= x * x
|
||||
sign *= -1
|
||||
e += num / fact * sign
|
||||
s += num / fact * sign
|
||||
getcontext().prec -= 2
|
||||
return e + 0
|
||||
return +s
|
||||
|
||||
\end{verbatim}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue