danielutils 1.1.28__py3-none-any.whl

danielutils/university/probability/expressions/accumulation_expression.py

@@ -0,0 +1,291 @@
+import copy
+from fractions import Fraction
+from typing import Callable, Any, Union, Optional
+from .probability_expression import ProbabilityExpression
+from ..protocols import Evaluable, Equatable
+from ..operator import Operator
+from ....data_structures import BinarySyntaxTree as BST
+
+def _create_operator(op: Operator, reverse: bool = False) -> Callable[['AccumulationExpression', Any], Evaluable]:
+        def operator(self, other) -> Evaluable:
+            lhs, rhs = self, other
+            if reverse:
+                lhs, rhs = rhs, lhs
+            if isinstance(other, (int, float, Fraction)) and op in Operator.order_operators():
+                rhs_expr = ProbabilityExpression(lhs.lhs, op, other) if op in Operator.inequalities() else ProbabilityExpression(other)
+                return AccumulationExpression(lhs, Operator.AND, rhs_expr)
+            raise NotImplementedError("Not Implemented")
+
+        return operator
+
+class AccumulationExpression(Evaluable):
+    @staticmethod
+    def _to_leaf(value: Any) -> BST.Node:
+        if isinstance(value, BST.Node):
+            return value
+        return BST.Node(value)
+
+    @staticmethod
+    def _probability_expression_to_nodes(expr: ProbabilityExpression) -> BST.Node:  # type:ignore
+        if expr.op is None:
+            return AccumulationExpression._to_leaf(expr.lhs)
+        return BST.Node(
+            expr.op,
+            AccumulationExpression._to_leaf(expr.lhs),
+            AccumulationExpression._to_leaf(expr.rhs),
+        )
+
+
+    @staticmethod
+    def _expression_intersection(expr1: ProbabilityExpression, expr2: ProbabilityExpression) -> Fraction:
+        if expr1.is_equal(expr2):
+            return expr1.evaluate()
+
+        a = expr1.rhs
+        op1 = expr1.op
+        b = expr2.rhs
+        op2 = expr2.op
+        X = expr1.lhs
+        if op1 in Operator.greater_than_inequalities() and op2 in Operator.less_than_inequalities():
+            return X.between(a, b, op1, op2)
+
+        if op1 in Operator.greater_than_inequalities() and op2 in Operator.greater_than_inequalities():
+            op = op1
+            if op2 == Operator.GT:
+                op = op2
+            return X.evaluate(max(a, b), op)
+
+        if op1 in Operator.less_than_inequalities() and op2 in Operator.less_than_inequalities():
+            op = op1
+            if op2 == Operator.LT:
+                op = op2
+            return X.evaluate(min(a, b), op)
+
+        if op1 in Operator.equalities() and op2 in Operator.equalities():
+            return Fraction(0, 1)
+
+        if op1 in Operator.equalities():
+            return expr1.evaluate()
+        return expr2.evaluate()
+
+    def __init__(self, lhs: ProbabilityExpression, op: Operator, rhs: ProbabilityExpression) -> None:
+        l = AccumulationExpression._probability_expression_to_nodes(lhs)
+        r = AccumulationExpression._probability_expression_to_nodes(rhs)
+        root = BST.Node(op, l, r)
+        self._tree = BST(root)
+
+    _eq_operator = _create_operator(Operator.EQ)
+    _ne_operator = _create_operator(Operator.NE)
+    _gt_operator = _create_operator(Operator.GT)
+    _ge_operator = _create_operator(Operator.GE)
+    _lt_operator = _create_operator(Operator.LT)
+    _le_operator = _create_operator(Operator.LE)
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, AccumulationExpression):
+            return self.is_equal(other)
+        return self._eq_operator(other)  # type:ignore[return-value]
+
+    def __ne__(self, other) -> bool:
+        if isinstance(other, AccumulationExpression):
+            return not self.is_equal(other)
+        return self._ne_operator(other)  # type:ignore[return-value]
+
+    def __gt__(self, other):
+        return self._gt_operator(other)
+
+    def __ge__(self, other):
+        return self._ge_operator(other)
+
+    def __lt__(self, other):
+        return self._lt_operator(other)
+
+    def __le__(self, other):
+        return self._le_operator(other)
+
+    def __bool__(self) -> bool:
+        if self._tree.root.data != Operator.EQ:
+            return False
+
+        def node_to_equatable(n: BST.Node) -> Equatable:  # type:ignore
+            if n.depth() == 2:  # type:ignore
+                return ProbabilityExpression(n.left.data, n.data, n.right.data)  # type:ignore
+            pass
+
+        if (d := self._tree.depth()) == 3:
+            return node_to_equatable(self._tree.root.left).is_equal(node_to_equatable(self._tree.root.right))
+
+        return NotImplemented
+
+    def __reversed__(self) -> 'AccumulationExpression':
+        return self.reverse()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(lhs={self._tree.root.left}, op={self._tree.root.data}, rhs={self._tree.root.right})"
+
+    def is_equal(self, other) -> bool:
+        if not isinstance(other, AccumulationExpression):
+            return False
+        from ..conditional_variable import ConditionalVariable
+        # I have to create a custom comparer because the BST can't (and shouldn't) know to compare using
+        # ConditionalVariable.is_equal
+        def are_nodes_equal(a: Any, b: Any) -> bool:
+            if not (isinstance(a, BST.Node) and isinstance(b, BST.Node)):
+                if a is None and b is None:
+                    return True
+                return False
+            if isinstance(a.data, Operator) and isinstance(b.data, Operator):  # type:ignore
+                if not (a.data == b.data):  # type:ignore
+                    return False
+            elif isinstance(a.data, ConditionalVariable) and isinstance(b.data, ConditionalVariable):  # type:ignore
+                if not a.data.is_equal(b.data):  # type:ignore
+                    return False
+            else:
+                return a.data == b.data  # type:ignore
+
+            return are_nodes_equal(a.left, b.left) and are_nodes_equal(a.right, b.right)  # type:ignore
+
+        return are_nodes_equal(self.standardize()._tree.root, other.standardize()._tree.root)
+
+    def evaluate(self) -> Fraction:
+        if not self._is_valid_tree():
+            raise AttributeError("Expression is not valid")
+        root = self._tree.root
+        if root.data == Operator.EQ:
+            return self._evaluate_equality(root)
+        if (d := self._tree.depth()) == 3:
+            # example: a < X < b
+            # =>       ____&____          1
+            #         /         \
+            #     ___<___     ___<___     2
+            #    a       X   X       b    3
+            # but actually it is ordered differently
+            # =>       ____&____          1
+            #         /         \
+            #     ___>___     ___<___     2
+            #    X       a   X       b    3
+            a = self._tree.root.left.right.data
+            op1 = self._tree.root.left.data
+            b = self._tree.root.right.right.data
+            op2 = self._tree.root.right.data
+            X = self._tree.root.left.left.data
+            Y = self._tree.root.right.left.data
+            lhs = ProbabilityExpression(X, op1, a)
+            rhs = ProbabilityExpression(Y, op2, b)
+            main_operator = self._tree.root.data
+            if X is Y:
+                if main_operator == Operator.AND:
+                    return AccumulationExpression._expression_intersection(lhs, rhs)
+                numerator: Fraction = AccumulationExpression._expression_intersection(lhs, rhs)
+                denominator: Fraction = rhs.evaluate()
+                return numerator / denominator
+            if X.is_dependent(Y):
+                raise NotImplementedError("This part is not implemented yet")
+            raise NotImplementedError("Illegal State?")
+
+        # example: a < X < Y < b
+        raise NotImplementedError("This part is not implemented yet")
+
+    @staticmethod
+    def _leaf_value(node: BST.Node) -> Any:
+        return node.data
+
+    def _evaluate_equality(self, root: BST.Node) -> Fraction:
+        from ..conditional_variable import ConditionalVariable
+
+        left = root.left
+        right = root.right
+        if left is None or right is None:
+            raise AttributeError("Expression is not valid")
+
+        right_value = self._leaf_value(right)
+        if isinstance(left.data, Operator) and left.left is not None and left.right is not None:
+            lhs_val = self._leaf_value(left.left)
+            rhs_val = self._leaf_value(left.right)
+            if isinstance(lhs_val, ConditionalVariable):
+                variable = lhs_val
+                operand = rhs_val
+                if left.data == Operator.ADD:
+                    target = right_value - operand
+                elif left.data == Operator.SUB:
+                    target = right_value + operand
+                else:
+                    raise NotImplementedError("This part is not implemented yet")
+                return variable.evaluate(target, Operator.EQ)
+            if isinstance(rhs_val, ConditionalVariable):
+                variable = rhs_val
+                operand = lhs_val
+                if left.data == Operator.ADD:
+                    target = right_value - operand
+                elif left.data == Operator.SUB:
+                    target = operand - right_value
+                else:
+                    raise NotImplementedError("This part is not implemented yet")
+                return variable.evaluate(target, Operator.EQ)
+
+        left_value = self._leaf_value(left)
+        if isinstance(right.data, Operator) and right.left is not None and right.right is not None:
+            lhs_val = self._leaf_value(right.left)
+            rhs_val = self._leaf_value(right.right)
+            if isinstance(lhs_val, ConditionalVariable):
+                variable = lhs_val
+                operand = rhs_val
+                if right.data == Operator.ADD:
+                    target = left_value - operand
+                elif right.data == Operator.SUB:
+                    target = left_value + operand
+                else:
+                    raise NotImplementedError("This part is not implemented yet")
+                return variable.evaluate(target, Operator.EQ)
+            if isinstance(rhs_val, ConditionalVariable):
+                variable = rhs_val
+                operand = lhs_val
+                if right.data == Operator.ADD:
+                    target = left_value - operand
+                elif right.data == Operator.SUB:
+                    target = operand - left_value
+                else:
+                    raise NotImplementedError("This part is not implemented yet")
+                return variable.evaluate(target, Operator.EQ)
+
+        if isinstance(left_value, ConditionalVariable):
+            return left_value.evaluate(right_value, Operator.EQ)
+        if isinstance(right_value, ConditionalVariable):
+            return right_value.evaluate(left_value, Operator.EQ)
+        raise AttributeError("Expression is not valid")
+
+    def duplicate(self) -> 'AccumulationExpression':
+        return copy.deepcopy(self)
+
+    def reverse(self) -> 'AccumulationExpression':
+        res = self.duplicate()
+        res._tree = res._tree.reverse()
+        return res
+
+    def standardize(self) -> 'AccumulationExpression':
+        for n in self._tree.traverse(self._tree.TraversalMode.Middle):
+            if n is self._tree.root:
+                break
+            if isinstance(n.data, Operator):
+                if n.data in Operator.greater_than_inequalities():
+                    return self.reverse()
+        return self.duplicate()
+
+    def _is_valid_tree(self) -> bool:
+        q = [self._tree.root]
+        i = 0
+        while i < len(q):
+            if isinstance(q[i], BST.Node):
+                if not isinstance(q[i].data, Operator):
+                    if not q[i].is_leaf:
+                        return False
+                else:
+                    q.append(q[i].left)
+                    q.append(q[i].right)
+            i += 1
+        return True
+
+
+__all__ = [
+    'AccumulationExpression'
+]

danielutils/university/probability/expressions/probability_expression.py

@@ -0,0 +1,110 @@
+from typing import Any, Callable, Optional
+from fractions import Fraction
+from ..protocols import Evaluable
+from ..operator import Operator
+
+
+def _create_operator(op: Operator, reverse: bool = False) -> Callable[['ConditionalVariable', Any], Evaluable]:
+    def operator(self: 'ProbabilityExpression', other: Any) -> Evaluable:
+        lhs, rhs = self, other
+        if reverse:
+            lhs, rhs = rhs, lhs
+        from .accumulation_expression import AccumulationExpression
+
+        if op in Operator.order_operators():
+            if isinstance(rhs, (int, float, Fraction)):
+                if op in Operator.inequalities():
+                    rhs = ProbabilityExpression(lhs.lhs, op, rhs)
+                    return AccumulationExpression(lhs, Operator.AND, rhs)
+                elif op == Operator.EQ:
+                    return AccumulationExpression(lhs, op, ProbabilityExpression(rhs))
+            elif isinstance(rhs, (ProbabilityExpression, AccumulationExpression)):
+                if isinstance(other, ProbabilityExpression):
+                    # TODO P((0<X)<(Y<5))
+                    # I think that this is the solution
+                    return AccumulationExpression(self, op, other)
+            raise NotImplementedError("Illegal state")
+        if op in {Operator.AND, Operator.GIVEN}:
+            if not isinstance(other, ProbabilityExpression):
+                raise NotImplementedError("Illegal state")
+            return AccumulationExpression(lhs, op, rhs)
+        raise NotImplementedError("Illegal state 2")
+
+    return operator
+class ProbabilityExpression(Evaluable):
+    OPERATOR_TYPE = Callable[['ProbabilityExpression', Any], 'AccumulationExpression']
+
+
+    def __init__(self, lhs: Evaluable, op: Optional[Operator] = None, rhs: Optional[Any] = None):
+        self._lhs = lhs
+        self._op = op
+        self._rhs = rhs
+
+    __eq__: OPERATOR_TYPE = _create_operator(Operator.EQ)
+    __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)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.lhs} {self.op.value} {self.rhs})"
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.lhs, self.op, self.rhs))
+
+    @property
+    def lhs(self):
+        return self._lhs
+
+    @property
+    def op(self):
+        return self._op
+
+    @property
+    def rhs(self):
+        return self._rhs
+
+    @property
+    def is_partial(self) -> bool:
+        return self.op is not None and self.rhs is not None
+
+    def evaluate(self) -> Fraction:
+        return self.lhs.evaluate(self.rhs, self.op)
+
+    def is_equal(self, other) -> bool:
+        if not isinstance(other, ProbabilityExpression):
+            raise TypeError(
+                f"Cant compare equality between {self.__class__.__qualname__} and non ConditionalExpression")
+        from ..conditional_variable import ConditionalVariable
+        if isinstance(self.lhs, ConditionalVariable) and not isinstance(other.lhs, ConditionalVariable):
+            return False
+        if not isinstance(self.lhs, ConditionalVariable) and isinstance(other.lhs, ConditionalVariable):
+            return False
+        # We need this complicated thing instead of doing self.lhs == other.lhs (and same for rhs) because we
+        # cant use __eq__
+
+        # TODO make better
+        if isinstance(self.lhs, ConditionalVariable):
+            if not (self.lhs.__class__ == other.lhs.__class__):
+                return False
+        else:
+            if not (self.lhs == other.lhs):
+                return False
+
+        if isinstance(self.rhs, ConditionalVariable):
+            if not (self.rhs.__class__ == other.rhs.__class__):
+                return False
+        else:
+            if not (self.rhs == other.rhs):
+                return False
+
+        return self.op == other.op
+
+
+__all__ = [
+    'ProbabilityExpression',
+]

danielutils/university/probability/funcs/__init__.py

@@ -0,0 +1,4 @@
+from .covariance import *
+from .expected_value import *
+from .probability_function import *
+from .variance import *

danielutils/university/probability/funcs/covariance.py

@@ -0,0 +1,12 @@
+from fractions import Fraction
+from .expected_value import expected_value as E
+from ..conditional_variable import ConditionalVariable
+
+def covariance(X: ConditionalVariable, Y: ConditionalVariable) -> Fraction:
+    # alternative = E((X - E(X)) * (Y - E(Y)))
+    return E(X * Y) - E(X) * E(Y)   # type:ignore
+
+
+__all__ = [
+    "covariance",
+]

danielutils/university/probability/funcs/expected_value.py

@@ -0,0 +1,41 @@
+from typing import Union, Any, Callable, Dict
+
+from fractions import Fraction
+from ..conditional_variable import ConditionalVariable
+from .probability_function import probability_function as P
+from ..expressions import ProbabilityExpression
+from ..operator import Operator
+from ..protocols import ExpectedValueCalculable
+
+_mapping: Callable[[Any], Dict[Operator, Callable]] = lambda const: {
+    Operator.POW: lambda n: n ** const,
+    Operator.MUL: lambda n: n * const,
+    Operator.DIV: lambda n: n / const,
+    Operator.MODULUS: lambda n: n & const,
+}
+
+
+def expected_value(obj: Union[ConditionalVariable, ProbabilityExpression]) -> Fraction:
+    if isinstance(obj, ExpectedValueCalculable):
+        return obj.expected_value()
+    res = Fraction(0, 1)
+    if isinstance(obj, ConditionalVariable):
+        X = obj
+        for n in X.supp:
+            res += n * P(X == n)  # type:ignore
+        return res
+    if isinstance(obj.rhs, int):
+        const = obj.rhs
+        op = obj.op
+        X = obj.lhs
+
+        def f(n: Union[int, float, Fraction]) -> Union[int, float, Fraction]:
+            return _mapping(const)[op](n)
+
+        for n in X.supp:
+            res += f(n) * P(X == n)  # type:ignore
+        return res
+    assert False
+
+
+__all__ = ['expected_value']

danielutils/university/probability/funcs/probability_function.py

@@ -0,0 +1,14 @@
+from ..protocols import Evaluable
+from fractions import Fraction
+
+
+def probability_function(*evaluables: Evaluable[Fraction]) -> Fraction:
+    res = Fraction(1, 1)
+    for evaluable in evaluables:
+        res *= evaluable.evaluate()
+    return res
+
+
+__all__ = [
+    'probability_function',
+]

danielutils/university/probability/funcs/variance.py

@@ -0,0 +1,17 @@
+from fractions import Fraction
+from .expected_value import expected_value as E
+from ..conditional_variable import ConditionalVariable
+from ..protocols import VariableCalculable
+
+
+def variance(obj: ConditionalVariable) -> Fraction:
+    if isinstance(obj, VariableCalculable):
+        return obj.variance()
+    X = obj
+    # alternative = E((X - E(X)) ** 2)
+    return E(X ** 2) - E(X) ** 2   # type:ignore
+
+
+__all__ = [
+    'variance'
+]

danielutils/university/probability/operator.py

@@ -0,0 +1,79 @@
+from enum import Enum
+from typing import Set as Set
+from ...reflection import get_python_version
+
+if get_python_version() >= (3, 9):
+    from builtins import set as Set
+
+
+class Operator(Enum):
+    """
+    Operator Enum to define the types of operators.
+    """
+    EQ = "=="
+    NE = "!="
+    GT = ">"
+    GE = ">="
+    LT = "<"
+    LE = "<="
+
+    @staticmethod
+    def strong_inequalities() -> Set['Operator']:
+        return {Operator.GT, Operator.LT}
+
+    @staticmethod
+    def weak_inequalities() -> Set['Operator']:
+        return {Operator.GE, Operator.LE}
+
+    @staticmethod
+    def inequalities() -> Set['Operator']:
+        return Operator.strong_inequalities().union(Operator.weak_inequalities())
+
+    @staticmethod
+    def equalities() -> Set['Operator']:
+        return {Operator.EQ, Operator.NE}
+
+    @staticmethod
+    def greater_than_inequalities() -> Set['Operator']:
+        return {Operator.GE, Operator.GT}
+
+    @staticmethod
+    def less_than_inequalities() -> Set['Operator']:
+        return {Operator.LE, Operator.LT}
+
+    @staticmethod
+    def order_operators() -> Set['Operator']:
+        return Operator.inequalities().union(Operator.equalities())
+
+    MUL = "*"
+    DIV = "/"
+    MODULUS = "%"
+    GIVEN = '|'
+    AND = '&'
+    POW = '**'
+    ADD = "+"
+    SUB = "-"
+
+    @property
+    def inverse(self) -> 'Operator':
+        """
+        Returns the inverse of the operator.
+        Returns:
+            Operator (Enum): the inverse of the operator.
+        """
+        dct = {
+            Operator.EQ: Operator.NE,
+            Operator.NE: Operator.EQ,
+            Operator.GT: Operator.LE,
+            Operator.LE: Operator.GT,
+            Operator.GE: Operator.LT,
+            Operator.LT: Operator.GE
+        }
+        if self not in dct:
+            raise ValueError(f"Operator.{self.name} does not support 'inverse'.")
+        return dct[self]
+
+
+__all__ = [
+    "Operator"
+]

danielutils/university/probability/protocols.py

@@ -0,0 +1,32 @@
+from fractions import Fraction
+from typing import runtime_checkable, Protocol, TypeVar
+
+T = TypeVar('T')
+
+
+@runtime_checkable
+class Evaluable(Protocol[T]):
+    def evaluate(self, *args, **kwargs) -> T: ...
+
+
+@runtime_checkable
+class ExpectedValueCalculable(Protocol):
+    def expected_value(self) -> Fraction: ...
+
+
+@runtime_checkable
+class VariableCalculable(Protocol):
+    def variance(self) -> Fraction: ...
+
+
+@runtime_checkable
+class Equatable(Protocol):
+    def is_equal(self, other) -> bool: ...
+
+
+__all__ = [
+    'Evaluable',
+    'VariableCalculable',
+    "ExpectedValueCalculable",
+    'Equatable',
+]