Minor improvements, fixups and wording changes everywhere.

Doc/lib/libdecimal.tex

@@ -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")}.
@@ -423,12 +423,13 @@ have a number of more specialized methods:
 \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
+    if sign:
+        build(trailneg)
     for i in range(places):
         build(next())
     build(dp)
-    try:
-        while 1:
-            for i in range(3):
+    i = 0
+    while digits:
         build(next())
-            if digits:
+        i += 1
+        if i == 3:
+            i = 0
             build(sep)
-    except IndexError:
-        pass
     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}