def test_variance_prop_with_covar(): x, y, z = symbols('x y z') phi, t = consts = symbols('phi t') a = RandomSymbol(x) var_x = Variance(a) b = RandomSymbol(y) var_y = Variance(b) c = RandomSymbol(z) var_z = Variance(c) covar_x_y = Covariance(a, b) covar_x_z = Covariance(a, c) covar_y_z = Covariance(b, c) cases = { x + y: var_x + var_y + 2*covar_x_y, a + y: var_x + var_y + 2*covar_x_y, x + y + z: var_x + var_y + var_z + \ 2*covar_x_y + 2*covar_x_z + 2*covar_y_z, 2*x: 4*var_x, x*y: var_x*y**2 + var_y*x**2 + 2*covar_x_y/(x*y), 1/x: var_x/x**4, exp(x): var_x*exp(2*x), exp(2*x): 4*var_x*exp(4*x), exp(-x*t): t**2*var_x*exp(-2*t*x), } for inp, out in cases.items(): obs = variance_prop(inp, consts=consts, include_covar=True) assert out == obs
def test_variance_prop(): x, y, z = symbols('x y z') phi, t = consts = symbols('phi t') a = RandomSymbol(x) var_x = Variance(a) var_y = Variance(RandomSymbol(y)) var_z = Variance(RandomSymbol(z)) f = Function('f')(x) cases = { x + y: var_x + var_y, a + y: var_x + var_y, x + y + z: var_x + var_y + var_z, 2*x: 4*var_x, x*y: var_x*y**2 + var_y*x**2, 1/x: var_x/x**4, x/y: (var_x*y**2 + var_y*x**2)/y**4, exp(x): var_x*exp(2*x), exp(2*x): 4*var_x*exp(4*x), exp(-x*t): t**2*var_x*exp(-2*t*x), f: Variance(f), } for inp, out in cases.items(): obs = variance_prop(inp, consts=consts) assert out == obs
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(0) elif isinstance(expr, RandomSymbol): return Variance(expr).doit() elif isinstance(expr, Symbol): return Variance(RandomSymbol(expr)).doit() else: return S(0) 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)).doit() \ 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)).doit()/(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: # unknown how to proceed, return variance of whole expr. var_expr = Variance(expr) return var_expr