| | """Tools for arithmetic error propagation.""" |
| |
|
| | from itertools import repeat, combinations |
| |
|
| | from sympy.core.add import Add |
| | from sympy.core.mul import Mul |
| | from sympy.core.power import Pow |
| | from sympy.core.singleton import S |
| | from sympy.core.symbol import Symbol |
| | from sympy.functions.elementary.exponential import exp |
| | from sympy.simplify.simplify import simplify |
| | from sympy.stats.symbolic_probability import RandomSymbol, Variance, Covariance |
| | from sympy.stats.rv import is_random |
| |
|
| | _arg0_or_var = lambda var: var.args[0] if len(var.args) > 0 else var |
| |
|
| |
|
| | def variance_prop(expr, consts=(), include_covar=False): |
| | r"""Symbolically propagates variance (`\sigma^2`) for expressions. |
| | This is computed as as seen in [1]_. |
| | |
| | Parameters |
| | ========== |
| | |
| | expr : Expr |
| | A SymPy expression to compute the variance for. |
| | consts : sequence of Symbols, optional |
| | Represents symbols that are known constants in the expr, |
| | and thus have zero variance. All symbols not in consts are |
| | assumed to be variant. |
| | include_covar : bool, optional |
| | Flag for whether or not to include covariances, default=False. |
| | |
| | Returns |
| | ======= |
| | |
| | var_expr : Expr |
| | An expression for the total variance of the expr. |
| | The variance for the original symbols (e.g. x) are represented |
| | via instance of the Variance symbol (e.g. Variance(x)). |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy import symbols, exp |
| | >>> from sympy.stats.error_prop import variance_prop |
| | >>> x, y = symbols('x y') |
| | |
| | >>> variance_prop(x + y) |
| | Variance(x) + Variance(y) |
| | |
| | >>> variance_prop(x * y) |
| | x**2*Variance(y) + y**2*Variance(x) |
| | |
| | >>> variance_prop(exp(2*x)) |
| | 4*exp(4*x)*Variance(x) |
| | |
| | References |
| | ========== |
| | |
| | .. [1] https://en.wikipedia.org/wiki/Propagation_of_uncertainty |
| | |
| | """ |
| | args = expr.args |
| | if len(args) == 0: |
| | if expr in consts: |
| | return S.Zero |
| | elif is_random(expr): |
| | return Variance(expr).doit() |
| | elif isinstance(expr, Symbol): |
| | return Variance(RandomSymbol(expr)).doit() |
| | else: |
| | return S.Zero |
| | nargs = len(args) |
| | var_args = list(map(variance_prop, args, repeat(consts, nargs), |
| | repeat(include_covar, nargs))) |
| | if isinstance(expr, Add): |
| | var_expr = Add(*var_args) |
| | if include_covar: |
| | terms = [2 * Covariance(_arg0_or_var(x), _arg0_or_var(y)).expand() \ |
| | for x, y in combinations(var_args, 2)] |
| | var_expr += Add(*terms) |
| | elif isinstance(expr, Mul): |
| | terms = [v/a**2 for a, v in zip(args, var_args)] |
| | var_expr = simplify(expr**2 * Add(*terms)) |
| | if include_covar: |
| | terms = [2*Covariance(_arg0_or_var(x), _arg0_or_var(y)).expand()/(a*b) \ |
| | for (a, b), (x, y) in zip(combinations(args, 2), |
| | combinations(var_args, 2))] |
| | var_expr += Add(*terms) |
| | elif isinstance(expr, Pow): |
| | b = args[1] |
| | v = var_args[0] * (expr * b / args[0])**2 |
| | var_expr = simplify(v) |
| | elif isinstance(expr, exp): |
| | var_expr = simplify(var_args[0] * expr**2) |
| | else: |
| | |
| | var_expr = Variance(expr) |
| | return var_expr |
| |
|
