multilingualprogramming 0.2.0__py3-none-any.whl

multilingualprogramming/numeral/mp_numeral.py

@@ -0,0 +1,243 @@
+#
+# SPDX-FileCopyrightText: 2022 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Functions to handle numbers of multiple languages
+"""
+
+from operator import invert, neg
+from roman import toRoman
+from multilingualprogramming.unicode_string import get_unicode_character_string
+import multilingualprogramming.numeral.unicode_numeral as un
+import multilingualprogramming.numeral.roman_numeral as rn
+from multilingualprogramming.exceptions import (
+    MultipleLanguageCharacterMixError,
+    InvalidNumeralCharacterError,
+    DifferentNumeralTypeError
+)
+
+
+class MPNumeral:
+    """
+    Handling numerals in unicode-supported languages and
+    Roman numerals
+    """
+
+    def __init__(self, numstr: str):
+        self.numstr = numstr
+        self.num = None
+        try:
+            if rn.RomanNumeral.is_roman_numeral(numstr):
+                self.num = rn.RomanNumeral(numstr)  # create a Roman numeral
+                self.numeral_type = "Roman"
+            else:
+                self.num = un.UnicodeNumeral(numstr)  # create a Unicode numeral
+                self.numeral_type = "Unicode"
+        except (
+            MultipleLanguageCharacterMixError,
+            InvalidNumeralCharacterError,
+        ) as exception:
+            raise exception
+
+    def to_decimal(self):
+        """
+        Returns the number (Multilingual Numeral) associated with the number string
+        given by the user
+
+        return:
+           number: number associated with the number string
+        """
+        if self.num:
+            return self.num.to_decimal()
+        return None
+
+    def __str__(self):
+        """
+        Returns the original number string (Multilingual Numeral)
+
+        return:
+           numstr: original number string
+        """
+        return self.numstr
+
+    def __repr__(self):
+        """
+        Returns the representation (Multilingual numeral) of an instance
+
+        return:
+           reprstr: representation of an instance
+        """
+
+    def to_mp_numeral(self, number):
+        """
+        Returns the number (Multilingual Numeral) associated with the number string
+        given by the user
+
+        return:
+           mpnumeral: MPNumber associated with the number string
+        """
+        result = None
+        if self.numeral_type == "Roman":
+            result = toRoman(number)
+        else:
+            result = get_unicode_character_string(self.num.language_name, number)
+        return MPNumeral(result)
+
+    def _perform_operation(self, numeral, operation):
+        """
+        Helper function to perform arithmetic operations on MPNumeral objects.
+
+        Parameters:
+            numeral (MPNumeral): The numeral to operate with.
+            operation (function): The arithmetic operation to apply.
+
+        Returns:
+            MPNumeral: The result of the arithmetic operation.
+        """
+        if isinstance(numeral, MPNumeral) and self.numeral_type == numeral.numeral_type:
+            result = operation(self.to_decimal(), numeral.to_decimal())
+            return self.to_mp_numeral(result)
+        raise DifferentNumeralTypeError(operation.__name__)
+
+    def __add__(self, numeral):
+        """
+        Add a MPNumeral with a numeral or another MPNumeral.
+
+        Returns:
+            MPNumeral: The sum of the MPNumeral values.
+        """
+        return self._perform_operation(numeral, lambda x, y: x + y)
+
+    def __mul__(self, numeral):
+        """
+        Multiply a MPNumeral with a numeral or another MPNumeral.
+
+        Returns:
+            MPNumeral: The product of the MPNumeral values.
+        """
+        return self._perform_operation(numeral, lambda x, y: x * y)
+
+    def __lshift__(self, numeral):
+        """
+        Left-shifting of Multilingual numerals
+
+        return:
+           MPNumeral: returns the left shifted value
+        """
+        return self._perform_operation(numeral, lambda x, y: x << y)
+
+    def __rshift__(self, numeral):
+        """
+        Right-shifting of Multilingual numerals
+
+        return:
+           MPNumeral: returns the right shifted value
+        """
+        return self._perform_operation(numeral, lambda x, y: x >> y)
+
+    def __sub__(self, numeral):
+        """
+        Substraction of Multilingual numerals
+
+        return:
+           MPNumeral: returns the difference
+        """
+        return self._perform_operation(numeral, lambda x, y: x - y)
+
+    def __truediv__(self, numeral):
+        """
+        True division of Multilingual numerals
+
+        return:
+           MPNumeral: returns the value after true division
+        """
+        return self._perform_operation(numeral, lambda x, y: x / y)
+
+    def __floordiv__(self, numeral):
+        """
+        Floor division of Multilingual numerals
+
+        return:
+           MPNumeral: returns the value after floor division
+        """
+        return self._perform_operation(numeral, lambda x, y: x // y)
+
+    def __neg__(self):
+        """
+        Negation of Multilingual numerals
+
+        return:
+           MPNumeral: returns the negation
+        """
+        return MPNumeral(str(neg(self.to_decimal())))
+
+    def __pow__(self, numeral):
+        """
+        Power of Multilingual numerals
+
+        return:
+           MPNumeral: returns the power
+        """
+        return self._perform_operation(numeral, lambda x, y: x**y)
+
+    def __mod__(self, numeral):
+        """
+        Modulus of Multilingual numerals
+
+        return:
+           MPNumeral: returns the modulus value
+        """
+        return self._perform_operation(numeral, lambda x, y: x % y)
+
+    def __xor__(self, numeral):
+        """
+        XOR value of Multilingual numerals
+
+        return:
+           MPNumeral: returns the XOR value
+        """
+        return self._perform_operation(numeral, lambda x, y: x ^ y)
+
+    def __invert__(self):
+        """
+        Bitwise inversion value of Multilingual numerals
+
+        return:
+           MPNumeral: returns the bitwise-inverted value
+        """
+        result = invert(self.to_decimal())
+        if self.numeral_type == "Roman":
+            result = toRoman(result)
+        else:
+            result = get_unicode_character_string(self.num.language_name, result)
+        return MPNumeral(result)
+
+    def __or__(self, numeral):
+        """
+        OR value of Multilingual numerals
+
+        return:
+           MPNumeral: returns the OR value
+        """
+        return self._perform_operation(numeral, lambda x, y: x | y)
+
+    def convert_to(self, target_language):
+        """
+        Convert this numeral to a different script.
+
+        Only works for Unicode numerals.
+
+        Parameters:
+            target_language (str): Target language name (e.g., "ARABIC-INDIC")
+
+        Returns:
+            MPNumeral: A new MPNumeral in the target script
+        """
+        if self.numeral_type == "Unicode":
+            converted = self.num.convert_to(target_language)
+            return MPNumeral(str(converted))
+        raise DifferentNumeralTypeError(
+            "Cannot convert Roman numerals to another script"
+        )

multilingualprogramming/numeral/numeral_converter.py

@@ -0,0 +1,151 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Functions for converting numerals between scripts and notations"""
+
+from multilingualprogramming.numeral.unicode_numeral import UnicodeNumeral
+from multilingualprogramming.unicode_string import (
+    get_unicode_character_string,
+)
+
+
+class NumeralConverter:
+    """
+    Utility class for converting numerals between scripts and formats.
+    """
+
+    # Unicode superscript digits for scientific notation
+    SUPERSCRIPT_MAP = {
+        "0": "\u2070",
+        "1": "\u00b9",
+        "2": "\u00b2",
+        "3": "\u00b3",
+        "4": "\u2074",
+        "5": "\u2075",
+        "6": "\u2076",
+        "7": "\u2077",
+        "8": "\u2078",
+        "9": "\u2079",
+        "-": "\u207b",
+    }
+
+    SUPERSCRIPT_REVERSE = {v: k for k, v in SUPERSCRIPT_MAP.items()}
+
+    @staticmethod
+    def convert(numeral, target_language):
+        """
+        Convert a UnicodeNumeral to a different script.
+
+        Parameters:
+            numeral (UnicodeNumeral): The numeral to convert
+            target_language (str): Target language name (e.g., "ARABIC-INDIC")
+
+        Returns:
+            UnicodeNumeral: A new numeral in the target script
+        """
+        return numeral.convert_to(target_language)
+
+    @staticmethod
+    def to_scientific(numeral, language=None):
+        """
+        Convert a numeral to scientific notation string.
+
+        Parameters:
+            numeral (UnicodeNumeral): The numeral to convert
+            language (str): Target language for output (default: same as input)
+
+        Returns:
+            str: Scientific notation string (e.g., "1.23×10³")
+        """
+        value = numeral.to_decimal()
+        lang = language or numeral.language_name or "DIGIT"
+
+        if value == 0:
+            zero = get_unicode_character_string(lang, 0)
+            return zero
+
+        # Calculate mantissa and exponent
+        negative = value < 0
+        abs_value = abs(value)
+
+        exponent = 0
+        mantissa = abs_value
+        if mantissa >= 10:
+            while mantissa >= 10:
+                mantissa /= 10
+                exponent += 1
+        elif 0 < mantissa < 1:
+            while mantissa < 1:
+                mantissa *= 10
+                exponent -= 1
+
+        # Format mantissa
+        if mantissa == int(mantissa):
+            mantissa = int(mantissa)
+
+        # Build the string
+        mantissa_val = -mantissa if negative else mantissa
+        if isinstance(mantissa_val, float):
+            # Round to avoid floating point artifacts
+            mantissa_val = round(mantissa_val, 10)
+
+        if exponent == 0:
+            return get_unicode_character_string(lang, mantissa_val)
+
+        mantissa_str = get_unicode_character_string(lang, mantissa_val)
+        ten_str = get_unicode_character_string(lang, 10)
+
+        # Build superscript exponent
+        exp_str = ""
+        for char in str(exponent):
+            exp_str += NumeralConverter.SUPERSCRIPT_MAP.get(char, char)
+
+        return f"{mantissa_str}\u00d7{ten_str}{exp_str}"
+
+    @staticmethod
+    def from_scientific(sci_str):
+        """
+        Parse a scientific notation string into a UnicodeNumeral.
+
+        Parameters:
+            sci_str (str): Scientific notation string (e.g., "1.23×10³")
+
+        Returns:
+            UnicodeNumeral: The parsed numeral
+        """
+        # Split on multiplication sign
+        if "\u00d7" in sci_str:
+            parts = sci_str.split("\u00d7", 1)
+            mantissa_str = parts[0]
+            base_exp_str = parts[1]
+        else:
+            # No scientific notation, just a plain number
+            return UnicodeNumeral(sci_str)
+
+        # Parse mantissa
+        mantissa_numeral = UnicodeNumeral(mantissa_str)
+        mantissa = mantissa_numeral.to_decimal()
+        lang = mantissa_numeral.language_name
+
+        # Parse exponent from superscript digits after the base
+        # Find where superscripts start
+        exp_chars = ""
+        base_chars = ""
+        for char in base_exp_str:
+            if char in NumeralConverter.SUPERSCRIPT_REVERSE:
+                exp_chars += NumeralConverter.SUPERSCRIPT_REVERSE[char]
+            else:
+                base_chars += char
+
+        exponent = int(exp_chars) if exp_chars else 0
+
+        # Calculate final value, rounding to avoid floating point artifacts
+        result = mantissa * (10 ** exponent)
+        result = round(result, 10)
+        if result == int(result):
+            result = int(result)
+
+        return UnicodeNumeral(get_unicode_character_string(lang, result))

multilingualprogramming/numeral/roman_numeral.py

@@ -0,0 +1,301 @@
+#
+# SPDX-FileCopyrightText: 2022 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Functions to handle Roman numerals
+"""
+
+from operator import invert, neg
+from roman import fromRoman, toRoman
+from multilingualprogramming.exceptions import (
+    InvalidNumeralCharacterError,
+)
+from multilingualprogramming.numeral.abstract_numeral import AbstractNumeral
+
+
+class RomanNumeral(AbstractNumeral):
+    """
+    Handling Roman numerals
+    """
+
+    roman_numerals_list = [
+        "X",
+        "V",
+        "I",
+        "L",
+        "C",
+        "D",
+        "M",
+        "x",
+        "v",
+        "i",
+        "l",
+        "c",
+        "d",
+        "m",
+        "Ⅰ",
+        "Ⅱ",
+        "Ⅲ",
+        "Ⅳ",
+        "Ⅴ",
+        "Ⅵ",
+        "Ⅶ",
+        "Ⅷ",
+        "Ⅸ",
+        "Ⅹ",
+        "Ⅺ",
+        "Ⅻ,Ⅼ",
+        "Ⅽ",
+        "Ⅾ",
+        "Ⅿ",
+        "ↀ",
+        "ↁ",
+        "ↂ",
+        "ↇ",
+        "ↈ",
+        "ⅰ",
+        "ⅱ",
+        "ⅲ",
+        "ⅳ",
+        "ⅴ",
+        "ⅵ",
+        "ⅶ",
+        "ⅷ",
+        "ⅷ",
+        "ⅸ",
+        "ⅹ",
+        "ⅺ",
+        "ⅻ",
+        "ⅼ",
+        "ⅽ",
+        "ⅾ",
+        "ⅿ",
+        "ↅ",
+        "ↆ",
+        "Ↄ",
+    ]
+
+    @classmethod
+    def __verify_roman_characters__(cls, self, numstr: str):
+        """
+        Verify whether each character is a Roman character
+        """
+        for character in numstr:
+            if character not in self.roman_numerals_list:
+                raise InvalidNumeralCharacterError(
+                    "Not a valid number, contains the character: " + character
+                )
+
+    @staticmethod
+    def is_roman_numeral(numstr: str) -> bool:
+        """
+        Verify whether each character is a Roman character
+        """
+        for character in numstr:
+            if character not in RomanNumeral.roman_numerals_list:
+                return False
+        return True
+
+    def __init__(self, numstr: str):
+        super().__init__(numstr)
+        self.numstr = numstr
+        self.__verify_roman_characters__(self, numstr)
+
+    def to_decimal(self):
+        """
+        Returns the number associated with the number string (Roman numeral)
+        given by the user
+
+        return:
+           number: number associated with the number string
+        """
+        return fromRoman(self.numstr)
+
+    @staticmethod
+    def get_roman_numerals() -> list:
+        """
+        Get list of Roman numerals
+        """
+        return RomanNumeral.roman_numerals_list
+
+    def set_roman_numerals(self, numerals: list):
+        """
+        Set list of Roman numerals
+        """
+        self.roman_numerals_list = numerals
+
+    def __str__(self):
+        """
+        Returns the original number string (Roman numeral)
+
+        return:
+           numstr: original number string
+        """
+        return self.numstr
+
+    def __repr__(self):
+        """
+        Returns the representation (Roman numeral) of an instance
+
+        return:
+           reprstr: representation of an instance
+        """
+        return f'RomanNumeral("{self.numstr}")'
+
+    def __add__(self, second):
+        """
+        Add a RomanNumeral with a numeral or another RomanNumeral
+
+        return:
+           RomanNumeral: returns the sum of a RomanNumeral
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() + second.to_decimal()))
+        raise TypeError("Cannot substract a Roman numeral with a non-Roman numeral")
+
+    def __mul__(self, second):
+        """
+        Multiply a RomanNumeral with a numeral or another RomanNumeral
+
+        return:
+           RomanNumeral: multiplication of the two RomanNumeral values
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() * second.to_decimal()))
+        raise TypeError("Cannot multiply a Roman numeral with a non-Roman numeral")
+
+    def __sub__(self, second):
+        """
+        Substraction of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the difference
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() - second.to_decimal()))
+        raise TypeError("Cannot substract a Roman numeral with a non-Roman numeral")
+
+    def __lshift__(self, second):
+        """
+        Left-shifting of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the left shifted value
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() << second.to_decimal()))
+        raise TypeError("Cannot left-shift a Roman numeral with a non-Roman numeral")
+
+    def __rshift__(self, second):
+        """
+        Right-shifting of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the right shifted value
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() >> second.to_decimal()))
+        raise TypeError("Cannot right-shift a Roman numeral with a non-Roman numeral")
+
+    def __truediv__(self, second):
+        """
+        True division of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the value after true division
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() / second.to_decimal()))
+        raise TypeError("Cannot divide a Roman numeral with a non-Roman numeral")
+
+    def __floordiv__(self, second):
+        """
+        Floor division of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the value after floor division
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() // second.to_decimal()))
+        raise TypeError("Cannot floor divide a Roman numeral with a non-Roman numeral")
+
+    def __neg__(self):
+        """
+        Negation of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the negation
+        """
+        return RomanNumeral(toRoman(neg(self.to_decimal())))
+
+    def __pow__(self, second):
+        """
+        Power of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the power
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() ** second.to_decimal()))
+        raise TypeError(
+            "Cannot compute power of a Roman numeral with a non-Roman numeral"
+        )
+
+    def __mod__(self, second):
+        """
+        Modulus of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the modulus value
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() % second.to_decimal()))
+        raise TypeError(
+            "Cannot compute modulus of a Roman numeral with a non-Roman numeral"
+        )
+
+    def __xor__(self, second):
+        """
+        XOR value of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the XOR value
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() ^ second.to_decimal()))
+        raise TypeError(
+            "Cannot compute XOR of a Roman numeral with a non-Roman numeral"
+        )
+
+    def __invert__(self):
+        """
+        Bitwise inversion value of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the bitwise-inverted value
+        """
+        return RomanNumeral(invert(toRoman(self.to_decimal())))
+
+    def __or__(self, second):
+        """
+        OR value of Roman Numerals
+
+        return:
+           AbstractNumeral: returns the OR value
+        """
+        if isinstance(second, RomanNumeral):
+            return RomanNumeral(toRoman(self.to_decimal() | second.to_decimal()))
+        raise TypeError(
+            "Cannot computer OR of a Roman numeral with a non-Roman numeral"
+        )
+
+    def __abs__(self):
+        """
+        Absolute value of Roman Numerals
+
+        return:
+           RomanNumeral: returns the absolute value
+        """
+        return RomanNumeral(toRoman(abs(self.to_decimal())))