danielutils 1.1.28__py3-none-any.whl

danielutils/university/probability/conditional_variable/conditional_variable.py

@@ -0,0 +1,138 @@
+from abc import ABC, abstractmethod
+from fractions import Fraction
+from typing import Callable, Any
+from ..expressions import ProbabilityExpression, AccumulationExpression
+from ..operator import Operator
+from ..supp import Supp
+from ..protocols import Evaluable
+
+def _create_operator(op: Operator, reverse: bool = False) -> Callable[['ConditionalVariable', Any], Evaluable]:
+    def operator(self, other) -> Evaluable:
+        lhs, rhs = self, other
+        if reverse:
+            lhs, rhs = rhs, lhs
+
+        if reverse and op == Operator.ADD and other == 0:
+            return self
+
+        if isinstance(other, ConditionalVariable) and op == Operator.ADD:
+            combined = _combine_iid_bernoulli_sums(lhs, other)
+            if combined is not None:
+                return combined
+
+        if isinstance(other, (int, float, Fraction)):
+            return ProbabilityExpression(lhs, op, rhs)
+
+        if isinstance(rhs, ProbabilityExpression):
+            l = ProbabilityExpression(lhs, op, rhs.lhs)
+            r = ProbabilityExpression(rhs.rhs, None, None)
+            o = other.op
+            return AccumulationExpression(l, o, r)
+
+        raise NotImplementedError("Not Implemented")
+
+    return operator
+
+
+def _combine_iid_bernoulli_sums(lhs: 'ConditionalVariable', rhs: 'ConditionalVariable'):
+    from .discrete.bernoulli import Bernoulli
+    from .discrete.binomial import Binomial
+    from .discrete.bernoulli_sum import BernoulliSum
+
+    def count_and_p(variable: ConditionalVariable):
+        if isinstance(variable, Bernoulli):
+            return 1, variable.p
+        if isinstance(variable, BernoulliSum):
+            return variable.n, variable.p
+        if isinstance(variable, Binomial):
+            return variable.n, variable.p
+        return None, None
+
+    left_n, left_p = count_and_p(lhs)
+    right_n, right_p = count_and_p(rhs)
+    if left_n is None or right_n is None or left_p != right_p:
+        return None
+    return BernoulliSum(left_p, left_n + right_n)
+
+class ConditionalVariable(ABC):
+    OPERATOR_TYPE = Callable[['ConditionalVariable', Any], Evaluable]
+
+
+    __eq__: OPERATOR_TYPE = _create_operator(Operator.EQ)  # type:ignore
+    __ne__: OPERATOR_TYPE = _create_operator(Operator.NE)  # type:ignore
+    __gt__: OPERATOR_TYPE = _create_operator(Operator.GT)
+    __ge__: OPERATOR_TYPE = _create_operator(Operator.GE)
+    __lt__: OPERATOR_TYPE = _create_operator(Operator.LT)
+    __le__: OPERATOR_TYPE = _create_operator(Operator.LE)
+
+    __or__: OPERATOR_TYPE = _create_operator(Operator.GIVEN)
+    __ror__: OPERATOR_TYPE = _create_operator(Operator.GIVEN, reverse=True)
+    __and__: OPERATOR_TYPE = _create_operator(Operator.AND)
+    __rand__: OPERATOR_TYPE = _create_operator(Operator.AND, reverse=True)
+
+    __mul__: OPERATOR_TYPE = _create_operator(Operator.MUL)
+    __truediv__: OPERATOR_TYPE = _create_operator(Operator.DIV)
+    __mod__: OPERATOR_TYPE = _create_operator(Operator.MODULUS)
+    __pow__: OPERATOR_TYPE = _create_operator(Operator.POW)
+    __add__: OPERATOR_TYPE = _create_operator(Operator.ADD)
+    __radd__: OPERATOR_TYPE = _create_operator(Operator.ADD, reverse=True)
+    __sub__: OPERATOR_TYPE = _create_operator(Operator.SUB)
+    __rsub__: OPERATOR_TYPE = _create_operator(Operator.SUB, reverse=True)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}"
+
+    def is_identical(self, other) -> bool:
+        if not isinstance(other, ConditionalVariable):
+            return False
+        return self is other
+
+    def is_independent(self, other) -> bool:
+        if not isinstance(other, ConditionalVariable):
+            return False
+        if self is other:
+            return False
+        if not self.supp.is_finite and not other.supp.is_finite:
+            raise ValueError("Can't check if two variables are independent if their supp is not finite")
+
+        if self.supp != other.supp:
+            return False
+        from ..funcs import probability_function as P
+        for k in self.supp:
+            if not (P((self == k) & (other == k)) == P(self == k) * P(other == k)):
+                return False
+        return True
+
+    def is_dependent(self, other) -> bool:
+        return not self.is_independent(other)
+
+    def is_correlated(self, other) -> bool:
+        if not isinstance(other, ConditionalVariable):
+            return False
+        from ..funcs import covariance as cov
+        return cov(self, other) == 0
+
+    def is_uncorrelated(self, other) -> bool:
+        return not self.is_correlated(other)
+
+    @abstractmethod
+    def evaluate(self, other: Any, operator: Operator) -> Fraction:
+        ...
+
+    @abstractmethod
+    def between(self, a, b, *args) -> Fraction:
+        ...
+
+    @property
+    @abstractmethod
+    def supp(self) -> Supp:
+        ...
+
+    @abstractmethod
+    def is_equal(self, other) -> bool:
+        ...
+
+
+__all__ = [
+    "ConditionalVariable"
+]

danielutils/university/probability/conditional_variable/discrete/__init__.py

@@ -0,0 +1,8 @@
+from .bernoulli import *
+from .bernoulli_sum import *
+from .binomial import *
+from .conditional_from_discrete_probability_func import *
+from .discrete import *
+from .geometric import *
+from .poisson import *
+from .uniform import *

danielutils/university/probability/conditional_variable/discrete/bernoulli.py

@@ -0,0 +1,38 @@
+from fractions import Fraction
+
+from .discrete import DiscreteConditionalVariable
+from ...supp import FrangeSupp
+from ...operator import Operator
+from ...protocols import ExpectedValueCalculable, VariableCalculable
+
+
+class Bernoulli(DiscreteConditionalVariable, ExpectedValueCalculable, VariableCalculable):
+    def evaluate(self, n: int, op: Operator) -> Fraction:
+        if op == Operator.EQ:
+            return self.p if n == 1 else 1 - self.p
+        if op == Operator.GE:
+            if n <= 0:
+                return Fraction(1, 1)
+            if n == 1:
+                return self.p
+            return Fraction(0, 1)
+        if op == Operator.LE:
+            if n >= 1:
+                return Fraction(1, 1)
+            if n == 0:
+                return 1 - self.p
+            return Fraction(0, 1)
+
+        return 1 - self.evaluate(n, op.inverse)
+
+    def __init__(self, p) -> None:
+        super().__init__(p, FrangeSupp(range(0, 2)))
+
+    def expected_value(self) -> Fraction:
+        return self.p
+
+    def variance(self) -> Fraction:
+        return self.p * (1 - self.p)
+
+
+__all__ = ['Bernoulli']

danielutils/university/probability/conditional_variable/discrete/bernoulli_sum.py

@@ -0,0 +1,31 @@
+from fractions import Fraction
+from typing import Union
+
+from .discrete import DiscreteConditionalVariable
+from .binomial import Binomial
+from ...operator import Operator
+from ...supp import FrangeSupp
+from .....better_builtins import frange
+
+
+class BernoulliSum(DiscreteConditionalVariable):
+    """Sum of iid Bernoulli variables; evaluates via Binomial."""
+
+    def __init__(self, p: Union[float, Fraction], n: int) -> None:
+        super().__init__(p, FrangeSupp(frange(0, n + 1)))
+        self._n = n
+
+    @property
+    def n(self) -> int:
+        return self._n
+
+    def evaluate(self, k: int, op: Operator) -> Fraction:
+        return Binomial(self._n, self.p).evaluate(k, op)
+
+    def is_equal(self, other) -> bool:
+        if not isinstance(other, BernoulliSum):
+            return False
+        return self.p == other.p and self._n == other._n
+
+
+__all__ = ["BernoulliSum"]

danielutils/university/probability/conditional_variable/discrete/binomial.py

@@ -0,0 +1,40 @@
+from fractions import Fraction
+from typing import Union
+from math import factorial
+from .discrete import DiscreteConditionalVariable
+from ...supp import FrangeSupp
+from ...operator import Operator
+from .....better_builtins import frange
+from ...protocols import ExpectedValueCalculable, VariableCalculable
+
+
+def choose(n: int, k: int) -> Fraction:
+    return Fraction(factorial(n), (factorial(k) * factorial(n - k)))
+
+
+class Binomial(DiscreteConditionalVariable, ExpectedValueCalculable, VariableCalculable):
+    def __init__(self, n: int, p: Union[float, Fraction]):
+        super().__init__(p, FrangeSupp(frange(0, float("inf"))))
+        self._n = n
+
+    @property
+    def n(self) -> int:
+        return self._n
+
+    def evaluate(self, k: int, op: Operator) -> Fraction:
+        if not 0 <= k <= self.n:
+            return Fraction(0, 1)
+
+        if op == Operator.EQ:
+            return choose(self.n, k) * ((1 - self.p) ** (self.n - k)) * (self.p ** k)
+        assert False  # TODO
+        return 1 - self.evaluate(k, op.inverse)
+
+    def expected_value(self) -> Fraction:
+        return self.n * self.p
+
+    def variance(self) -> Fraction:
+        return self.n * self.p * (1 - self.p)
+
+
+__all__ = ['Binomial']

danielutils/university/probability/conditional_variable/discrete/conditional_from_discrete_probability_func.py

@@ -0,0 +1,36 @@
+from typing import Callable
+from fractions import Fraction
+from .discrete import DiscreteConditionalVariable
+from ...supp import FrangeSupp
+from ...operator import Operator
+
+
+class ConditionalFromDiscreteProbabilityFunc(DiscreteConditionalVariable):
+    def evaluate(self, n: int, op: Operator) -> Fraction:
+        if op == Operator.EQ:
+            return self.f(n)
+        if op == Operator.LT:
+            res = Fraction(0, 1)
+            for k in range(n):
+                res += self.evaluate(k, Operator.EQ)
+            return res
+        if op == Operator.LE:
+            return self.evaluate(n, Operator.LT) + self.evaluate(n, Operator.EQ)
+
+        return 1 - self.evaluate(n, op.inverse)
+
+    def __init__(self, p: Callable[[int], Fraction], supp: FrangeSupp) -> None:
+        super().__init__(None, supp)   # type:ignore
+        self.f = p
+
+    @property
+    def p(self):
+        raise AttributeError(f"{self.__class__.__name__} has no attribute 'p'")
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+
+__all__ = [
+    'ConditionalFromDiscreteProbabilityFunc',
+]

danielutils/university/probability/conditional_variable/discrete/discrete.py

@@ -0,0 +1,42 @@
+from fractions import Fraction
+from typing import Union
+
+from ..conditional_variable import ConditionalVariable
+from ...supp import FrangeSupp
+from ...operator import Operator
+
+
+class DiscreteConditionalVariable(ConditionalVariable):
+
+    def __init__(self, p: Union[float, Fraction], supp: FrangeSupp):
+        self._p: Fraction = p if isinstance(p, Fraction) else Fraction.from_float(p)
+        self._supp: FrangeSupp = supp
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.p})"
+
+    @property
+    def supp(self) -> FrangeSupp:
+        return self._supp
+
+    @property
+    def p(self) -> Fraction:
+        return self._p
+
+    def between(self, a, b, op1: Operator, op2: Operator) -> Fraction:   # type:ignore
+        a, b = min(a, b), max(a, b)
+        if not (float(a).is_integer() and float(b).is_integer()):
+            # a = a - (a % self.supp.step)
+            # b = b - (b % self.supp.step)
+            raise NotImplementedError("Only integers are currently implemented")
+        return 1 - (self.evaluate(a, op1.inverse) + self.evaluate(b, op2.inverse))
+
+    def is_equal(self, other) -> bool:
+        if not isinstance(other, DiscreteConditionalVariable):
+            return False
+        return self.__class__ == other.__class__ and self.p == other.p
+
+
+__all__ = [
+    "DiscreteConditionalVariable"
+]

danielutils/university/probability/conditional_variable/discrete/geometric.py

@@ -0,0 +1,43 @@
+from fractions import Fraction
+from typing import Union, Tuple
+
+from .discrete import DiscreteConditionalVariable
+from ...operator import Operator
+from .....better_builtins import frange
+from ...supp import FrangeSupp
+from ...protocols import ExpectedValueCalculable, VariableCalculable
+from .....reflection import get_python_version
+
+
+class Geometric(DiscreteConditionalVariable, ExpectedValueCalculable, VariableCalculable):
+    def __init__(self, p: Union[float, Fraction]):
+        super().__init__(Fraction(p), FrangeSupp(frange(1, float("inf"), 1)))
+
+    def _is_edge_case(self, n: int, op: Operator) -> Tuple[bool, Fraction]:
+        if n <= 0 and op in Operator.greater_than_inequalities():
+            return True, Fraction(1, 1)
+        if n <= 0 and op in Operator.less_than_inequalities():
+            return True, Fraction(0, 1)
+        return False, Fraction(0, 1)
+
+    def evaluate(self, n: int, op: Operator) -> Fraction:
+        if (tup := self._is_edge_case(n, op))[0]:
+            return tup[1]
+        del tup
+
+        if op == Operator.EQ:
+            return (Fraction(1 - self.p) ** (n - 1)) * self.p
+        if op == Operator.GT:
+            return Fraction(1 - self.p) ** n
+        if op == Operator.GE:
+            return self.evaluate(n - 1, Operator.GT)
+        return 1 - self.evaluate(n, op.inverse)
+
+    def expected_value(self) -> Fraction:
+        return Fraction(1, self.p)
+
+    def variance(self) -> Fraction:
+        return Fraction(1 - self.p, self.p ** 2)
+
+
+__all__ = ['Geometric']

danielutils/university/probability/conditional_variable/discrete/poisson.py

@@ -0,0 +1,32 @@
+from fractions import Fraction
+from typing import Union
+from math import e, factorial
+
+from .discrete import DiscreteConditionalVariable
+from ...supp import FrangeSupp
+from ...operator import Operator
+from .....better_builtins import frange
+from ...protocols import ExpectedValueCalculable, VariableCalculable
+
+
+class Poisson(DiscreteConditionalVariable, ExpectedValueCalculable, VariableCalculable):
+    def __init__(self, p: Union[float, Fraction]):
+        super().__init__(p, FrangeSupp(frange(1, float("inf"))))
+
+    def evaluate(self, n: int, op: Operator) -> Fraction:
+        if n < 0:
+            return Fraction(0, 1)
+        if op == Operator.EQ:
+            return Fraction((e ** (-self.p)) * (self.p ** n), factorial(n))  # type:ignore
+
+        assert False  # TODO
+        return 1 - self.evaluate(n, op.inverse)  # type:ignore
+
+    def expected_value(self) -> Fraction:
+        return self.p
+
+    def variance(self) -> Fraction:
+        return self.p
+
+
+__all__ = ['Poisson']

danielutils/university/probability/conditional_variable/discrete/uniform.py

@@ -0,0 +1,33 @@
+from fractions import Fraction
+
+from ...supp import FrangeSupp
+from ...operator import Operator
+
+from .discrete import DiscreteConditionalVariable
+from ...protocols import ExpectedValueCalculable, VariableCalculable
+
+
+class Uniform(DiscreteConditionalVariable, ExpectedValueCalculable, VariableCalculable):
+    def evaluate(self, n: int, op: Operator) -> Fraction:
+        if n not in self.supp:
+            return Fraction(0, 1)
+
+        if op == Operator.EQ:
+            return self.p
+
+        assert False  # TODO
+        return self.evaluate(n, op.inverse)
+
+    def __init__(self, size) -> None:
+        super().__init__(Fraction(1, size), FrangeSupp(range(1, size + 1)))
+
+    def expected_value(self) -> Fraction:
+        return Fraction(Fraction.from_float(self.supp.minimum + self.supp.maximum), 2)
+
+    def variance(self) -> Fraction:
+        return Fraction(
+            Fraction.from_float((self.supp.maximum - self.supp.minimum - 1) ** 2 - 1),
+            12
+        )
+
+    __all__ = ['Uniform']

danielutils/university/probability/distributions.py

@@ -0,0 +1,35 @@
+from enum import Enum
+from .conditional_variable import ConditionalVariable
+from .conditional_variable.discrete import Bernoulli, Geometric, Uniform, Binomial, Poisson
+
+
+class DiscreteDistribution(Enum):
+    Ber = Bernoulli
+    Geo = Geometric
+    Unif = Uniform
+    Bin = Binomial
+    Pois = Poisson
+
+    def __call__(self, *args, **kwargs) -> ConditionalVariable:
+        return self.value(*args, **kwargs)
+
+
+class ContinuousDistribution(Enum):
+    Unif = None
+    Exp = None
+    Normal = None
+
+
+class Distribution:
+    Discrete = DiscreteDistribution
+    Continuous = ContinuousDistribution
+    #     def __getattr__(self, item):
+    #         if item in map(lambda x: x.name, list(self.value)):
+    #             print("foo")
+    #         return super().__getattr__(item)
+
+__all__ = [
+    'DiscreteDistribution',
+    'ContinuousDistribution',
+    'Distribution'
+]

danielutils/university/probability/expressions/__init__.py

@@ -0,0 +1,2 @@
+from .probability_expression import *
+from .accumulation_expression import *