If you want to see how things are calculated, pdb is indeed one solution.
However, with a debugger like pdb, it is hard to get a high-level overview of what is going on. This is why reading the code is also useful. For example, if you want to know what a+b does, you can check if type(a).__add__ exists, because if it does, it handles the addition. This is the case with the uncertainties package.
That said, __add__ is indeed implemented in uncertainties through a general mechanism instead of being specifically coded for, so I can tell you the idea behind its implementation, since this is what you seem to be ultimately looking for.
In your example, a and b are Variable objects:
>>> from uncertainties import ufloat
>>> a = ufloat(1, 3)
>>> b = ufloat(2, 4)
>>> type(a)
<class 'uncertainties.Variable'>
Then c = a + b is actually a linear function of a and b, represented by its derivatives with respect to a and b:
>>> c = a + b
>>> type(c)
<class 'uncertainties.AffineScalarFunc'>
>>> c.derivatives
{1.0+/-3.0: 1.0, 2.0+/-4.0: 1.0}
If you know the derivatives of a function with respect to its variables, you can easily get an approximation of its standard deviation from the standard deviations of its variables.
Thus, the main ideas behind the implementation of the uncertainties package is that values are either:
- random variables like x = 3.14±0.0.1 and y = 0±0.01 (
Variable objects), described by their standard deviation,
- or linear approximations of functions (
AffineScalarFunc objects: "affine" because they are linear, "scalar" because their values are real, and "func" because they are functions).
To take a more complicated example, z = 2*x+sin(y) is approximated in (x, y) = (3.14, 0) as 2*x + y. In the implementation, since the approximation is linear, only the derivatives with respect to the variables are stored:
>>> x = ufloat(3.14, 0.01)
>>> y = ufloat(0, 0.01)
>>> from uncertainties.umath import sin
>>> z = 2*x + sin(y)
>>> type(z)
<class 'uncertainties.AffineScalarFunc'>
>>> z.derivatives
{3.14+/-0.01: 2.0, 0.0+/-0.01: 1.0}
The main work done by the uncertainties package is thus to calculate the derivatives of any function involving variables. This is done by the efficient method of automatic differentiation. Concretely, when you do something like a+b, Python automatically calls the Variable.__add__() method, which creates a new linear function by calculating the derivatives of a+b with respect to its variables (the derivatives are both one, because the derivative of a with respect to a is one, and the same for b). More generally, one adds functions, not pure variables: the derivatives of f(a,b) + g(a,b) with respect to a and b is calculated with the chain rule. This is how automatic differentiation works, and this is what is implemented in the uncertainties package. The key function here is uncertainties.wrap(). It is the largest and most complicated function of the whole package, but the code is largely commented, and details on the method are available.
Derivatives then give you the standard deviation of the final function as a function of the standard deviations of the variables (the code of AffineScalarFunc.std_dev() is very simple: the more difficult task is to automatically calculate derivatives).
