Start writing MOs

mapytex/calculus/core/MO/mo.py

@@ -0,0 +1,263 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# vim:fenc=utf-8
+#
+# Copyright © 2017 lafrite <lafrite@Poivre>
+#
+# Distributed under terms of the MIT license.
+
+from mapytex.calculus.core.tree import Tree
+
+class MOError(Exception):
+    pass
+
+class MO(object):
+
+    """MO for math object
+
+    This base class is representing int and Decimal. It stocks its value in 
+    self.value and it 
+    
+    """
+
+    def __init__(self, value):
+        """ Initiate the MO
+
+        It should be idempotent.
+        
+        >>> a = MO(3)
+        >>> a
+        <MO 3>
+        >>> a = MO(a)
+        >>> a
+        <MO 3>
+        
+        """
+        try:
+            self.value = value.value
+        except AttributeError:
+            self.value = value
+
+        self.is_scalar = True
+
+    @classmethod
+    def factory(cls, value):
+        """ Factory to ensure that a value is a MO before using it """
+        if isinstance(value, MO):
+            return value
+        elif isinstance(value, str):
+            return MOstr(value)
+
+        return MO(value)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} {self.__txt__}>"
+
+    def __str__(self):
+        return self.__txt__
+
+    @property
+    def __txt__(self):
+        return str(self.value)
+
+    def __add__(self, other):
+        """ Overload + for MOs
+
+        >>> from decimal import Decimal
+        >>> a = MO(4)
+        >>> b = MO(Decimal("1.2"))
+        >>> a + b
+        <MO 5.2>
+        >>> b + a
+        <MO 5.2>
+        """
+        return MO.factory(self.value + other.value)
+
+    def __mul__(self, other):
+        """ Overload * for MOs
+
+        >>> from decimal import Decimal
+        >>> a = MO(4)
+        >>> b = MO(Decimal("1.2"))
+        >>> a * b
+        <MO 4.8>
+        >>> b * a
+        <MO 4.8>
+        """
+        return MO.factory(self.value * other.value)
+
+    def __truediv__(self, other):
+        """ Overload / for MOs
+
+        >>> from decimal import Decimal
+        >>> a = MO(4)
+        >>> b = MO(Decimal("1.4"))
+        >>> c = b / a
+        >>> c
+        <MO 0.35>
+        >>> type(c.value)
+        <class 'decimal.Decimal'>
+        >>> c = a / b
+        >>> c
+        <MO 2.857142857142857142857142857>
+        >>> type(c.value)
+        <class 'decimal.Decimal'>
+        """
+        return MO.factory(self.value / other.value)
+
+    def __neg__(self):
+        """ Overload + for MOs
+
+        >>> from decimal import Decimal
+        >>> a = MO(4)
+        >>> - a
+        <MO -4>
+        >>> b = MO(Decimal("1.2"))
+        >>> - b
+        <MO -1.2>
+        """
+        return MO.factory(-self.value)
+        
+class MOstr(MO):
+
+    """ Unknown math object like x or n"""
+
+    def __init__(self, value, negative=False):
+        """ Initiate a string MO
+
+        >>> a = MOstr("x")
+        >>> a
+        <MOstr x>
+        >>> a = MOstr("x", negative=True)
+        >>> a
+        <MOstr -x>
+        >>> b = MOstr(a)
+        >>> b
+        <MOstr x>
+
+        >>> MOstr("ui")
+        Traceback (most recent call last):
+            ...
+        mo.MOError: An MOstr should be initiate with a single caracter string
+        >>> MOstr(2)
+        Traceback (most recent call last):
+            ...
+        mo.MOError: An MOstr should be initiate with a string - the unknown
+
+        """
+        try:
+            val = value.value
+        except AttributeError:
+            val = value
+
+        if not isinstance(val, str):
+            raise MOError("An MOstr should be initiate with a string - the unknown")
+        if len(val) != 1:
+            raise MOError("An MOstr should be initiate with a single caracter string")
+
+        MO.__init__(self, value)
+        self.negative = negative
+        self.is_scalar = False
+
+    @property
+    def __txt__(self):
+        return "-"*self.negative + str(self.value)
+
+    def __add__(self, other):
+        raise NotImplemented
+
+    def __radd__(self, other):
+        raise NotImplemented
+
+    def __mul__(self, other):
+        if other.is_scalar:
+            raise NotImplemented
+        raise NotImplemented
+        
+    def __rmul__(self, other):
+        if other.is_scalar:
+            raise NotImplemented
+        raise NotImplemented
+        
+    def __truediv__(self, other):
+        if other.is_scalar:
+            raise NotImplemented
+        raise NotImplemented
+
+    def __rtruediv__(self, other):
+        if other.is_scalar:
+            raise NotImplemented
+        raise NotImplemented
+
+    def __neg__(self):
+        return MO(self.value, not self.negative)
+        
+class MOFraction(MO):
+
+    """ Fraction math object"""
+
+    def __init__(self, numerator, denominator, negative=False):
+        """ Initiate the MOFraction
+
+        It can't be indempotent.
+
+        :param numerator: Numerator of the Fraction
+        :param denominator: Denominator of the Fraction
+        :param negative: Is the fraction negative (not concidering sign of
+        numerator or denominator.
+
+        >>> f = MOFraction(2, 3)
+        >>> f
+        <MOFraction 2 / 3>
+        >>> f = MOFraction(2, 3, negative = True)
+        >>> f
+        <MOFraction - 2 / 3>
+        """
+        value = Tree("/",
+                MO.factory(numerator),
+                MO.factory(denominator),
+                )
+        MO.__init__(self, value)
+
+        self._numerator = numerator
+        self._denominator = denominator
+        self.negative = negative
+
+    @property
+    def __txt__(self):
+        # TODO: fonctionnement temporaire. Il faudrait utilser un moteur de rendu plus fin. |jeu. mars  8 15:26:49 EAT 2018
+        try:
+            numerator = self._numerator.__txt__
+        except AttributeError:
+            numerator = str(self._numerator)
+
+        try:
+            denominator = self._denominator.__txt__
+        except AttributeError:
+            denominator = str(self._denominator)
+        return "- "*self.negative + f"{numerator} / {denominator}"
+
+    def __add__(self, other):
+        """ Overload * for MOFraction
+
+        :param other: any other MO
+        :yields: calculus steps and the final yielded value is a MO.
+
+
+        >>> f = MOFraction(1, 2)
+        >>> g = MOFraction(3, 2)
+        """
+        raise NotImplemented
+
+    def __mul__(self, other):
+        raise NotImplemented
+
+    def __truediv__(self, other):
+        raise NotImplemented
+        
+        
+
+# -----------------------------
+# Reglages pour 'vim'
+# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
+# cursor: 16 del