Hello community,
here is the log from the commit of package python-uncertainties for
openSUSE:Factory checked in at 2018-09-07 15:41:41
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-uncertainties (Old)
and /work/SRC/openSUSE:Factory/.python-uncertainties.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-uncertainties"
Fri Sep 7 15:41:41 2018 rev:3 rq:633740 version:3.0.2
Changes:
--------
---
/work/SRC/openSUSE:Factory/python-uncertainties/python-uncertainties.changes
2017-08-04 11:58:51.496046632 +0200
+++
/work/SRC/openSUSE:Factory/.python-uncertainties.new/python-uncertainties.changes
2018-09-07 15:41:48.806381211 +0200
@@ -1,0 +2,18 @@
+Thu Sep 6 12:52:28 UTC 2018 - Jan Engelhardt <jeng...@inai.de>
+
+- Trim non-RPM markup from description. Ensure neutrality of
+ description.
+
+-------------------------------------------------------------------
+Wed Sep 5 03:56:06 UTC 2018 - a...@gmx.de
+
+- specfile:
+ * update copyright year
+ * remove devel from noarch
+
+- update to version 3.0.2:
+ * This update contains only documentation updates (and new or
+ updated code comments). Added explicit information on NaN
+ handling.
+
+-------------------------------------------------------------------
Old:
----
uncertainties-3.0.1.tar.gz
New:
----
uncertainties-3.0.2.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-uncertainties.spec ++++++
--- /var/tmp/diff_new_pack.uVhyWl/_old 2018-09-07 15:41:49.462380509 +0200
+++ /var/tmp/diff_new_pack.uVhyWl/_new 2018-09-07 15:41:49.466380505 +0200
@@ -1,7 +1,7 @@
#
# spec file for package python-uncertainties
#
-# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -18,33 +18,26 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-uncertainties
-Version: 3.0.1
+Version: 3.0.2
Release: 0
Summary: Uncertainties on the Quantities Involved (aka "Error
Propagation")
License: BSD-3-Clause
Group: Development/Languages/Python
-Url: http://pythonhosted.org/uncertainties/
+URL: http://pythonhosted.org/uncertainties/
Source:
https://files.pythonhosted.org/packages/source/u/uncertainties/uncertainties-%{version}.tar.gz
-BuildRequires: %{python_module devel}
BuildRequires: %{python_module setuptools}
BuildRequires: fdupes
BuildRequires: python-rpm-macros
+BuildArch: noarch
%if 0%{?suse_version}
Recommends: python-numpy
%endif
-BuildRoot: %{_tmppath}/%{name}-%{version}-build
-BuildArch: noarch
-
%python_subpackages
%description
-``uncertainties`` allows **calculations** such as (2 +/- 0.1)*2 = 4 +/-
-0.2 to be **performed transparently**. Much more complex mathematical
-expressions involving numbers with uncertainties can also be evaluated
-directly.
-
-The ``uncertainties`` package **takes the pain and complexity out**
-of uncertainty calculations.
+"uncertainties" allows calculations such as (2±0.1)*2 = 4±0.2 to be
+performed transparently. Much more complex mathematical expressions
+involving numbers with uncertainties can also be evaluated directly.
%prep
%setup -q -n uncertainties-%{version}
@@ -56,8 +49,8 @@
%python_install
%files %{python_files}
-%defattr(-,root,root,-)
-%doc LICENSE.txt README.rst
+%license LICENSE.txt
+%doc README.rst
%{python_sitelib}/uncertainties/
%{python_sitelib}/uncertainties-%{version}-py*.egg-info
++++++ uncertainties-3.0.1.tar.gz -> uncertainties-3.0.2.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/PKG-INFO
new/uncertainties-3.0.2/PKG-INFO
--- old/uncertainties-3.0.1/PKG-INFO 2016-08-15 22:52:30.000000000 +0200
+++ new/uncertainties-3.0.2/PKG-INFO 2018-01-14 17:00:56.000000000 +0100
@@ -1,11 +1,12 @@
Metadata-Version: 1.1
Name: uncertainties
-Version: 3.0.1
+Version: 3.0.2
Summary: Transparent calculations with uncertainties on the quantities
involved (aka error propagation); fast calculation of derivatives
-Home-page: http://pythonhosted.org/uncertainties/
+Home-page: http://uncertainties-python-package.readthedocs.io/
Author: Eric O. LEBIGOT (EOL)
Author-email: eric.lebi...@normalesup.org
License: This software can be used under one of the following two licenses:
(1) The Revised BSD License. (2) Any other license, as long as it is obtained
from the original author.
+Description-Content-Type: UNKNOWN
Description: Overview
========
@@ -94,7 +95,7 @@
=======================
Installation instructions are available on the `main web site
- <http://pythonhosted.org/uncertainties/#installation-and-download>`_
+
<http://uncertainties-python-package.readthedocs.io/en/latest/index.html#installation-and-download>`_
for this package.
Contact
@@ -108,7 +109,7 @@
Main changes:
- - 3.0: Massive speedup for operations involving large numbers of
numbers with uncertainty, like ``sum(ufloat(1, 1) for _ in xrange(100000))``
(this is about 5,000 times faster than before).
+ - 3.0: Massive speedup for some operations involving large numbers of
numbers with uncertainty, like ``sum(ufloat(1, 1) for _ in xrange(100000))``
(this is about 5,000 times faster than before).
- 2.4.8: Friendlier completions in Python shells, etc.: internal
functions should not appear anymore (for the user modules: ``uncertainties``,
``uncertainties.umath`` and ``uncertainties.unumpy``). Parsing the shorthand
notation (e.g. ``3.1(2)``) now works with infinite values (e.g. ``-inf(inf)``);
this mirrors the ability to print such numbers with uncertainty. The Particle
Data Group rounding rule is applied in more cases (e.g. printing 724.2±26.2 now
gives ``724±26``). The shorthand+LaTeX formatting of numbers with an infinite
nominal value is fixed. ``uncertainties.unumpy.matrix`` now uses ``.std_devs``
instead of ``.std_devs()``, for consistency with floats with uncertainty
(automatic conversion of code added to ``uncertainties.1to2``).
- 2.4.7: String formatting now works for ``(-)inf+/-...`` numbers.
- 2.4.5: String formatting now works for ``NaN+/-...`` numbers.
@@ -229,17 +230,16 @@
``covariance_matrix()``.
.. _Python: http://docs.python.org/tutorial/interpreter.html
- .. _IPython: http://ipython.scipy.org/
+ .. _IPython: http://ipython.readthedocs.io/en/stable/
.. _NumPy: http://numpy.scipy.org/
.. _math: http://docs.python.org/library/math.html
.. _PEP 8: http://www.python.org/dev/peps/pep-0008/
.. _error propagation theory:
http://en.wikipedia.org/wiki/Propagation_of_uncertainty
.. _Eric O. LEBIGOT (EOL): mailto:eric.lebi...@normalesup.org
.. _PayPal:
https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4TK7KNDTEDT4S
- .. _main website: http://pythonhosted.org/uncertainties/
- .. _code updater:
http://pythonhosted.org/uncertainties/#migration-from-version-1-to-version-2
- .. _formatting:
http://pythonhosted.org/uncertainties/user_guide.html#printing
-
+ .. _main website: http://uncertainties-python-package.readthedocs.io/
+ .. _code updater:
http://uncertainties-python-package.readthedocs.io/en/latest/index.html#migration-from-version-1-to-version-2
+ .. _formatting:
http://uncertainties-python-package.readthedocs.io/en/latest/user_guide.html#printing
Keywords: error propagation,uncertainties,uncertainty calculations,standard
deviation,derivatives,partial derivatives,differentiation
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
@@ -261,6 +261,7 @@
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: Jython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Education
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/README.rst
new/uncertainties-3.0.2/README.rst
--- old/uncertainties-3.0.1/README.rst 2016-08-15 22:45:56.000000000 +0200
+++ new/uncertainties-3.0.2/README.rst 2018-01-14 16:53:48.000000000 +0100
@@ -1,15 +1,17 @@
uncertainties
=============
-..
- .. image:: https://travis-ci.org/lebigot/uncertainties.png
- :target: https://travis-ci.org/lebigot/uncertainties
-This is the uncertainties Python package, which performs transparent
-calculations with uncertainties (aka "error propagation"). This package
+.. image:: https://travis-ci.org/lebigot/uncertainties.svg?branch=master
+ :target: https://travis-ci.org/lebigot/uncertainties
+.. image::
https://ci.appveyor.com/api/projects/status/j5238244myqx0a0r?svg=true
+ :target: https://ci.appveyor.com/project/lebigot/uncertainties
+
+This is the ``uncertainties`` Python package, which performs **transparent
+calculations with uncertainties** (aka "error propagation"). This package
also calculates derivatives.
-* Documentation: http://pythonhosted.org/uncertainties/
+* Documentation: http://uncertainties-python-package.readthedocs.io/
* Issues: https://github.com/lebigot/uncertainties/issues/
* Python Package Index entry: http://pypi.python.org/pypi/uncertainties/
* Code: https://github.com/lebigot/uncertainties/
@@ -17,14 +19,14 @@
GitHub
------
-The current version of the ``master*`` branches in the Github
-repository are bleeding-edge, but they are *working* versions that
-passed the tests for all versions of Python starting at 2.4.
-
The ``master`` branch is for Python 2.7+ (including Python 3+ through
``2to3``), while the ``master_python2.3`` branch is for Python 2.3 to
2.6 (with unit tests only run with Python 2.6).
+Other ``master*`` branches in the Github repository are bleeding-edge,
+but they are *working* versions that passed the tests for many versions
+of Python starting at 2.4.
+
Other branches might be present in the GitHub repository, but they are
temporary and represent work in progress that does not necessarily run
properly yet.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/doc/_templates/layout.html
new/uncertainties-3.0.2/doc/_templates/layout.html
--- old/uncertainties-3.0.1/doc/_templates/layout.html 2016-07-24
19:09:02.000000000 +0200
+++ new/uncertainties-3.0.2/doc/_templates/layout.html 2018-01-14
16:53:48.000000000 +0100
@@ -4,6 +4,10 @@
{{ toctree() }}
{% endblock %}
+{% block document %}
+{{ super() }}
+<a href="https://github.com/you";><img style="position: absolute; top: 0;
right: 0; border: 0;"
src="https://camo.githubusercontent.com/652c5b9acfaddf3a9c326fa6bde407b87f7be0f4/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f6f72616e67655f6666373630302e706e67";
alt="Fork me on GitHub" height="120 %"
data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_orange_ff7600.png";></a>
+{% endblock %}
{% block relbar1 %}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/doc/index.rst
new/uncertainties-3.0.2/doc/index.rst
--- old/uncertainties-3.0.1/doc/index.rst 2016-08-15 22:44:36.000000000
+0200
+++ new/uncertainties-3.0.2/doc/index.rst 2018-01-14 16:53:48.000000000
+0100
@@ -381,24 +381,24 @@
`donations`_: they help keep this project alive by providing positive
feedback.
-I greatly appreciated getting key technical input from Arnaud
+I greatly appreciate having gotten key technical input from Arnaud
Delobelle, Pierre Cladé, and Sebastian Walter. Patches by Pierre
Cladé, Tim Head, José Sabater Montes, Martijn Pieters, Ram Rachum,
-Christoph Deil, and Gabi Davar are gratefully acknowledged.
+Christoph Deil, Gabi Davar and Roman Yurchak are gratefully acknowledged.
I would also like to thank users who contributed with feedback and
suggestions, which greatly helped improve this program: Joaquin Abian,
Jason Moore, Martin Lutz, Víctor Terrón, Matt Newville, Matthew Peel,
Don Peterson, Mika Pflueger, Albert Puig, Abraham Lee, Arian Sanusi,
Martin Laloux, Jonathan Whitmore, Federico Vaggi, Marco A. Ferra,
-Hernan Grecco, David Zwicker, and many others.
+Hernan Grecco, David Zwicker, James Hester, Andrew Nelson, and many others.
I am also grateful to Gabi Davar and Pierre Raybaut for including it
in `Python(x,y)`_, to Christoph Gohlke for including it in his Base
distribution of `scientific Python packages`_ for Windows, and to the
-Mac OS X and Linux distribution maintainers of this package (Jonathan
-Stickel, David Paleino, Federico Ceratto, Roberto Colistete Jr, and
-Filipe Pires Alvarenga Fernandes).
+Anaconda, macOS and Linux distribution maintainers of this package (Jonathan
+Stickel, David Paleino, Federico Ceratto, Roberto Colistete Jr,
+Filipe Pires Alvarenga Fernandes, and Felix Yan).
.. index:: license
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/doc/numpy_guide.rst
new/uncertainties-3.0.2/doc/numpy_guide.rst
--- old/uncertainties-3.0.1/doc/numpy_guide.rst 2016-07-24 19:09:02.000000000
+0200
+++ new/uncertainties-3.0.2/doc/numpy_guide.rst 2018-01-14 16:53:48.000000000
+0100
@@ -122,6 +122,38 @@
:mod:`uncertainties.umath` (which is accessible through :func:`help`
or ``pydoc``).
+.. index::
+ pair: testing and operations (in arrays); NaN
+
+NaN testing and NaN-aware operations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+One particular function pertains to NaN testing: ``unumpy.isnan()``. It
+returns true for each NaN *nominal value* (and false otherwise).
+
+Since NaN±1 is *not* (the scalar) NaN, functions like
+``numpy.nanmean()`` do not skip such values. This is where
+``unumpy.isnan()`` is useful, as it can be used for masking out numbers
+with a NaN nominal value:
+
+>>> nan = float("nan")
+>>> arr = numpy.array([nan, uncertainties.ufloat(nan, 1),
uncertainties.ufloat(1, nan), 2])
+>>> arr
+array([nan, nan+/-1.0, 1.0+/-nan, 2], dtype=object)
+>>> arr[~unumpy.isnan(arr)].mean()
+1.5+/-nan
+
+or equivalently, by using masked arrays:
+
+>>> masked_arr = numpy.ma.array(arr, mask=unumpy.isnan(arr))
+>>> masked_arr.mean()
+1.5+/-nan
+
+In this case the uncertainty is NaN as it should be, because one of
+the numbers does have an undefined uncertainty, which makes the final
+uncertainty undefined (but the average is well defined). In general,
+uncertainties are not NaN and one obtains the mean of the non-NaN
+values.
.. index:: saving to file; array
.. index:: reading from file; array
@@ -154,9 +186,23 @@
columns with :func:`uncertainties.ufloat_fromstr`. The number
:data:`num_cols` of columns in the input file (1, in our example) must
be determined in advance, because NumPy requires a converter for each
-column separately:
+column separately. For Python 2:
>>> converters = dict.fromkeys(range(num_cols), uncertainties.ufloat_fromstr)
+
+For Python 3, since :func:`numpy.loadtxt` passes bytes to converters,
+they must first be converted into a string:
+
+>>> converters = dict.fromkeys(
+ range(num_cols),
+ lambda col_bytes:
uncertainties.ufloat_fromstr(col_bytes.decode("latin1")))
+
+(Latin 1 appears to in fact be the encoding used in
+:func:`numpy.savetxt` [as of NumPy 1.12]. This encoding seems
+to be the one hardcoded in :func:`numpy.compat.asbytes`.)
+
+The array can then be loaded:
+
>>> arr = numpy.loadtxt('arr.txt', converters=converters, dtype=object)
.. index:: linear algebra; additional functions, ulinalg
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/doc/tech_guide.rst
new/uncertainties-3.0.2/doc/tech_guide.rst
--- old/uncertainties-3.0.1/doc/tech_guide.rst 2016-08-15 22:44:36.000000000
+0200
+++ new/uncertainties-3.0.2/doc/tech_guide.rst 2018-01-14 16:53:48.000000000
+0100
@@ -14,7 +14,7 @@
.. index:: pickling
.. index:: saving to file; number with uncertainty
-.. index:: reading from file; number with uncertainty
+.. index:: reading from file; number with uncertainty
.. _pickling:
@@ -63,15 +63,15 @@
expressions through the linear approximation of `error propagation
theory`_.
-The standard deviations and nominal values calculated by this package
-are thus meaningful approximations as long as **uncertainties are
-small**. A more precise version of this constraint is that the final
-calculated functions must have **precise linear expansions in the region
-where the probability distribution of their variables is the largest**.
-Mathematically, this means that the linear terms of the final calculated
-functions around the nominal values of their variables should be much
-larger than the remaining higher-order terms over the region of
-significant probability (because such higher-order contributions are
+The standard deviations and nominal values calculated by this package
+are thus meaningful approximations as long as **uncertainties are
+"small"**. A more precise version of this constraint is that the final
+calculated functions must have **precise linear expansions in the region
+where the probability distribution of their variables is the largest**.
+Mathematically, this means that the linear terms of the final calculated
+functions around the nominal values of their variables should be much
+larger than the remaining higher-order terms over the region of
+significant probability (because such higher-order contributions are
neglected).
For example, calculating ``x*10`` with :data:`x` = 5±3 gives a
@@ -95,10 +95,11 @@
calculations, and can in principle yield very precise results, but
calculations are much slower than with approximation schemes.
-.. index:: NaN
+.. index::
+ pair: uncertainty; NaN
-Not-a-number uncertainties
-==========================
+NaN uncertainty
+===============
If linear `error propagation theory`_ cannot be applied, the functions
defined by :mod:`uncertainties` internally use a `not-a-number value
@@ -114,14 +115,15 @@
propagation theory is not defined** (a Monte-Carlo calculation of the
resulting random variable is more adapted to this specific case).
-However, the :mod:`uncertainties` package **correctly handles
-perfectly precise numbers**, in this case:
+However, even in this case where the derivative at the nominal value
+is infinite, the :mod:`uncertainties` package **correctly handles
+perfectly precise numbers**:
>>> umath.sqrt(ufloat(0, 0))
0.0+/-0
-gives the correct result, despite the fact that the derivative of the
-square root is not defined in zero.
+is thus the correct result, despite the fact that the derivative of
+the square root is not defined in zero.
.. _math_def_num_uncert:
@@ -277,22 +279,21 @@
derivatives required by linear error propagation theory.
Almost all the derivatives of the fundamental functions provided by
-:mod:`uncertainties` are obtained through a analytical formulas (the
+:mod:`uncertainties` are obtained through analytical formulas (the
few mathematical functions that are instead differentiated through
numerical approximation are listed in ``umath_core.num_deriv_funcs``).
-The derivatives of mathematical *expressions* are evaluated through a
-fast and precise method: :mod:`uncertainties` transparently implements
-`automatic differentiation`_ with reverse accumulation. This method
-essentially consists in keeping track of the value of derivatives, and
-in automatically applying the `chain rule
-<http://en.wikipedia.org/wiki/Chain_rule>`_. Automatic differentiation
-is often faster than symbolic differentiation and more precise than
-numerical differentiation (when used with analytical formulas, like in
-:mod:`uncertainties`).
+The derivatives of mathematical *expressions* are evaluated through a
+fast and precise method: :mod:`uncertainties` transparently implements
+`automatic differentiation`_ with reverse accumulation. This method
+essentially consists in keeping track of the value of derivatives, and
+in automatically applying the `chain rule
+<http://en.wikipedia.org/wiki/Chain_rule>`_. Automatic differentiation
+is faster than symbolic differentiation and more precise than
+numerical differentiation.
-The derivatives of any expression can be obtained with
-:mod:`uncertainties` in a simple way, as demonstrated in the :ref:`User
+The derivatives of any expression can be obtained with
+:mod:`uncertainties` in a simple way, as demonstrated in the :ref:`User
Guide <derivatives>`.
.. _variable_tracking:
@@ -315,7 +316,7 @@
Even though ``x*x`` has a non-zero uncertainty, the result has a zero
uncertainty, because it is equal to :data:`a`.
-If the variable :data:`a` above is modified, the value of :data:`poly`
+If the variable :data:`a` above is modified, the value of :data:`poly`
is not modified, as is usual in Python:
>>> a = 123
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/doc/user_guide.rst
new/uncertainties-3.0.2/doc/user_guide.rst
--- old/uncertainties-3.0.1/doc/user_guide.rst 2016-08-15 22:51:56.000000000
+0200
+++ new/uncertainties-3.0.2/doc/user_guide.rst 2018-01-14 16:53:48.000000000
+0100
@@ -89,6 +89,25 @@
The list of available mathematical functions can be obtained with the
``pydoc uncertainties.umath`` command.
+.. index::
+ pair: testing (scalar); NaN
+
+NaN testing
+-----------
+
+NaN values can appear in a number with uncertainty. Care must be
+taken with such values, as values like NaN±1, 1±NaN and NaN±NaN are by
+definition *not* NaN, which is a float.
+
+Testing whether a number with uncertainty has a **NaN nominal value** can
+be done with the provided function ``uncertainties.umath.isnan()``,
+which generalizes the standard ``math.isnan()``.
+
+Checking whether the *uncertainty* of ``x`` is NaN can be done directly
+with the standard function: ``math.isnan(x.std_dev)`` (or equivalently
+``math.isnan(x.s)``).
+
+
.. index:: arrays; simple use, matrices; simple use
.. _simple_array_use:
@@ -144,188 +163,6 @@
correlations between the quantities involved. All of this is done
completely **transparently**.
-.. index::
- printing
- formatting
-
-Printing
-========
-
-.. Overview:
-
-Numbers with uncertainties can be printed conveniently:
-
->>> print x
-0.200+/-0.010
-
-The resulting form can generally be parsed back with
-:func:`ufloat_fromstr` (except for the LaTeX form).
-
-.. Precision matching:
-
-The nominal value and the uncertainty always have the **same
-precision**: this makes it easier to compare them.
-
-.. Formatting method:
-
-More **control over the format** can be obtained (in Python 2.6+)
-through the usual :func:`format` method of strings:
-
->>> print 'Result = {:10.2f}'.format(x)
-Result = 0.20+/- 0.01
-
-(Python 2.6 requires ``'{0:10.2f}'`` instead, with the usual explicit
-index. In Python 2.5 and earlier versions, :func:`str.format` is not
-available, but one can use the :func:`format` method of numbers with
-uncertainties instead: ``'Result = %s' % x.format('10.2f')``.)
-
-.. Legacy formats and base syntax of the format specification:
-
-**All the float format specifications** are accepted, except those
-with the ``n`` format type. In particular, a fill character, an
-alignment option, a sign or zero option, a width, or the ``%`` format
-type are all supported.
-
-.. Precision control:
-
-When :mod:`uncertainties` must **choose the number of significant
-digits on the uncertainty**, it is defined with the `Particle
-Data Group
-<http://PDG.lbl.gov/2010/reviews/rpp2010-rev-rpp-intro.pdf>`_ rounding
-rules (these rules keep the number of digits small, which is
-convenient for reading numbers with uncertainties, and at the same
-time prevent the uncertainty from being displayed with too few
-digits):
-
->>> print 'Automatic number of digits on the uncertainty: {}'.format(x)
-Automatic number of digits on the uncertainty: 0.200+/-0.010
->>> print x
-0.200+/-0.010
-
-It is possible to **control the number of significant digits of the
-uncertainty** by adding the precision modifier ``u`` after the
-precision (and before any valid float format type like ``f``, ``e``,
-the empty format type, etc.):
-
->>> print '1 significant digit on the uncertainty: {:.1u}'.format(x)
-1 significant digit on the uncertainty: 0.20+/-0.01
->>> print '3 significant digits on the uncertainty: {:.3u}'.format(x)
-3 significant digits on the uncertainty: 0.2000+/-0.0100
->>> print '1 significant digit, exponent notation: {:.1ue}'.format(x)
-1 significant digit, exponent notation: (2.0+/-0.1)e-01
->>> print '1 significant digit, percentage: {:.1u%}'.format(x)
-1 significant digit, percentage: (20+/-1)%
-
-The usual **float formats with a precision** retain their original
-meaning (e.g. ``.2e`` uses two digits after the decimal point): code
-that works with floats produces similar results when running with
-numbers with uncertainties.
-
-
-.. Common exponent:
-
-A **common exponent** is automatically calculated if an exponent is
-needed for the larger of the nominal value (in absolute value) and the
-uncertainty (the rule is the same as for floats). The exponent is
-generally **factored**, for increased legibility:
-
->>> print x*1e7
-(2.00+/-0.10)e+06
-
-When a *format width* is used, the common exponent is not factored:
-
->>> print 'Result = {:10.1e}'.format(x*1e-10)
-Result = 2.0e-11+/- 0.1e-11
-
-(Using a (minimal) width of 1 is thus a way of forcing exponents to not
-be factored.) Thanks to this feature, each part (nominal value and
-standard deviation) is correctly aligned across multiple lines, while the
-relative magnitude of the error can still be readily estimated thanks to
-the common exponent.
-
-.. Options:
-
-Formatting options can be added at the end of the format string: ``S``
-for the **shorthand notation**, ``L`` for a **LaTeX** output, ``P``
-for **pretty-printing**:
-
->>> print '{:+.1uS}'.format(x) # Sign, 1 digit for the uncertainty, shorthand
-+0.20(1)
->>> print '{:L}'.format(x*1e7) # Automatic exponent form, LaTeX
-\left(2.00 \pm 0.10\right) \times 10^{6}
-
-The pretty-printing mode uses "±" and superscript exponents: the
-default output is such that ``print '{:.2e}'.format(x)`` yields
-"(2.00+/-0.10)e-01", whereas the pretty-printing mode in ``print
-u'{:.2eP}'.format(x)`` yields "(2.00±0.10)×10\ :sup:`-1`\ ". Note that
-the pretty-printing mode implies using Unicode format strings
-(``u'…'`` in Python 2, but simply ``'…'`` in Python 3).
-
-These formatting options can be combined (when meaningful).
-
-.. Special cases:
-
-An uncertainty which is *exactly* **zero** is always formatted as an
-integer:
-
->>> print ufloat(3.1415, 0)
-3.1415+/-0
->>> print ufloat(3.1415e10, 0)
-(3.1415+/-0)e+10
->>> print ufloat(3.1415, 0.0005)
-3.1415+/-0.0005
->>> print '{:.2f}'.format(ufloat(3.14, 0.001))
-3.14+/-0.00
->>> print '{:.2f}'.format(ufloat(3.14, 0.00))
-3.14+/-0
-
-**All the digits** of a number with uncertainty are given in its
-representation:
-
->>> y = ufloat(1.23456789012345, 0.123456789)
->>> print y
-1.23+/-0.12
->>> print repr(y)
-1.23456789012345+/-0.123456789
->>> y
-1.23456789012345+/-0.123456789
-
-**More information** on formatting can be obtained with ``pydoc
-uncertainties.UFloat.__format__`` (customization of the LaTeX output,
-etc.).
-
-Global formatting
------------------
-
-It is sometimes useful to have a **consistent formatting** across
-multiple parts of a program. Python's `string.Formatter class
-<http://docs.python.org/2/library/string.html#string-formatting>`_
-allows one to do just that. Here is how it can be used to consistently
-use the shorthand notation for numbers with uncertainties:
-
-.. code-block:: python
-
- class ShorthandFormatter(string.Formatter):
-
- def format_field(self, value, format_spec):
- if isinstance(value, uncertainties.UFloat):
- return value.format(format_spec+'S') # Shorthand option added
- # Special formatting for other types can be added here (floats,
etc.)
- else:
- # Usual formatting:
- return super(ShorthandFormatter, self).format_field(
- value, format_spec)
-
- frmtr = ShorthandFormatter()
-
- print frmtr.format("Result = {0:.1u}", x) # 1-digit uncertainty
-
-prints with the shorthand notation: ``Result = 0.20(1)``.
-
-
-.. index::
- pair: nominal value; scalar
- pair: uncertainty; scalar
Access to the uncertainty and to the nominal value
==================================================
@@ -430,7 +267,6 @@
numbers with uncertainties can be found in the :ref:`Technical Guide
<comparison_operators>`.
-
.. index:: covariance matrix
Covariance and correlation matrices
@@ -533,6 +369,189 @@
single: Fortran code; wrapping
single: wrapping (C, Fortran,…) functions
+.. index::
+ printing
+ formatting
+
+Printing
+========
+
+.. Overview:
+
+Numbers with uncertainties can be printed conveniently:
+
+>>> print x
+0.200+/-0.010
+
+The resulting form can generally be parsed back with
+:func:`ufloat_fromstr` (except for the LaTeX form).
+
+.. Precision matching:
+
+The nominal value and the uncertainty always have the **same
+precision**: this makes it easier to compare them.
+
+.. Formatting method:
+
+More **control over the format** can be obtained (in Python 2.6+)
+through the usual :func:`format` method of strings:
+
+>>> print 'Result = {:10.2f}'.format(x)
+Result = 0.20+/- 0.01
+
+(Python 2.6 requires ``'{0:10.2f}'`` instead, with the usual explicit
+index. In Python 2.5 and earlier versions, :func:`str.format` is not
+available, but one can use the :func:`format` method of numbers with
+uncertainties instead: ``'Result = %s' % x.format('10.2f')``.)
+
+.. Legacy formats and base syntax of the format specification:
+
+**All the float format specifications** are accepted, except those
+with the ``n`` format type. In particular, a fill character, an
+alignment option, a sign or zero option, a width, or the ``%`` format
+type are all supported.
+
+.. Precision control:
+
+When :mod:`uncertainties` must **choose the number of significant
+digits on the uncertainty**, it is defined with the `Particle
+Data Group
+<http://PDG.lbl.gov/2010/reviews/rpp2010-rev-rpp-intro.pdf>`_ rounding
+rules (these rules keep the number of digits small, which is
+convenient for reading numbers with uncertainties, and at the same
+time prevent the uncertainty from being displayed with too few
+digits):
+
+>>> print 'Automatic number of digits on the uncertainty: {}'.format(x)
+Automatic number of digits on the uncertainty: 0.200+/-0.010
+>>> print x
+0.200+/-0.010
+
+It is possible to **control the number of significant digits of the
+uncertainty** by adding the precision modifier ``u`` after the
+precision (and before any valid float format type like ``f``, ``e``,
+the empty format type, etc.):
+
+>>> print '1 significant digit on the uncertainty: {:.1u}'.format(x)
+1 significant digit on the uncertainty: 0.20+/-0.01
+>>> print '3 significant digits on the uncertainty: {:.3u}'.format(x)
+3 significant digits on the uncertainty: 0.2000+/-0.0100
+>>> print '1 significant digit, exponent notation: {:.1ue}'.format(x)
+1 significant digit, exponent notation: (2.0+/-0.1)e-01
+>>> print '1 significant digit, percentage: {:.1u%}'.format(x)
+1 significant digit, percentage: (20+/-1)%
+
+The usual **float formats with a precision** retain their original
+meaning (e.g. ``.2e`` uses two digits after the decimal point): code
+that works with floats produces similar results when running with
+numbers with uncertainties.
+
+
+.. Common exponent:
+
+A **common exponent** is automatically calculated if an exponent is
+needed for the larger of the nominal value (in absolute value) and the
+uncertainty (the rule is the same as for floats). The exponent is
+generally **factored**, for increased legibility:
+
+>>> print x*1e7
+(2.00+/-0.10)e+06
+
+When a *format width* is used, the common exponent is not factored:
+
+>>> print 'Result = {:10.1e}'.format(x*1e-10)
+Result = 2.0e-11+/- 0.1e-11
+
+(Using a (minimal) width of 1 is thus a way of forcing exponents to not
+be factored.) Thanks to this feature, each part (nominal value and
+standard deviation) is correctly aligned across multiple lines, while the
+relative magnitude of the error can still be readily estimated thanks to
+the common exponent.
+
+.. Options:
+
+Formatting options can be added at the end of the format string: ``S``
+for the **shorthand notation**, ``L`` for a **LaTeX** output, ``P``
+for **pretty-printing**:
+
+>>> print '{:+.1uS}'.format(x) # Sign, 1 digit for the uncertainty, shorthand
++0.20(1)
+>>> print '{:L}'.format(x*1e7) # Automatic exponent form, LaTeX
+\left(2.00 \pm 0.10\right) \times 10^{6}
+
+The pretty-printing mode uses "±" and superscript exponents: the
+default output is such that ``print '{:.2e}'.format(x)`` yields
+"(2.00+/-0.10)e-01", whereas the pretty-printing mode in ``print
+u'{:.2eP}'.format(x)`` yields "(2.00±0.10)×10\ :sup:`-1`\ ". Note that
+the pretty-printing mode implies using Unicode format strings
+(``u'…'`` in Python 2, but simply ``'…'`` in Python 3).
+
+These formatting options can be combined (when meaningful).
+
+.. Special cases:
+
+An uncertainty which is *exactly* **zero** is always formatted as an
+integer:
+
+>>> print ufloat(3.1415, 0)
+3.1415+/-0
+>>> print ufloat(3.1415e10, 0)
+(3.1415+/-0)e+10
+>>> print ufloat(3.1415, 0.0005)
+3.1415+/-0.0005
+>>> print '{:.2f}'.format(ufloat(3.14, 0.001))
+3.14+/-0.00
+>>> print '{:.2f}'.format(ufloat(3.14, 0.00))
+3.14+/-0
+
+**All the digits** of a number with uncertainty are given in its
+representation:
+
+>>> y = ufloat(1.23456789012345, 0.123456789)
+>>> print y
+1.23+/-0.12
+>>> print repr(y)
+1.23456789012345+/-0.123456789
+>>> y
+1.23456789012345+/-0.123456789
+
+**More information** on formatting can be obtained with ``pydoc
+uncertainties.UFloat.__format__`` (customization of the LaTeX output,
+etc.).
+
+Global formatting
+-----------------
+
+It is sometimes useful to have a **consistent formatting** across
+multiple parts of a program. Python's `string.Formatter class
+<http://docs.python.org/2/library/string.html#string-formatting>`_
+allows one to do just that. Here is how it can be used to consistently
+use the shorthand notation for numbers with uncertainties:
+
+.. code-block:: python
+
+ class ShorthandFormatter(string.Formatter):
+
+ def format_field(self, value, format_spec):
+ if isinstance(value, uncertainties.UFloat):
+ return value.format(format_spec+'S') # Shorthand option added
+ # Special formatting for other types can be added here (floats,
etc.)
+ else:
+ # Usual formatting:
+ return super(ShorthandFormatter, self).format_field(
+ value, format_spec)
+
+ frmtr = ShorthandFormatter()
+
+ print frmtr.format("Result = {0:.1u}", x) # 1-digit uncertainty
+
+prints with the shorthand notation: ``Result = 0.20(1)``.
+
+
+.. index::
+ pair: nominal value; scalar
+ pair: uncertainty; scalar
+
Making custom functions accept numbers with uncertainties
=========================================================
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/setup.cfg
new/uncertainties-3.0.2/setup.cfg
--- old/uncertainties-3.0.1/setup.cfg 2016-08-15 22:52:30.000000000 +0200
+++ new/uncertainties-3.0.2/setup.cfg 2018-01-14 17:00:56.000000000 +0100
@@ -1,5 +1,4 @@
[egg_info]
tag_build =
tag_date = 0
-tag_svn_revision = 0
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/setup.py
new/uncertainties-3.0.2/setup.py
--- old/uncertainties-3.0.1/setup.py 2016-08-15 22:51:45.000000000 +0200
+++ new/uncertainties-3.0.2/setup.py 2018-01-14 16:53:48.000000000 +0100
@@ -42,10 +42,10 @@
# Common options for distutils/setuptools's setup():
setup_options = dict(
name='uncertainties',
- version='3.0.1',
+ version='3.0.2',
author='Eric O. LEBIGOT (EOL)',
author_email='eric.lebi...@normalesup.org',
- url='http://pythonhosted.org/uncertainties/',
+ url='http://uncertainties-python-package.readthedocs.io/',
license='''\
This software can be used under one of the following two licenses: \
@@ -146,7 +146,7 @@
=======================
Installation instructions are available on the `main web site
-<http://pythonhosted.org/uncertainties/#installation-and-download>`_
+<http://uncertainties-python-package.readthedocs.io/en/latest/index.html#installation-and-download>`_
for this package.
Contact
@@ -160,7 +160,7 @@
Main changes:
-- 3.0: Massive speedup for operations involving large numbers of numbers with
uncertainty, like ``sum(ufloat(1, 1) for _ in xrange(100000))`` (this is about
5,000 times faster than before).
+- 3.0: Massive speedup for some operations involving large numbers of numbers
with uncertainty, like ``sum(ufloat(1, 1) for _ in xrange(100000))`` (this is
about 5,000 times faster than before).
- 2.4.8: Friendlier completions in Python shells, etc.: internal functions
should not appear anymore (for the user modules: ``uncertainties``,
``uncertainties.umath`` and ``uncertainties.unumpy``). Parsing the shorthand
notation (e.g. ``3.1(2)``) now works with infinite values (e.g. ``-inf(inf)``);
this mirrors the ability to print such numbers with uncertainty. The Particle
Data Group rounding rule is applied in more cases (e.g. printing 724.2±26.2 now
gives ``724±26``). The shorthand+LaTeX formatting of numbers with an infinite
nominal value is fixed. ``uncertainties.unumpy.matrix`` now uses ``.std_devs``
instead of ``.std_devs()``, for consistency with floats with uncertainty
(automatic conversion of code added to ``uncertainties.1to2``).
- 2.4.7: String formatting now works for ``(-)inf+/-...`` numbers.
- 2.4.5: String formatting now works for ``NaN+/-...`` numbers.
@@ -281,17 +281,16 @@
``covariance_matrix()``.
.. _Python: http://docs.python.org/tutorial/interpreter.html
-.. _IPython: http://ipython.scipy.org/
+.. _IPython: http://ipython.readthedocs.io/en/stable/
.. _NumPy: http://numpy.scipy.org/
.. _math: http://docs.python.org/library/math.html
.. _PEP 8: http://www.python.org/dev/peps/pep-0008/
.. _error propagation theory:
http://en.wikipedia.org/wiki/Propagation_of_uncertainty
.. _Eric O. LEBIGOT (EOL): mailto:eric.lebi...@normalesup.org
.. _PayPal:
https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4TK7KNDTEDT4S
-.. _main website: http://pythonhosted.org/uncertainties/
-.. _code updater:
http://pythonhosted.org/uncertainties/#migration-from-version-1-to-version-2
-.. _formatting: http://pythonhosted.org/uncertainties/user_guide.html#printing
-''',
+.. _main website: http://uncertainties-python-package.readthedocs.io/
+.. _code updater:
http://uncertainties-python-package.readthedocs.io/en/latest/index.html#migration-from-version-1-to-version-2
+.. _formatting:
http://uncertainties-python-package.readthedocs.io/en/latest/user_guide.html#printing''',
keywords=['error propagation', 'uncertainties',
'uncertainty calculations',
@@ -320,6 +319,7 @@
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
+ 'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: Implementation :: Jython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Education',
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties-py23/__init__.py
new/uncertainties-3.0.2/uncertainties-py23/__init__.py
--- old/uncertainties-3.0.1/uncertainties-py23/__init__.py 2016-08-15
22:51:45.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py23/__init__.py 2018-01-14
16:53:48.000000000 +0100
@@ -225,7 +225,7 @@
from uncertainties.core import __all__ # For a correct help(uncertainties)
# Numerical version:
-__version_info__ = (3, 0, 1)
+__version_info__ = (3, 0, 2)
__version__ = '.'.join(map(str, __version_info__))
__author__ = 'Eric O. LEBIGOT (EOL) <eric.lebi...@normalesup.org>'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties-py23/core.py
new/uncertainties-3.0.2/uncertainties-py23/core.py
--- old/uncertainties-3.0.1/uncertainties-py23/core.py 2016-08-15
22:51:45.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py23/core.py 2018-01-14
16:53:48.000000000 +0100
@@ -1,7 +1,7 @@
# coding=utf-8
"""
-Main module for the uncertainties package, with internals.
+Main module for the uncertainties package, with internal functions.
"""
# The idea behind this module is to replace the result of mathematical
@@ -253,6 +253,7 @@
# partial_derivative(). Value chosen to as to get better numerical
# results:
try:
+ # New in Python 2.6:
STEP_SIZE = sqrt(sys.float_info.epsilon)
except AttributeError:
STEP_SIZE = 1e-8
@@ -2911,7 +2912,13 @@
###############################################################################
# Parsing of values with uncertainties:
-POSITIVE_DECIMAL_UNSIGNED_OR_NON_FINITE = ur'((\d+)(\.\d*)?|nan|NAN|inf|INF)'
+# Parsing of (part of) numbers. The reason why the decimal part is
+# parsed (if any), instead of using the parsing built in float(), is
+# that the presence (or not) of a decimal point does matter, in the
+# semantics of some representations (e.g. .1(2.) = .1+/-2, whereas
+# .1(2) = .1+/-0.2), so just getting the numerical value of the part
+# in parentheses would not be sufficient.
+POSITIVE_DECIMAL_UNSIGNED_OR_NON_FINITE = ur'((\d*)(\.\d*)?|nan|NAN|inf|INF)'
# Regexp for a number with uncertainty (e.g., "-1.234(2)e-6"), where
# the uncertainty is optional (in which case the uncertainty is
@@ -2963,7 +2970,7 @@
# The 'main' part is the nominal value, with 'int'eger part, and
# 'dec'imal part. The 'uncert'ainty is similarly broken into its
# integer and decimal parts.
- (sign, main, main_int, main_dec, uncert, uncert_int, uncert_dec,
+ (sign, main, _, main_dec, uncert, uncert_int, uncert_dec,
exponent) = match.groups()
else:
raise NotParenUncert("Unparsable number representation: '%s'."
@@ -2993,7 +3000,7 @@
# uncert_int represents an uncertainty on the last digits:
# The number of digits after the period defines the power of
- # 10 than must be applied to the provided uncertainty:
+ # 10 that must be applied to the provided uncertainty:
if main_dec is None:
num_digits_after_period = 0
else:
@@ -3148,6 +3155,8 @@
12.3(0.4)e-5
169.0(7)
169.1(15)
+ .123(4)
+ .1(.4)
# NaN uncertainties:
12.3(nan)
@@ -3155,6 +3164,11 @@
3±nan
Surrounding spaces are ignored.
+
+ About the "shorthand" notation: 1.23(3) == 1.23 ± 0.03 but
+ 1.23(3.) == 1.23 ± 3.00. Thus, the presence of a decimal point in
+ the uncertainty signals an absolute uncertainty (instead of an
+ uncertainty on the last digits of the nominal value).
"""
(nominal_value, std_dev) = str_to_number_with_uncert(
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/uncertainties-3.0.1/uncertainties-py23/lib1to2/test_1to2.py
new/uncertainties-3.0.2/uncertainties-py23/lib1to2/test_1to2.py
--- old/uncertainties-3.0.1/uncertainties-py23/lib1to2/test_1to2.py
2016-08-15 22:51:45.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py23/lib1to2/test_1to2.py
2018-01-14 16:53:48.000000000 +0100
@@ -20,7 +20,7 @@
# like here a whole indented block?
-if sys.version_info < (2, 7) or "TRAVIS" in os.environ:
+if sys.version_info < (2, 7) or "TRAVIS" in os.environ or "APPVEYOR" in
os.environ:
# This package uses lib2to3, which requires Python 2.6+.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties-py23/umath_core.py
new/uncertainties-3.0.2/uncertainties-py23/umath_core.py
--- old/uncertainties-3.0.1/uncertainties-py23/umath_core.py 2016-08-15
22:51:45.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py23/umath_core.py 2018-01-14
16:53:48.000000000 +0100
@@ -1,5 +1,5 @@
-# !!!!!!!!!!! Add a header to the documentation, stating somethign
-# about the uncertainties.UFloat-compatible version of..., for all functions
+# !!!!!!!!!!! Add a header to the documentation, that starts with something
+# like "uncertainties.UFloat-compatible version of...", for all functions.
"""
Implementation of umath.py, with internals.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/uncertainties-3.0.1/uncertainties-py23/unumpy/core.py
new/uncertainties-3.0.2/uncertainties-py23/unumpy/core.py
--- old/uncertainties-3.0.1/uncertainties-py23/unumpy/core.py 2016-08-15
22:51:45.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py23/unumpy/core.py 2018-01-14
16:53:48.000000000 +0100
@@ -679,7 +679,6 @@
# numpy.float... (equality tests succeed, though).
func = getattr(umath_core, function_name)
-
# Data type of the result of the unumpy function:
otypes = (
# It is much more convenient to preserve the type of
@@ -700,6 +699,9 @@
setattr(
this_module, unumpy_name,
+ #!!!! For umath_core.locally_cst_funcs, would it make sense
+ # to optimize this by using instead the equivalent (? see
+ # above) vectorized NumPy function on the nominal values?
numpy.vectorize(func,
doc="""\
Vectorized version of umath.%s.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties-py27/__init__.py
new/uncertainties-3.0.2/uncertainties-py27/__init__.py
--- old/uncertainties-3.0.1/uncertainties-py27/__init__.py 2016-08-15
22:50:48.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py27/__init__.py 2018-01-14
12:55:34.000000000 +0100
@@ -225,7 +225,7 @@
from .core import __all__ # For a correct help(uncertainties)
# Numerical version:
-__version_info__ = (3, 0, 1)
+__version_info__ = (3, 0, 2)
__version__ = '.'.join(map(str, __version_info__))
__author__ = 'Eric O. LEBIGOT (EOL) <eric.lebi...@normalesup.org>'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties-py27/core.py
new/uncertainties-3.0.2/uncertainties-py27/core.py
--- old/uncertainties-3.0.1/uncertainties-py27/core.py 2016-08-15
22:50:48.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py27/core.py 2018-01-14
12:55:34.000000000 +0100
@@ -1,7 +1,7 @@
# coding=utf-8
"""
-Main module for the uncertainties package, with internals.
+Main module for the uncertainties package, with internal functions.
"""
# The idea behind this module is to replace the result of mathematical
@@ -245,10 +245,7 @@
# Step constant for numerical derivatives in
# partial_derivative(). Value chosen to as to get better numerical
# results:
-try:
- STEP_SIZE = sqrt(sys.float_info.epsilon)
-except AttributeError:
- STEP_SIZE = 1e-8
+STEP_SIZE = sqrt(sys.float_info.epsilon)
# !! It would be possible to split the partial derivative calculation
# into two functions: one for positional arguments (case of integer
@@ -837,11 +834,9 @@
Return 0 for a null value.
'''
- # Python 2.5 returns nan for math.log10(-4), but Python 2.7 raises
- # ValueError, so the value is directly tested:
- if value:
+ try:
return int(math.floor(math.log10(abs(value))))
- else:
+ except ValueError: # Case of value == 0
return 0
def PDG_precision(std_dev):
@@ -947,8 +942,8 @@
# Inverted TO_SUPERSCRIPT table, for use with unicode.translate():
#
#! Python 2.7+ can use a dictionary comprehension instead:
-FROM_SUPERSCRIPT = dict(
- (ord(sup), normal) for (normal, sup) in TO_SUPERSCRIPT.items())
+FROM_SUPERSCRIPT = {
+ ord(sup): normal for (normal, sup) in TO_SUPERSCRIPT.iteritems()}
def to_superscript(value):
'''
@@ -1806,7 +1801,7 @@
# An empty format string and str() usually return the same
# string
#
(http://docs.python.org/2/library/string.html#format-specification-mini-language):
- return self.__format__('') # Works with Python < 2.6, not format()
+ return self.format('')
def __format__(self, format_spec):
'''Formats a number with uncertainty.
@@ -2878,7 +2873,13 @@
###############################################################################
# Parsing of values with uncertainties:
-POSITIVE_DECIMAL_UNSIGNED_OR_NON_FINITE = ur'((\d+)(\.\d*)?|nan|NAN|inf|INF)'
+# Parsing of (part of) numbers. The reason why the decimal part is
+# parsed (if any), instead of using the parsing built in float(), is
+# that the presence (or not) of a decimal point does matter, in the
+# semantics of some representations (e.g. .1(2.) = .1+/-2, whereas
+# .1(2) = .1+/-0.2), so just getting the numerical value of the part
+# in parentheses would not be sufficient.
+POSITIVE_DECIMAL_UNSIGNED_OR_NON_FINITE = ur'((\d*)(\.\d*)?|nan|NAN|inf|INF)'
# Regexp for a number with uncertainty (e.g., "-1.234(2)e-6"), where
# the uncertainty is optional (in which case the uncertainty is
@@ -2930,7 +2931,7 @@
# The 'main' part is the nominal value, with 'int'eger part, and
# 'dec'imal part. The 'uncert'ainty is similarly broken into its
# integer and decimal parts.
- (sign, main, main_int, main_dec, uncert, uncert_int, uncert_dec,
+ (sign, main, _, main_dec, uncert, uncert_int, uncert_dec,
exponent) = match.groups()
else:
raise NotParenUncert("Unparsable number representation: '%s'."
@@ -2952,15 +2953,13 @@
uncert_int = '1' # The other parts of the uncertainty are None
# Do we have a fully explicit uncertainty?
- #
- # !!! Python 2.7+: in {'nan',...} is faster (x10)
- if uncert_dec is not None or uncert in ['nan', 'NAN', 'inf', 'INF']:
+ if uncert_dec is not None or uncert in {'nan', 'NAN', 'inf', 'INF'}:
uncert_value = float(uncert)
else:
# uncert_int represents an uncertainty on the last digits:
# The number of digits after the period defines the power of
- # 10 than must be applied to the provided uncertainty:
+ # 10 that must be applied to the provided uncertainty:
if main_dec is None:
num_digits_after_period = 0
else:
@@ -3115,6 +3114,8 @@
12.3(0.4)e-5
169.0(7)
169.1(15)
+ .123(4)
+ .1(.4)
# NaN uncertainties:
12.3(nan)
@@ -3122,6 +3123,11 @@
3±nan
Surrounding spaces are ignored.
+
+ About the "shorthand" notation: 1.23(3) == 1.23 ± 0.03 but
+ 1.23(3.) == 1.23 ± 3.00. Thus, the presence of a decimal point in
+ the uncertainty signals an absolute uncertainty (instead of an
+ uncertainty on the last digits of the nominal value).
"""
(nominal_value, std_dev) = str_to_number_with_uncert(
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/uncertainties-3.0.1/uncertainties-py27/lib1to2/test_1to2.py
new/uncertainties-3.0.2/uncertainties-py27/lib1to2/test_1to2.py
--- old/uncertainties-3.0.1/uncertainties-py27/lib1to2/test_1to2.py
2016-08-15 22:50:48.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py27/lib1to2/test_1to2.py
2018-01-14 12:55:34.000000000 +0100
@@ -20,7 +20,7 @@
# like here a whole indented block?
-if sys.version_info < (2, 7) or "TRAVIS" in os.environ:
+if sys.version_info < (2, 7) or "TRAVIS" in os.environ or "APPVEYOR" in
os.environ:
# This package uses lib2to3, which requires Python 2.6+.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties-py27/umath_core.py
new/uncertainties-3.0.2/uncertainties-py27/umath_core.py
--- old/uncertainties-3.0.1/uncertainties-py27/umath_core.py 2016-08-15
22:50:48.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py27/umath_core.py 2018-01-14
12:55:34.000000000 +0100
@@ -1,5 +1,5 @@
-# !!!!!!!!!!! Add a header to the documentation, stating somethign
-# about the uncertainties.UFloat-compatible version of..., for all functions
+# !!!!!!!!!!! Add a header to the documentation, that starts with something
+# like "uncertainties.UFloat-compatible version of...", for all functions.
"""
Implementation of umath.py, with internals.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/uncertainties-3.0.1/uncertainties-py27/unumpy/core.py
new/uncertainties-3.0.2/uncertainties-py27/unumpy/core.py
--- old/uncertainties-3.0.1/uncertainties-py27/unumpy/core.py 2016-08-15
22:50:48.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties-py27/unumpy/core.py 2018-01-14
12:55:34.000000000 +0100
@@ -672,7 +672,6 @@
# numpy.float... (equality tests succeed, though).
func = getattr(umath_core, function_name)
-
# Data type of the result of the unumpy function:
otypes = (
# It is much more convenient to preserve the type of
@@ -693,6 +692,9 @@
setattr(
this_module, unumpy_name,
+ #!!!! For umath_core.locally_cst_funcs, would it make sense
+ # to optimize this by using instead the equivalent (? see
+ # above) vectorized NumPy function on the nominal values?
numpy.vectorize(func,
doc="""\
Vectorized version of umath.%s.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/uncertainties-3.0.1/uncertainties.egg-info/PKG-INFO
new/uncertainties-3.0.2/uncertainties.egg-info/PKG-INFO
--- old/uncertainties-3.0.1/uncertainties.egg-info/PKG-INFO 2016-08-15
22:52:29.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties.egg-info/PKG-INFO 2018-01-14
17:00:56.000000000 +0100
@@ -1,11 +1,12 @@
Metadata-Version: 1.1
Name: uncertainties
-Version: 3.0.1
+Version: 3.0.2
Summary: Transparent calculations with uncertainties on the quantities
involved (aka error propagation); fast calculation of derivatives
-Home-page: http://pythonhosted.org/uncertainties/
+Home-page: http://uncertainties-python-package.readthedocs.io/
Author: Eric O. LEBIGOT (EOL)
Author-email: eric.lebi...@normalesup.org
License: This software can be used under one of the following two licenses:
(1) The Revised BSD License. (2) Any other license, as long as it is obtained
from the original author.
+Description-Content-Type: UNKNOWN
Description: Overview
========
@@ -94,7 +95,7 @@
=======================
Installation instructions are available on the `main web site
- <http://pythonhosted.org/uncertainties/#installation-and-download>`_
+
<http://uncertainties-python-package.readthedocs.io/en/latest/index.html#installation-and-download>`_
for this package.
Contact
@@ -108,7 +109,7 @@
Main changes:
- - 3.0: Massive speedup for operations involving large numbers of
numbers with uncertainty, like ``sum(ufloat(1, 1) for _ in xrange(100000))``
(this is about 5,000 times faster than before).
+ - 3.0: Massive speedup for some operations involving large numbers of
numbers with uncertainty, like ``sum(ufloat(1, 1) for _ in xrange(100000))``
(this is about 5,000 times faster than before).
- 2.4.8: Friendlier completions in Python shells, etc.: internal
functions should not appear anymore (for the user modules: ``uncertainties``,
``uncertainties.umath`` and ``uncertainties.unumpy``). Parsing the shorthand
notation (e.g. ``3.1(2)``) now works with infinite values (e.g. ``-inf(inf)``);
this mirrors the ability to print such numbers with uncertainty. The Particle
Data Group rounding rule is applied in more cases (e.g. printing 724.2±26.2 now
gives ``724±26``). The shorthand+LaTeX formatting of numbers with an infinite
nominal value is fixed. ``uncertainties.unumpy.matrix`` now uses ``.std_devs``
instead of ``.std_devs()``, for consistency with floats with uncertainty
(automatic conversion of code added to ``uncertainties.1to2``).
- 2.4.7: String formatting now works for ``(-)inf+/-...`` numbers.
- 2.4.5: String formatting now works for ``NaN+/-...`` numbers.
@@ -229,17 +230,16 @@
``covariance_matrix()``.
.. _Python: http://docs.python.org/tutorial/interpreter.html
- .. _IPython: http://ipython.scipy.org/
+ .. _IPython: http://ipython.readthedocs.io/en/stable/
.. _NumPy: http://numpy.scipy.org/
.. _math: http://docs.python.org/library/math.html
.. _PEP 8: http://www.python.org/dev/peps/pep-0008/
.. _error propagation theory:
http://en.wikipedia.org/wiki/Propagation_of_uncertainty
.. _Eric O. LEBIGOT (EOL): mailto:eric.lebi...@normalesup.org
.. _PayPal:
https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4TK7KNDTEDT4S
- .. _main website: http://pythonhosted.org/uncertainties/
- .. _code updater:
http://pythonhosted.org/uncertainties/#migration-from-version-1-to-version-2
- .. _formatting:
http://pythonhosted.org/uncertainties/user_guide.html#printing
-
+ .. _main website: http://uncertainties-python-package.readthedocs.io/
+ .. _code updater:
http://uncertainties-python-package.readthedocs.io/en/latest/index.html#migration-from-version-1-to-version-2
+ .. _formatting:
http://uncertainties-python-package.readthedocs.io/en/latest/user_guide.html#printing
Keywords: error propagation,uncertainties,uncertainty calculations,standard
deviation,derivatives,partial derivatives,differentiation
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
@@ -261,6 +261,7 @@
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: Jython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Education
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/uncertainties-3.0.1/uncertainties.egg-info/requires.txt
new/uncertainties-3.0.2/uncertainties.egg-info/requires.txt
--- old/uncertainties-3.0.1/uncertainties.egg-info/requires.txt 2016-08-15
22:52:29.000000000 +0200
+++ new/uncertainties-3.0.2/uncertainties.egg-info/requires.txt 2018-01-14
17:00:56.000000000 +0100
@@ -1,7 +1,7 @@
[all]
-numpy
sphinx
+numpy
nose
[docs]
![https://s3.amazonaws.com/github/ribbons/forkme_right_orange_ff7600.png"](https://s3.amazonaws.com/github/ribbons/forkme_right_orange_ff7600.png"){kind=link}