Repository: opensource-nepal/py-nepali (language: python)

Issue:
Create a feature for nepali numbers with nepalinumber class
Let's create `nepalinumber` class which will be compatible with python's `int`, `float`, etc numbers. The major features will be comparison, addition, subtraction, multiplication, and division. A lot of features can be added later.

Here are some basic example of this class

```python
from nepali.number import nepalinumber

# initialization
np_number = nepalinumber(1234)
np_number = nepalinumber("1234")
np_number = nepalinumber("१२३४")
np_number = nepalinumber("12.34")

# comparison
np_number == 10
np_number >= nepalinumber("१२")

# addition, subscription, multiplication, division
a = np_number / 10 * nepalinumber("४") + 300 - nepalinumber("१.२")

# output
float(a)
int(a)
str(a)
a.str_ne()  # returns Devanagari number format
a.str_en()  # return in English number format
```


Discussion / hints:
Basic POC.

```python
>>> class nepalinumber(float):
...     pass
...
>>>
>>> a = nepalinumber(1)
>>> 1 + a
2.0
>>> a + 1
2.0
>>> a / 2
0.5
>>> str(a)
'1.0'
>>> a == 1
True
>>> a > 2
False
>>> a <= 1
True
```

cc: @sugat009, @ecedreamer 
- Type casting nepalinumber to int and float
- Addition operation between int, float and nepalinumber.
```python
from typing import Optional, TypeVar

selfnepalinumber = TypeVar("selfnepalinumber", bound="nepalinumber")


class nepalinumber:
    def __init__(self, value) -> None:
        self.value = value

    def __str__(self) -> str:
        return str(self.value)

    def __int__(self) -> int:
        return int(self.value)

    def __float__(self) -> float:
        return float(self.value)

    def __add(self, other) -> Optional[selfnepalinumber]:
        if (
            (isinstance(self.value, int) and isinstance(other, int))
            or (isinstance(self.value, int) and isinstance(other, float))
            or (isinstance(self.value, float) and isinstance(other, int))
            or (isinstance(self.value, float) and isinstance(other, float))
        ):
            val = self.value + other

            return nepalinumber(val)
        elif isinstance(other, nepalinumber):
            val = self.value + other.value

            return nepalinumber(val)
        return None

    def __add__(self, other) -> selfnepalinumber:
        added_value = self.__add(other)

        if added_value:
            return added_value

        raise Exception(
            f'Operator "+" not supported for types nepalinumber and "{type(object)}'
        )

    def __radd__(self, other) -> selfnepalinumber:
        added_value = self.__add(other)

        if added_value:
            return added_value

        raise Exception(
            f'Operator "+" not supported for types "{type(object)} and nepalinumber'
        )


if __name__ == "__main__":
    num = nepalinumber(10)
    print(float(num))

    num2 = nepalinumber(1.1)
    print(int(num2))

    num3 = 69
    num4 = 20

    print(num + num3)
    print(num + num2)
    print(num4 + num)
    print(num4 + num2)
    print(num + num2)
```
@sugat009, Yours looks good to me. Let's discuss about the extra features/test cases if any and start the development.

Fix patch:
diff --git a/README.md b/README.md
index afcece6..f42a788 100644
--- a/README.md
+++ b/README.md
@@ -50,6 +50,7 @@ phone_number.parse("+977-9845217789")
    - [parse](#parse)
    - [strftime() and strptime() Format Codes](#strftime-and-strptime-format-codes)
 2. [Numbers](#numbers)
+    - [nepalinumber](#nepalinumber)
 3. [Phone Number](#phone-number)
 4. [Locations](#locations)
 
@@ -341,6 +342,35 @@ Adds comma in nepali numbers.
 number_text = number.add_comma("1234567890")  # 1,23,45,67,890
 ```
 
+### nepalinumber
+`nepalinumber` is a new data type, which can be used to represent Nepali (Devanagari) numbers. It allows us to perform arithmetic operations, just like with int and float. Additionally, it can be used to parse numbers and output them in Devanagari format.
+
+```python
+from nepali.number import nepalinumber
+```
+
+**Parsing**
+```python
+a = nepalinumber("१८.२७")
+print(a)  # 18.27
+
+b = nepalinumber(15)
+print(b)  # 15
+```
+
+**Nepali (Devanagari) output**
+```python
+a = nepalinumber("18.27")
+print(a.str_ne())  # १८.२७
+```
+
+**Arithmetic operations**
+```python
+a = nepalinumber("1")
+b = nepalinumber("२")
+c = a + b * 3
+print(c)  # 7
+```
 ---
 
 ## Phone Number
diff --git a/nepali/number.py b/nepali/number.py
deleted file mode 100644
index 193c47a..0000000
--- a/nepali/number.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import warnings
-from typing import Any
-
-
-NP_NUMBERS = ["०", "१", "२", "३", "४", "५", "६", "७", "८", "९"]
-
-
-def english_to_nepali(number: Any) -> str:
-    """
-    Converts english number to nepali.
-    """
-    number = str(number)
-    converted_number = []
-    for n in number:
-        if n.isdigit() and int(n) in range(0, 10):
-            converted_number.append(NP_NUMBERS[int(n)])
-        else:
-            converted_number.append(n)
-    return "".join(converted_number)
-
-
-def nepali_to_english(number: Any) -> str:
-    """
-    Converts nepali number to english.
-    """
-    number = str(number)
-    converted_number = []
-    nepali_number_set = set(NP_NUMBERS)
-    for n in number:
-        if n in nepali_number_set:
-            converted_number.append(str(NP_NUMBERS.index(n)))
-        else:
-            converted_number.append(n)
-    return "".join(converted_number)
-
-
-def add_comma_english(number: Any) -> str:
-    """
-    Adds comma in english style
-    Eg. 123456789 => 123,456,789
-    """
-    return "{:,}".format(int(number))
-
-
-def add_comma(number: Any, convert=False) -> str:
-    """
-    Adds comma in nepali style
-    Eg. 123456789 => 12,34,56,789
-
-    :param number Any: Number to be converted
-    :param convert bool: If true converts english number to nepali
-    """
-    if convert:
-        number = english_to_nepali(number)
-    else:
-        number = str(number)
-
-    number_with_comma = []
-    counter = 0
-    for nepali_number_char in list(str(number))[::-1]:
-        if counter == 3 or (counter != 1 and (counter - 1) % 2 == 0):
-            number_with_comma.append(",")
-        number_with_comma.append(nepali_number_char)
-        counter += 1
-
-    return "".join(number_with_comma[::-1])
-
-
-def convert_and_add_comma(number: Any) -> str:
-    """
-    Converts the number into nepali text and adds comma to it.
-    """
-    return add_comma(number, convert=True)
-
-
-# Backward compatibility support for legacy NepaliNumber
-class NepaliNumber:
-    @classmethod
-    def convert_and_add_comma(cls, number):
-        warnings.warn(
-            message="NepaliNumber.convert_and_add_comma has been moved to `convert_and_add_comma. This function is depreciated and will be removed in the future release.",
-            category=DeprecationWarning,
-        )
-        return add_comma(english_to_nepali(number))
-
-    @staticmethod
-    def convert(num):
-        warnings.warn(
-            message="NepaliNumber.convert has been moved to `english_to_nepali. This function is depreciated and will be removed in the future release.",
-            category=DeprecationWarning,
-        )
-        return english_to_nepali(num)
-
-    @staticmethod
-    def revert(num):
-        warnings.warn(
-            message="NepaliNumber.revert has been moved to `nepali_to_english. This function is depreciated and will be removed in the future release.",
-            category=DeprecationWarning,
-        )
-        return nepali_to_english(num)
-
-    @staticmethod
-    def add_comma(number):
-        warnings.warn(
-            message="NepaliNumber.add_comma has been moved to `add_comma. This function is depreciated and will be removed in the future release.",
-            category=DeprecationWarning,
-        )
-        return add_comma(number)
-
-    @staticmethod
-    def add_comma_english(number):
-        warnings.warn(
-            message="NepaliNumber.add_comma_english has been moved to `add_comma_english. This function is depreciated and will be removed in the future release.",
-            category=DeprecationWarning,
-        )
-        return add_comma_english(number)
diff --git a/nepali/number/__init__.py b/nepali/number/__init__.py
new file mode 100644
index 0000000..abb6ebf
--- /dev/null
+++ b/nepali/number/__init__.py
@@ -0,0 +1,19 @@
+from ._number import NepaliNumber
+from ._nepalinumber import nepalinumber
+from .utils import (
+    add_comma,
+    add_comma_english,
+    convert_and_add_comma,
+    english_to_nepali,
+    nepali_to_english,
+)
+
+__all__ = [
+    "NepaliNumber",
+    "add_comma",
+    "add_comma_english",
+    "convert_and_add_comma",
+    "english_to_nepali",
+    "nepali_to_english",
+    "nepalinumber",
+]
diff --git a/nepali/number/_nepalinumber.py b/nepali/number/_nepalinumber.py
new file mode 100644
index 0000000..413c85b
--- /dev/null
+++ b/nepali/number/_nepalinumber.py
@@ -0,0 +1,547 @@
+"""
+Contains the class for the nepalinumber feature
+"""
+
+from typing import Any, Tuple, Type, Union
+from .utils import NP_NUMBERS, NP_NUMBERS_SET, english_to_nepali
+
+
+class nepalinumber:
+    """
+    Represents the nepali(devanagari) numbers and
+    the features related to arithmetic operations
+    on them
+    """
+
+    def __init__(self, value: Any) -> None:
+        """
+        Constructor/Initializer
+        """
+        self.__value = self.__parse(value)
+
+    def _raise_parse_exception(self, obj, ex_class: Type[Exception] = ValueError):
+        raise ex_class(
+            f"could not convert {obj.__class__.__name__} to {self.__class__.__name__}: '{obj}'"
+        ) from None
+
+    def __parse(self, value: Any) -> Union[int, float]:
+        """
+        Parses nepali number input into a valid value.
+
+        Eg:
+        >>> self.__parse("१२")
+        12
+        >>> self.__parse("१२.३")
+        12.3
+        >>> self.__parse(1)
+        1
+        >>> self.__parse("invalid")
+        ValueError: could not convert str to nepalinumber: 'invalid'
+
+        :param value: Value to be parsed.
+        :return: returns value int or float
+        :raises ValueError: If the value is invalid
+        :raises TypeError: If the value object can't be parsed
+        """
+        if isinstance(value, int):
+            return int(value)
+
+        elif isinstance(value, float):
+            return float(value)
+
+        elif isinstance(value, str):
+            return self.__parse_str(value)
+
+        return self.__parse_object(value)
+
+    def __parse_str(self, value: str) -> Union[int, float]:
+        """
+        Parses str object into int and float.
+        This is a low level implementation.
+
+        :raises ValueError: If the value is invalid
+        """
+        result = 0
+        sign = 1
+        decimal_found = False
+        decimal_place = 1
+        i = 0
+
+        # for negative sign
+        if value[0] == "-":
+            sign = -1
+            i = 1
+
+        while i < len(value):
+            # decimal number found
+            if value[i] == ".":
+                if decimal_found:
+                    # decimal was already found
+                    self._raise_parse_exception(value)
+                decimal_found = True
+                i += 1
+                continue
+
+            digit = ord(value[i]) - ord("0")
+            if digit < 0 or digit > 9:
+                # checking nepali character
+                if value[i] not in NP_NUMBERS_SET:
+                    self._raise_parse_exception(value)
+                digit = NP_NUMBERS.index(value[i])
+
+            if decimal_found:
+                decimal_place /= 10
+                result += digit * decimal_place
+            else:
+                result = result * 10 + digit
+
+            i += 1
+        return sign * result
+
+    def __parse_object(self, obj: Any) -> Union[int, float]:
+        """
+        Parses object using __int__, __float__, and __str__.
+
+        :raises TypeError: If the value object can't be parsed
+        """
+        try:
+            if hasattr(obj, "__float__"):
+                return float(obj)
+            elif hasattr(obj, "__int__"):
+                return int(obj)
+
+            return self.__parse_str(str(obj))
+        except (ValueError, TypeError):
+            # object conversion must raise TypeError if fails
+            self._raise_parse_exception(obj, ex_class=TypeError)
+
+    def __convert_or_return(self, obj) -> Union["nepalinumber", object]:
+        """
+        Will try to parse the given object and convert to nepalinumber
+        else will return the same object
+
+        :param obj: The object to convert
+
+        :returns: Either a nepalinumber or the same object unchanged
+        """
+        try:
+            return nepalinumber(obj)
+        except (TypeError, ValueError) as e:
+            return obj
+
+    def __str__(self) -> str:
+        """
+        Called when the object is called with functions
+        like print or logger.debug()
+        """
+        return str(self.__value)
+
+    def __repr__(self) -> str:
+        return str(self.__value)
+
+    def __int__(self) -> int:
+        """
+        Called when the object is typecasted into integer
+        """
+        return int(self.__value)
+
+    def __float__(self) -> float:
+        """
+        Called when the object is typecasted into float
+        """
+        return float(self.__value)
+
+    def __add(self, other) -> Union[int, float]:
+        """
+        Adds the value in the object with the passed object
+
+        :param other: The other number/object to be added to the object
+        :raises TypeError: Raised when unsupported data types
+            are added to the nepalinumber object
+        :return: A new nepalinumber object with the added values
+        """
+        if isinstance(other, nepalinumber):
+            return self.__value + other.value
+
+        return self.__value + other
+
+    def __mul(self, other) -> Union[int, float]:
+        """
+        Multiplies the value in the object with the passed object
+
+        :param other: The other number/object to be added to the object
+        :raises TypeError: Raised when unsupported data types
+            are multiplied to the nepalinumber object
+        :return: A new nepalinumber object with the multiplied values
+        """
+        if isinstance(other, nepalinumber):
+            return self.__value * other.value
+
+        return self.__value * other
+
+    def __eq__(self, other) -> bool:
+        """
+        Checks if nepalinumber is equal to another object
+
+        :param other: The other number/object which is to be checked for
+            equality againt nepalinumber
+        :return: True if equal else False
+        """
+        if isinstance(other, nepalinumber):
+            return self.__value == other.value
+
+        return self.__value == other
+
+    def __ne__(self, other) -> bool:
+        """
+        Checks if nepalinumber is not equal to another object
+
+        :param other: The other number/object which is to be checked for
+            equality againt nepalinumber
+        :return: True if not equal else False
+        """
+        if isinstance(other, nepalinumber):
+            return self.__value != other.value
+
+        return self.__value != other
+
+    def __neg__(self) -> "nepalinumber":
+        """
+        Returns the negative value of the nepalinumber value
+        """
+        return nepalinumber((-1) * self.__value)
+
+    def __add__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the addition operator +  is used after
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            added to the value onto the nepalinumber object
+        :raises TypeError: Raised when unsupported data types
+            are added to the nepalinumber object
+        :return: Returns the added value as a nepalinumber
+            object
+        """
+        try:
+            return self.__convert_or_return(self.__add(other))
+        except TypeError:
+            return NotImplemented
+
+    def __radd__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the addition operator + is used before
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            added to the value onto the nepalinumber object
+        :raises TypeError: Raised when nepalinumber object is
+            added to unsupported data types
+        :return: Returns the added value as a nepalinumber
+            object
+        """
+        try:
+            return self.__convert_or_return(self.__add(other))
+        except TypeError:
+            return NotImplemented
+
+    def __sub__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the subtraction operator - is used after
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            subtracted from the value in the nepalinumber object
+        :raises TypeError: Raised when unsupported data types are
+            subtracted from nepalinumber object
+        :return: Returns the subtracted number as a nepalinumber object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(self.__value - other.value)
+
+            return self.__convert_or_return(self.__value - other)
+        except TypeError:
+            return NotImplemented
+
+    def __rsub__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the subtraction operator - is used before
+        the nepalinumber object
+
+        :param other: The other number/object that is to get
+            subtracted by the value in the nepalinumber object
+        :raises TypeError: Raised when nepalinumber object is
+            subtracted from  unsupported data types
+        :return: Returns the subtracted number as a nepalinumber
+             object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(other.value - self.__value)
+
+            return self.__convert_or_return(other - self.__value)
+        except TypeError:
+            return NotImplemented
+
+    def __mul__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the multiplication operator * is used after
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            multiplied to the value onto the nepalinumber object
+        :raises TypeError: Raised when unsupported data types
+            are multiplied to the nepalinumber object
+        :return: Returns the multiplied value as a nepalinumber
+            object
+        """
+        try:
+            if isinstance(other, str):
+                return self.__value * other  # type: ignore
+
+            return self.__convert_or_return(self.__mul(other))
+        except TypeError:
+            return NotImplemented
+
+    def __rmul__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the multiplication operator * is used before
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            multiplied to the value onto the nepalinumber object
+        :raises TypeError: Raised when nepalinumber object is
+            multiplied to unsupported data types
+        :return: Returns the multiplied value as a nepalinumber
+            object
+        """
+        try:
+            if isinstance(other, str):
+                return other * self.__value  # type: ignore
+
+            return self.__convert_or_return(self.__mul(other))
+        except TypeError:
+            return NotImplemented
+
+    def __truediv__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the division operator / is used after
+        the nepalinumber object
+
+        :param other: The other number/object that is to divide
+            the value in the nepalinumber object
+        :raises TypeError: Raised when unsupported data types are
+            used to divide nepalinumber object
+        :return: Returns the quotient number as a nepalinumber object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(self.__value / other.value)
+
+            return self.__convert_or_return(self.__value / other)
+        except TypeError:
+            return NotImplemented
+
+    def __rtruediv__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the division operator / is used before
+        the nepalinumber object
+
+        :param other: The other number/object that is to get
+            dividied by the value in the nepalinumber object
+        :raises TypeError: Raised when nepalinumber object is
+            used to divide unsupported data types
+        :return: Returns the quotient number as a nepalinumber
+             object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(other.value / self.__value)
+
+            return self.__convert_or_return(other / self.__value)
+        except TypeError:
+            return NotImplemented
+
+    def __floordiv__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the floor/integer division operator // is used
+        after the nepalinumber object
+
+        :param other: The other number/object that is to divide
+            the value in the nepalinumber object
+        :raises TypeError: Raised when unsupported data types are
+            used to divide nepalinumber object
+        :return: Returns the quotient number as a nepalinumber object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(self.__value // other.value)
+
+            return self.__convert_or_return(self.__value // other)
+        except TypeError:
+            return NotImplemented
+
+    def __rfloordiv__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the floor/integer division operator // is used
+        before the nepalinumber object
+
+        :param other: The other number/object that is to get
+            dividied by the value in the nepalinumber object
+        :raises TypeError: Raised when nepalinumber object is
+            used to divide unsupported data types
+        :return: Returns the quotient number as a nepalinumber
+             object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(other.value // self.__value)
+
+            return self.__convert_or_return(other // self.__value)
+        except TypeError:
+            return NotImplemented
+
+    def __mod__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the modulo operator % is used after
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            perform modulo division from the value in the
+            nepalinumber object
+        :raises TypeError: Raised when unsupported data types are
+            modulo divided from nepalinumber object
+        :return: Returns the remainder number as a nepalinumber object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(self.__value % other.value)
+
+            return self.__convert_or_return(self.__value % other)
+        except TypeError:
+            return NotImplemented
+
+    def __rmod__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the modulo operator % is used before
+        the nepalinumber object
+
+        :param other: The other number/object that is to get
+            modulo divided by the value in the nepalinumber object
+        :raises TypeError: Raised when nepalinumber object is
+            used modulo divide unsupported data types
+        :return: Returns the remainder number as a nepalinumber
+             object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(other.value % self.__value)
+
+            return self.__convert_or_return(other % self.__value)
+        except TypeError:
+            return NotImplemented
+
+    def __divmod__(
+        self, other
+    ) -> Tuple[Union["nepalinumber", object], Union["nepalinumber", object]]:
+        """
+        Called when the built-in function divmod() is used
+        with nepalinumber as the dividend and other as divisor
+
+        :param other: The other number/object that is to be
+            divisor for the value in the nepalinumber object
+        :raises TypeError: Raised when unsupported data types are
+            used as divisor for nepalinumber object
+        :return: Returns a tuple of quotient and remainder
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                quotient, remainder = divmod(self.__value, other.value)
+
+            quotient, remainder = divmod(self.__value, other)
+
+            return self.__convert_or_return(quotient), self.__convert_or_return(
+                remainder
+            )
+        except TypeError:
+            return NotImplemented
+
+    def __rdivmod__(
+        self, other
+    ) -> Tuple[Union["nepalinumber", object], Union["nepalinumber", object]]:
+        """
+        Called when the built-in function divmod() is used
+        with nepalinumber as the divisor and other as dividend
+
+        :param other: The other number/object that is to be
+            dividend for the value in the nepalinumber object
+        :raises TypeError: Raised when unsupported data types are
+            used as dividend for nepalinumber object
+        :return: Returns a tuple of quotient and remainder
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                quotient, remainder = divmod(other.value, self.__value)
+
+            quotient, remainder = divmod(other, self.__value)
+
+            return self.__convert_or_return(quotient), self.__convert_or_return(
+                remainder
+            )
+        except TypeError:
+            return NotImplemented
+
+    def __pow__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the power operator **  is used after
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            powered to the value onto the nepalinumber object
+        :raises TypeError: Raised when unsupported data types
+            are powered to the nepalinumber object
+        :return: Returns the powered by value as a nepalinumber
+            object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(self.__value**other.value)
+
+            return self.__convert_or_return(self.__value**other)
+        except TypeError:
+            return NotImplemented
+
+    def __rpow__(self, other) -> Union["nepalinumber", object]:
+        """
+        Called when the power operator ** is used before
+        the nepalinumber object
+
+        :param other: The other number/object that is to be
+            powered by the value onto the nepalinumber object
+        :raises TypeError: Raised when unsupported data types
+            are powered by the nepalinumber object
+        :return: Returns the powered by value as a nepalinumber
+            object
+        """
+        try:
+            if isinstance(other, nepalinumber):
+                return self.__convert_or_return(other.value**self.__value)
+
+            return self.__convert_or_return(other**self.__value)
+        except TypeError:
+            return NotImplemented
+
+    def str_ne(self) -> str:
+        """
+        Returns nepali (devanagari) format for the number
+
+        :return: Stringified Nepali number
+        """
+        if not hasattr(self, "__str_ne"):
+            self.__str_ne = english_to_nepali(self.__value)
+        return self.__str_ne
+
+    @property
+    def value(self):
+        return self.__value
diff --git a/nepali/number/_number.py b/nepali/number/_number.py
new file mode 100644
index 0000000..266bbd3
--- /dev/null
+++ b/nepali/number/_number.py
@@ -0,0 +1,51 @@
+import warnings
+
+from .utils import (
+    add_comma,
+    add_comma_english,
+    english_to_nepali,
+    nepali_to_english,
+)
+
+
+# Backward compatibility support for legacy NepaliNumber
+class NepaliNumber:
+    @classmethod
+    def convert_and_add_comma(cls, number):
+        warnings.warn(
+            message="NepaliNumber.convert_and_add_comma has been moved to `convert_and_add_comma. This function is depreciated and will be removed in the future release.",
+            category=DeprecationWarning,
+        )
+        return add_comma(english_to_nepali(number))
+
+    @staticmethod
+    def convert(num):
+        warnings.warn(
+            message="NepaliNumber.convert has been moved to `english_to_nepali. This function is depreciated and will be removed in the future release.",
+            category=DeprecationWarning,
+        )
+        return english_to_nepali(num)
+
+    @staticmethod
+    def revert(num):
+        warnings.warn(
+            message="NepaliNumber.revert has been moved to `nepali_to_english. This function is depreciated and will be removed in the future release.",
+            category=DeprecationWarning,
+        )
+        return nepali_to_english(num)
+
+    @staticmethod
+    def add_comma(number):
+        warnings.warn(
+            message="NepaliNumber.add_comma has been moved to `add_comma. This function is depreciated and will be removed in the future release.",
+            category=DeprecationWarning,
+        )
+        return add_comma(number)
+
+    @staticmethod
+    def add_comma_english(number):
+        warnings.warn(
+            message="NepaliNumber.add_comma_english has been moved to `add_comma_english. This function is depreciated and will be removed in the future release.",
+            category=DeprecationWarning,
+        )
+        return add_comma_english(number)
diff --git a/nepali/number/utils.py b/nepali/number/utils.py
new file mode 100644
index 0000000..331ae6f
--- /dev/null
+++ b/nepali/number/utils.py
@@ -0,0 +1,73 @@
+from typing import Any
+
+
+NP_NUMBERS = ["०", "१", "२", "३", "४", "५", "६", "७", "८", "९"]
+NP_NUMBERS_SET = set(NP_NUMBERS)
+
+
+def english_to_nepali(number: Any) -> str:
+    """
+    Converts english number to nepali.
+    """
+    number = str(number)
+    converted_number = []
+    for n in number:
+        num = ord(n) - ord("0")
+        if num in range(0, 10):
+            converted_number.append(NP_NUMBERS[num])
+        else:
+            converted_number.append(n)
+    return "".join(converted_number)
+
+
+def nepali_to_english(number: Any) -> str:
+    """
+    Converts nepali number to english.
+    """
+    number = str(number)
+    converted_number = []
+    for n in number:
+        if n in NP_NUMBERS_SET:
+            converted_number.append(str(NP_NUMBERS.index(n)))
+        else:
+            converted_number.append(n)
+    return "".join(converted_number)
+
+
+def add_comma_english(number: Any) -> str:
+    """
+    Adds comma in english style
+    Eg. 123456789 => 123,456,789
+    """
+    return "{:,}".format(int(number))
+
+
+def add_comma(number: Any, convert=False) -> str:
+    """
+    Adds comma in nepali style
+    Eg. 123456789 => 12,34,56,789
+
+    :param number Any: Number to be converted
+    :param convert bool: If true converts english number to nepali
+    """
+    if convert:
+        number = english_to_nepali(number)
+    else:
+        number = str(number)
+
+    number_with_comma = []
+    counter = 0
+    for nepali_number_char in list(str(number))[::-1]:
+        if counter == 3 or (counter != 1 and (counter - 1) % 2 == 0):
+            number_with_comma.append(",")
+        number_with_comma.append(nepali_number_char)
+        counter += 1
+
+    return "".join(number_with_comma[::-1])
+
+
+def convert_and_add_comma(number: Any) -> str:
+    """
+    Converts the number into nepali text and adds comma to it.
+    """
+    return add_comma(number, convert=True)


Test patch:
diff --git a/nepali/tests/test_number.py b/nepali/tests/test_number.py
index dd00655..efde595 100644
--- a/nepali/tests/test_number.py
+++ b/nepali/tests/test_number.py
@@ -3,17 +3,18 @@
 
     python -m unittest nepali/tests/test_number.py -v
 """
+import sys
 import unittest
 
 from nepali import number
-
-NepaliNumber = number.NepaliNumber
+from nepali.number import nepalinumber, NepaliNumber
 
 
 class TestNumber(unittest.TestCase):
     def test_number_english_to_nepali(self):
         self.assertEqual(
-            number.english_to_nepali("0123456789०१२३४५६७८९"), "०१२३४५६७८९०१२३४५६७८९"
+            number.english_to_nepali("0123456789०१२३४५६७८९hello"),
+            "०१२३४५६७८९०१२३४५६७८९hello",
         )
         self.assertEqual(
             NepaliNumber.convert("0123456789०१२३४५६७८९"), "०१२३४५६७८९०१२३४५६७८९"
@@ -21,7 +22,8 @@ def test_number_english_to_nepali(self):
 
     def test_number_nepali_to_english(self):
         self.assertEqual(
-            number.nepali_to_english("0123456789०१२३४५६७८९"), "01234567890123456789"
+            number.nepali_to_english("0123456789०१२३४५६७८९hello"),
+            "01234567890123456789hello",
         )
         self.assertEqual(
             NepaliNumber.revert("0123456789०१२३४५६७८९"), "01234567890123456789"
@@ -46,3 +48,3077 @@ def test_number_convert_and_add_comma(self):
         self.assertEqual(
             NepaliNumber.convert_and_add_comma("123456789"), "१२,३४,५६,७८९"
         )
+
+
+# to run this test suite exclusively
+# python -m unittest nepali.tests.test_number.TestNepaliNumber -v
+class TestNepaliNumberArithmeticOperations(unittest.TestCase):
+    """
+    Contains test cases related to nepalinumber
+    arithmetic operations
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        Test fixtures
+        """
+        # positive integers
+        cls.nepalinumber_integer_20 = number.nepalinumber(20)
+        cls.nepalinumber_integer_15 = number.nepalinumber(15)
+        cls.nepalinumber_integer_11 = number.nepalinumber(11)
+        cls.nepalinumber_integer_10 = number.nepalinumber(10)
+        cls.nepalinumber_integer_5 = number.nepalinumber(5)
+        cls.nepalinumber_integer_4 = number.nepalinumber(4)
+        cls.nepalinumber_integer_3 = number.nepalinumber(3)
+        cls.nepalinumber_integer_2 = number.nepalinumber(2)
+        cls.nepalinumber_integer_1 = number.nepalinumber(1)
+        # positive floats
+        cls.nepalinumber_float_21_21 = number.nepalinumber(21.21)
+        cls.nepalinumber_float_20_2 = number.nepalinumber(20.2)
+        cls.nepalinumber_float_20_1 = number.nepalinumber(20.1)
+        cls.nepalinumber_float_15_6 = number.nepalinumber(15.6)
+        cls.nepalinumber_float_15_5 = number.nepalinumber(15.5)
+        cls.nepalinumber_float_10_9 = number.nepalinumber(10.9)
+        cls.nepalinumber_float_10_0_cont = number.nepalinumber(
+            20.1 - 10.1
+        )  # 10.000...2
+        cls.nepalinumber_float_10_1 = number.nepalinumber(10.1)
+        cls.nepalinumber_float_9_9 = number.nepalinumber(9.9)
+        cls.nepalinumber_float_5_5 = number.nepalinumber(5.5)
+        cls.nepalinumber_float_5_25 = number.nepalinumber(5.25)
+        cls.nepalinumber_float_4_6 = number.nepalinumber(4.6)
+        cls.nepalinumber_float_4_5 = number.nepalinumber(4.5)
+        cls.nepalinumber_float_3_5 = number.nepalinumber(3.5)
+        cls.nepalinumber_float_2_5 = number.nepalinumber(2.5)
+        cls.nepalinumber_float_2_25 = number.nepalinumber(2.25)
+        cls.nepalinumber_float_1_5 = number.nepalinumber(1.5)
+        cls.nepalinumber_float_1_25 = number.nepalinumber(1.25)
+        cls.nepalinumber_float_0_5 = number.nepalinumber(0.5)
+        cls.nepalinumber_float_0_1 = number.nepalinumber(0.1)
+        cls.nepalinumber_float_0_0_9 = number.nepalinumber(
+            10.1 - 10
+        )  # to lazy to type 0.099...
+        # negative numbers
+        cls.nepalinumber_negative_integer_20 = number.nepalinumber(-20)
+        cls.nepalinumber_negative_integer_15 = number.nepalinumber(-15)
+        cls.nepalinumber_negative_integer_11 = number.nepalinumber(-11)
+        cls.nepalinumber_negative_integer_10 = number.nepalinumber(-10)
+        cls.nepalinumber_negative_integer_5 = number.nepalinumber(-5)
+        cls.nepalinumber_negative_integer_4 = number.nepalinumber(-4)
+        cls.nepalinumber_negative_integer_3 = number.nepalinumber(-3)
+        cls.nepalinumber_negative_integer_2 = number.nepalinumber(-2)
+        cls.nepalinumber_negative_integer_1 = number.nepalinumber(-1)
+        # negative floats
+        cls.nepalinumber_negative_float_21_21 = number.nepalinumber(-21.21)
+        cls.nepalinumber_negative_float_20_2 = number.nepalinumber(-20.2)
+        cls.nepalinumber_negative_float_20_1 = number.nepalinumber(-20.1)
+        cls.nepalinumber_negative_float_20_0 = number.nepalinumber(-20.0)
+        cls.nepalinumber_negative_float_15_6 = number.nepalinumber(-15.6)
+        cls.nepalinumber_negative_float_15_5 = number.nepalinumber(-15.5)
+        cls.nepalinumber_negative_float_10_1 = number.nepalinumber(-10.1)
+        cls.nepalinumber_negative_float_9_9 = number.nepalinumber(-9.9)
+        cls.nepalinumber_negative_float_5_5 = number.nepalinumber(-5.5)
+        cls.nepalinumber_negative_float_5_4 = number.nepalinumber(-5.4)
+        cls.nepalinumber_negative_float_4_5 = number.nepalinumber(-4.5)
+        cls.nepalinumber_negative_float_2_5 = number.nepalinumber(-2.5)
+        cls.nepalinumber_negative_float_2_25 = number.nepalinumber(-2.25)
+        cls.nepalinumber_negative_float_1_5 = number.nepalinumber(-1.5)
+        cls.nepalinumber_negative_float_1_25 = number.nepalinumber(-1.25)
+        cls.nepalinumber_negative_float_0_5 = number.nepalinumber(-0.5)
+        cls.nepalinumber_negative_float_0_0_9 = number.nepalinumber(
+            10 - 10.1
+        )  # to lazy to type -0.099...
+        # zero
+        cls.nepalinumber_zero = number.nepalinumber(0)
+        # objects
+        cls.random_object = object
+        # string
+        cls.random_string = "test"
+
+    # addition
+    # nepalinumber positive integer addition tests
+    def test_nepalinumber_integer_is_addable_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + 10, self.nepalinumber_integer_20
+        )
+
+    def test_nepalinumber_integer_is_addable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + 10.1, self.nepalinumber_float_20_1
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_integer(self):
+        self.assertEqual(self.nepalinumber_integer_10 + (-10), self.nepalinumber_zero)
+
+    def test_nepalinumber_integer_is_addable_to_negative_integer_to_give_negative_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + (-20), self.nepalinumber_negative_integer_10
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + (-5.5), self.nepalinumber_float_4_5
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_float_to_give_negative_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + (-15.5), self.nepalinumber_negative_float_5_5
+        )
+
+    def test_nepalinumber_integer_is_addable_to_postive_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + self.nepalinumber_integer_10,
+            self.nepalinumber_integer_20,
+        )
+
+    def test_nepalinumber_integer_is_addable_to_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + self.nepalinumber_float_10_1,
+            self.nepalinumber_float_20_1,
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + self.nepalinumber_negative_integer_10,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_nepali_number_integer_to_give_negative_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + self.nepalinumber_negative_integer_20,
+            self.nepalinumber_negative_integer_10,
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_float_4_5,
+        )
+
+    def test_nepalinumber_integer_is_addable_to_negative_nepali_number_float_to_give_negative_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 + self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_float_5_5,
+        )
+
+    # adding the nepali number to other numbers tests
+    def test_positive_integer_is_addable_to_nepalinumber_integer(self):
+        self.assertEqual(
+            10 + self.nepalinumber_integer_10, self.nepalinumber_integer_20
+        )
+
+    def test_positive_float_is_addable_to_nepalinumber_integer(self):
+        self.assertEqual(
+            10.1 + self.nepalinumber_integer_10, self.nepalinumber_float_20_1
+        )
+
+    def test_negative_integer_is_addable_to_nepalinumber_integer(self):
+        self.assertEqual(-10 + self.nepalinumber_integer_10, self.nepalinumber_zero)
+
+    def test_negative_integer_is_addable_to_nepalinumber_integer_to_give_negative_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            (-20) + self.nepalinumber_integer_10, self.nepalinumber_negative_integer_10
+        )
+
+    def test_negative_float_is_addable_to_nepalinumber_integer(self):
+        self.assertEqual(
+            (-5.5) + self.nepalinumber_integer_10, self.nepalinumber_float_4_5
+        )
+
+    def test_negative_float_is_addable_to_nepalinumber_integer_to_give_negative_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            (-15.5) + self.nepalinumber_integer_10, self.nepalinumber_negative_float_5_5
+        )
+
+    # nepalinumber negative integer addition tests
+    def test_negative_nepalinumber_integer_is_addable_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + 10, self.nepalinumber_zero
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + 10.1, self.nepalinumber_float_0_0_9
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_positive_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + 20, self.nepalinumber_integer_10
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + (-10),
+            self.nepalinumber_negative_float_20_0,
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + (-5.5),
+            self.nepalinumber_negative_float_15_5,
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_positive_float_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + 15.5, self.nepalinumber_float_5_5
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + self.nepalinumber_integer_10,
+            self.nepalinumber_zero,
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + self.nepalinumber_float_10_1,
+            self.nepalinumber_float_0_0_9,
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            + self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_integer_20,
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_positive_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 + self.nepalinumber_integer_20,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_integer_is_addable_to_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            + self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_negative_float_15_5,
+        )
+
+    def test_nepalinumber_integer_is_addable_to_positive_nepali_number_float_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + self.nepalinumber_float_20_1,
+            self.nepalinumber_float_10_0_cont,
+        )
+
+    # nepalinumber positive float addition tests
+    def test_nepalinumber_float_is_addable_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + 10, self.nepalinumber_float_20_1
+        )
+
+    def test_nepalinumber_float_is_addable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + 10.1, self.nepalinumber_float_20_2
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + (-10), self.nepalinumber_float_0_0_9
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_integer_to_give_negative_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_9 + (-21), self.nepalinumber_negative_float_10_1
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + (-5.6), self.nepalinumber_float_4_5
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_float_to_give_negative_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + (-15.6), self.nepalinumber_negative_float_5_5
+        )
+
+    def test_nepalinumber_float_is_addable_to_postive_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + self.nepalinumber_integer_10,
+            self.nepalinumber_float_20_1,
+        )
+
+    def test_nepalinumber_float_is_addable_to_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + self.nepalinumber_float_10_1,
+            self.nepalinumber_float_20_2,
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + self.nepalinumber_negative_integer_10,
+            self.nepalinumber_float_0_0_9,
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_nepali_number_integer_to_give_negative_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + self.nepalinumber_negative_integer_20,
+            self.nepalinumber_negative_float_9_9,
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_float_4_6,
+        )
+
+    def test_nepalinumber_float_is_addable_to_negative_nepali_number_float_to_give_negative_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 + self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_float_5_4,
+        )
+
+    # nepalinumber negative float addition tests
+    def test_negative_nepalinumber_float_is_addable_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + 10,
+            self.nepalinumber_negative_float_0_0_9,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + 10.1, self.nepalinumber_zero
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_positive_integer_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + 20, self.nepalinumber_float_9_9
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + (-10),
+            self.nepalinumber_negative_float_20_1,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + (-5.4),
+            self.nepalinumber_negative_float_15_5,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_positive_float_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + 15.6, self.nepalinumber_float_5_5
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + self.nepalinumber_integer_10,
+            self.nepalinumber_negative_float_0_0_9,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + self.nepalinumber_float_10_1,
+            self.nepalinumber_zero,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            + self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_float_20_1,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_positive_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + self.nepalinumber_integer_20,
+            self.nepalinumber_float_9_9,
+        )
+
+    def test_negative_nepalinumber_float_is_addable_to_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            + self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_negative_float_15_6,
+        )
+
+    def test_nepalinumber_float_is_addable_to_positive_nepali_number_float_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 + self.nepalinumber_float_20_1,
+            self.nepalinumber_float_10_0_cont,
+        )
+
+    # addition negative testing
+    def test_nepalinumber_throws_error_when_objects_are_added_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_integer_10 + self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for +: 'nepalinumber' and 'type'",
+        )
+
+    def test_nepalinumber_throws_error_when_added_with_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object + self.nepalinumber_integer_10
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for +: 'type' and 'nepalinumber'",
+        )
+
+    # subtraction
+    # nepalinumber positive integer subtraction tests
+    def test_nepalinumber_integer_is_subtractable_by_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_10 - 10, self.nepalinumber_zero)
+
+    def test_nepalinumber_integer_is_subtractable_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - 5.5, self.nepalinumber_float_4_5
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - (-10), self.nepalinumber_integer_20
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - (-5.5), self.nepalinumber_float_15_5
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - self.nepalinumber_integer_10,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - self.nepalinumber_float_5_5,
+            self.nepalinumber_float_4_5,
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - self.nepalinumber_negative_integer_10,
+            self.nepalinumber_integer_20,
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 - self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_float_15_5,
+        )
+
+    # subtracting the nepali number to other numbers tests
+    def test_positive_integer_is_subtractable_by_nepalinumber_integer(self):
+        self.assertEqual(10 - self.nepalinumber_integer_10, self.nepalinumber_zero)
+
+    def test_positive_float_is_subtractable_by_nepalinumber_integer(self):
+        self.assertEqual(
+            10.1 - self.nepalinumber_integer_10, self.nepalinumber_float_0_0_9
+        )
+
+    def test_negative_integer_is_subtractable_by_nepalinumber_integer(self):
+        self.assertEqual(
+            (-10) - self.nepalinumber_integer_10, self.nepalinumber_negative_integer_20
+        )
+
+    def test_negative_float_is_subtractable_by_nepalinumber_integer(self):
+        self.assertEqual(
+            (-5.5) - self.nepalinumber_integer_10, self.nepalinumber_negative_float_15_5
+        )
+
+    def test_negative_float_is_subtractable_by_nepalinumber_integer_to_give_negative_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            (-5.5) - self.nepalinumber_integer_10, self.nepalinumber_negative_float_15_5
+        )
+
+    # nepalinumber negative integer subtraction tests
+    def test_negative_nepalinumber_integer_is_subtractable_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - 10,
+            self.nepalinumber_negative_integer_20,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - 10.1,
+            self.nepalinumber_negative_float_20_1,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_negative_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - (-20), self.nepalinumber_integer_10
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - (-5.5),
+            self.nepalinumber_negative_float_4_5,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_negative_float_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - (-15.5), self.nepalinumber_float_5_5
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - self.nepalinumber_integer_10,
+            self.nepalinumber_negative_float_20_0,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 - self.nepalinumber_float_10_1,
+            self.nepalinumber_negative_float_20_1,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            - self.nepalinumber_negative_integer_10,
+            self.nepalinumber_zero,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_negative_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            - self.nepalinumber_negative_integer_20,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_integer_is_subtractable_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            - self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_negative_float_4_5,
+        )
+
+    def test_nepalinumber_integer_is_subtractable_by_negative_nepali_number_float_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            - self.nepalinumber_negative_float_20_1,
+            self.nepalinumber_float_10_0_cont,
+        )
+
+    # nepalinumber positive float subtraction tests
+    def test_nepalinumber_float_is_subtractable_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - 10, self.nepalinumber_float_0_0_9
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_positive_float(self):
+        self.assertEqual(self.nepalinumber_float_10_1 - 10.1, self.nepalinumber_zero)
+
+    def test_nepalinumber_float_is_subtractable_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - (-10), self.nepalinumber_float_20_1
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - (-5.4), self.nepalinumber_float_15_5
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_postive_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - self.nepalinumber_integer_10,
+            self.nepalinumber_float_0_0_9,
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - self.nepalinumber_float_10_1,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_negative_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - self.nepalinumber_negative_integer_10,
+            self.nepalinumber_float_20_1,
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_positive_nepali_number_integer_to_give_negative_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - self.nepalinumber_integer_20,
+            self.nepalinumber_negative_float_9_9,
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 - self.nepalinumber_negative_float_5_5,
+            self.nepalinumber_float_15_6,
+        )
+
+    # nepalinumber negative float subtraction tests
+    def test_negative_nepalinumber_float_is_subtractable_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - 10,
+            self.nepalinumber_negative_float_20_1,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - 5.4,
+            self.nepalinumber_negative_float_15_5,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_integer_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - (-20), self.nepalinumber_float_9_9
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - (-10),
+            self.nepalinumber_negative_float_0_0_9,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - (-5.6),
+            self.nepalinumber_negative_float_4_5,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_float_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - (-15.6), self.nepalinumber_float_5_5
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - self.nepalinumber_integer_10,
+            self.nepalinumber_negative_float_20_1,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 - self.nepalinumber_float_5_5,
+            self.nepalinumber_negative_float_15_6,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            - self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_float_0_0_9,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            - self.nepalinumber_negative_integer_20,
+            self.nepalinumber_float_9_9,
+        )
+
+    def test_negative_nepalinumber_float_is_subtractable_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            - self.nepalinumber_negative_float_10_1,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_float_is_subtractable_by_negative_nepali_number_float_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            - self.nepalinumber_negative_float_20_1,
+            self.nepalinumber_float_10_0_cont,
+        )
+
+    # subtraction negative testing
+    def test_nepalinumber_throws_error_when_subtracted_by_object_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_integer_10 - self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for -: 'nepalinumber' and 'type'",
+        )
+
+    def test_nepalinumber_throws_error_when_subtracted_to_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object - self.nepalinumber_integer_10
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for -: 'type' and 'nepalinumber'",
+        )
+
+    # multiplication
+    # nepalinumber positive integer multiplication tests
+    def test_nepalinumber_integer_is_multiplicable_to_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_10 * 2, self.nepalinumber_integer_20)
+
+    def test_nepalinumber_integer_is_multiplicable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * 1.5, self.nepalinumber_integer_15
+        )
+
+    def test_nepalinumber_integer_is_multiplicable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * (-2), self.nepalinumber_negative_integer_20
+        )
+
+    def test_nepalinumber_integer_is_multiplicable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * (-1.5), self.nepalinumber_negative_integer_15
+        )
+
+    def test_nepalinumber_integer_is_multiplicable_to_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * self.nepalinumber_integer_2,
+            self.nepalinumber_integer_20,
+        )
+
+    def test_nepalinumber_integer_is_multiplicable_to_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * self.nepalinumber_float_1_5,
+            self.nepalinumber_integer_15,
+        )
+
+    def test_nepalinumber_integer_is_multiplicable_to_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * self.nepalinumber_negative_integer_2,
+            self.nepalinumber_negative_integer_20,
+        )
+
+    def test_nepalinumber_integer_is_multiplicable_to_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 * self.nepalinumber_negative_float_1_5,
+            self.nepalinumber_negative_integer_15,
+        )
+
+    # multiplying the nepali number to other numbers tests
+    def test_positive_integer_is_multiplicable_to_nepalinumber_integer(self):
+        self.assertEqual(2 * self.nepalinumber_integer_10, self.nepalinumber_integer_20)
+
+    def test_positive_float_is_multiplicable_to_nepalinumber_integer(self):
+        self.assertEqual(
+            1.5 * self.nepalinumber_integer_10, self.nepalinumber_integer_15
+        )
+
+    def test_negative_integer_is_multiplicable_to_nepalinumber_integer(self):
+        self.assertEqual(
+            -2 * self.nepalinumber_integer_10, self.nepalinumber_negative_integer_20
+        )
+
+    def test_negative_integer_is_multiplicable_to_nepalinumber_integer_to_give_negative_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            -2 * self.nepalinumber_integer_10, self.nepalinumber_negative_integer_20
+        )
+
+    def test_negative_float_is_multiplicable_to_nepalinumber_integer(self):
+        self.assertEqual(
+            (-1.5) * self.nepalinumber_integer_10, self.nepalinumber_negative_integer_15
+        )
+
+    # nepalinumber negative integer multiplication tests
+    def test_negative_nepalinumber_integer_is_multiplicable_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 * 2,
+            self.nepalinumber_negative_integer_20,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 * 1.5,
+            self.nepalinumber_negative_integer_15,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 * (-2),
+            self.nepalinumber_integer_20,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 * (-1.5),
+            self.nepalinumber_integer_15,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 * self.nepalinumber_integer_2,
+            self.nepalinumber_negative_integer_20,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 * self.nepalinumber_float_1_5,
+            self.nepalinumber_negative_integer_15,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            * self.nepalinumber_negative_integer_2,
+            self.nepalinumber_integer_20,
+        )
+
+    def test_negative_nepalinumber_integer_is_multiplicable_to_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            * self.nepalinumber_negative_float_1_5,
+            self.nepalinumber_integer_15,
+        )
+
+    # nepalinumber positive float multiplication tests
+    def test_nepalinumber_float_is_multiplicable_to_positive_integer(self):
+        self.assertEqual(self.nepalinumber_float_1_5 * 10, self.nepalinumber_integer_15)
+
+    def test_nepalinumber_float_is_multiplicable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 * 2.1, self.nepalinumber_float_21_21
+        )
+
+    def test_nepalinumber_float_is_multiplicable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_1_5 * (-3), self.nepalinumber_negative_float_4_5
+        )
+
+    def test_nepalinumber_float_is_multiplicable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 * (-2.2), self.nepalinumber_negative_float_9_9
+        )
+
+    def test_nepalinumber_float_is_multiplicable_to_postive_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 * self.nepalinumber_integer_2,
+            self.nepalinumber_float_20_2,
+        )
+
+    def test_nepalinumber_float_is_multiplicable_to_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_1_5 * self.nepalinumber_float_3_5,
+            self.nepalinumber_float_5_25,
+        )
+
+    def test_nepalinumber_float_is_multiplicable_to_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 * self.nepalinumber_negative_integer_2,
+            self.nepalinumber_negative_float_20_2,
+        )
+
+    def test_nepalinumber_float_is_multiplicable_to_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_1_5 * self.nepalinumber_negative_float_1_5,
+            self.nepalinumber_negative_float_2_25,
+        )
+
+    # nepalinumber negative float addition tests
+    def test_negative_nepalinumber_float_is_multiplicable_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 * 2,
+            self.nepalinumber_negative_float_20_2,
+        )
+
+    def test_negative_nepalinumber_float_is_multiplicable_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5 * 1.5,
+            self.nepalinumber_negative_float_2_25,
+        )
+
+    def test_negative_nepalinumber_float_is_multiplicable_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 * (-2),
+            self.nepalinumber_float_20_2,
+        )
+
+    def test_negative_nepalinumber_float_is_multiplicable_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5 * (-3.5),
+            self.nepalinumber_float_5_25,
+        )
+
+    def test_negative_nepalinumber_float_is_multiplicable_to_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1 * self.nepalinumber_integer_2,
+            self.nepalinumber_negative_float_20_2,
+        )
+
+    def test_negative_nepalinumber_float_is_multiplicable_to_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5 * self.nepalinumber_float_1_5,
+            self.nepalinumber_negative_float_2_25,
+        )
+
+    def test_negative_nepalinumber_float_is_mutliplicable_to_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_10_1
+            * self.nepalinumber_negative_integer_2,
+            self.nepalinumber_float_20_2,
+        )
+
+    def test_negative_nepalinumber_float_is_multiplicable_to_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5 * self.nepalinumber_negative_float_1_5,
+            self.nepalinumber_float_2_25,
+        )
+
+    # string tests
+    def test_nepalinumber_integer_can_be_multiplied_with_string(self):
+        self.assertEqual(
+            self.nepalinumber_integer_2 * self.random_string, 2 * self.random_string
+        )
+
+    def test_string_can_be_multiplied_by_nepalinumber_integer(self):
+        self.assertEqual(
+            self.random_string * self.nepalinumber_integer_2, self.random_string * 2
+        )
+
+    def test_nepalinumber_negative_integer_on_multiplication_with_string_gives_empty_string(
+        self,
+    ):
+        self.assertEqual(self.nepalinumber_negative_integer_2 * self.random_string, "")
+
+    def test_string_can_be_multiplied_by_negative_nepalinumber_integer_to_give_empty_string(
+        self,
+    ):
+        self.assertEqual(self.random_string * self.nepalinumber_negative_integer_2, "")
+
+    def test_nepalinumber_float_throws_error_when_multiplied_with_string(self):
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_float_0_1 * self.random_string
+
+        self.assertEqual(
+            str(te.exception),
+            "can't multiply sequence by non-int of type 'nepalinumber'",
+        )
+
+    def test_nepalinumber_float_throws_error_when_multiplied_to_string(self):
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_string * self.nepalinumber_float_0_0_9
+
+        self.assertEqual(
+            str(te.exception),
+            "can't multiply sequence by non-int of type 'nepalinumber'",
+        )
+
+    # multiplication negative testing
+    def test_nepalinumber_throws_error_when_objects_are_multiplied_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_integer_10 * self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for *: 'nepalinumber' and 'type'",
+        )
+
+    def test_nepalinumber_throws_error_when_multiplied_with_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object + self.nepalinumber_integer_10
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for +: 'type' and 'nepalinumber'",
+        )
+
+    # division
+    # nepalinumber positive integer division tests
+    def test_nepalinumber_integer_is_divisible_by_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_20 / 2, self.nepalinumber_integer_10)
+
+    def test_nepalinumber_integer_is_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 / 2.5, self.nepalinumber_integer_4
+        )
+
+    def test_nepalinumber_integer_is_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_20 / (-2), self.nepalinumber_negative_integer_10
+        )
+
+    def test_nepalinumber_integer_is_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 / (-2.5), self.nepalinumber_negative_integer_4
+        )
+
+    def test_nepalinumber_integer_is_divisible_by_postive_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_20 / self.nepalinumber_integer_10,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_nepalinumber_integer_is_divisible_by_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 / self.nepalinumber_float_2_5,
+            self.nepalinumber_integer_4,
+        )
+
+    def test_nepalinumber_integer_is_divisible_by_negative_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_20 / self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_nepalinumber_integer_is_divisible_by_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 / self.nepalinumber_negative_float_2_5,
+            self.nepalinumber_negative_integer_4,
+        )
+
+    # dividing other numbers by nepali number tests
+    def test_positive_integer_is_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(20 / self.nepalinumber_integer_2, self.nepalinumber_integer_10)
+
+    def test_positive_float_is_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            20.2 / self.nepalinumber_integer_2, self.nepalinumber_float_10_1
+        )
+
+    def test_negative_integer_is_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            -20 / self.nepalinumber_integer_10, self.nepalinumber_negative_integer_2
+        )
+
+    def test_negative_integer_is_divisible_by_negative_nepalinumber_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            (-20) / self.nepalinumber_negative_integer_10, self.nepalinumber_integer_2
+        )
+
+    def test_negative_float_is_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            (-20.2) / self.nepalinumber_integer_2, self.nepalinumber_negative_float_10_1
+        )
+
+    def test_negative_float_is_divisible_by_negative_nepalinumber_integer_to_give_positive_nepali_float(
+        self,
+    ):
+        self.assertEqual(
+            (-20.2) / self.nepalinumber_negative_integer_2, self.nepalinumber_float_10_1
+        )
+
+    # nepalinumber negative integer division tests
+    def test_negative_nepalinumber_integer_is_divisible_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / 5,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / 2.5,
+            self.nepalinumber_negative_integer_4,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / -5, self.nepalinumber_integer_2
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / (-5),
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / (-2.5),
+            self.nepalinumber_integer_4,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_float_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / -2.5, self.nepalinumber_integer_4
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_20 / self.nepalinumber_integer_10,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 / self.nepalinumber_float_2_5,
+            self.nepalinumber_negative_integer_4,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_20
+            / self.nepalinumber_negative_integer_10,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_20
+            / self.nepalinumber_negative_integer_2,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_integer_is_divisible_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            / self.nepalinumber_negative_float_2_5,
+            self.nepalinumber_integer_4,
+        )
+
+    # nepalinumber positive float division tests
+    def test_nepalinumber_float_is_divisible_by_positive_integer(self):
+        self.assertEqual(self.nepalinumber_float_20_2 / 2, self.nepalinumber_float_10_1)
+
+    def test_nepalinumber_float_is_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / 10.1, self.nepalinumber_integer_2
+        )
+
+    def test_nepalinumber_float_is_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / (-2), self.nepalinumber_negative_float_10_1
+        )
+
+    def test_nepalinumber_float_is_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / (-10.1), self.nepalinumber_negative_integer_2
+        )
+
+    def test_nepalinumber_float_is_divisible_by_postive_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / self.nepalinumber_integer_2,
+            self.nepalinumber_float_10_1,
+        )
+
+    def test_nepalinumber_float_is_divisible_by_positive_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / self.nepalinumber_float_10_1,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_nepalinumber_float_is_divisible_by_negative_nepali_number_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / self.nepalinumber_negative_integer_2,
+            self.nepalinumber_negative_float_10_1,
+        )
+
+    def test_nepalinumber_float_is_divisible_by_negative_nepali_number_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 / self.nepalinumber_negative_float_10_1,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    # nepalinumber negative float division tests
+    def test_negative_nepalinumber_float_is_divisible_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 / 2,
+            self.nepalinumber_negative_float_10_1,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 / 10.1,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 / (-2),
+            self.nepalinumber_float_10_1,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 / (-10.1),
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 / self.nepalinumber_integer_2,
+            self.nepalinumber_negative_float_10_1,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 / self.nepalinumber_float_10_1,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_negative_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2
+            / self.nepalinumber_negative_integer_2,
+            self.nepalinumber_float_10_1,
+        )
+
+    def test_negative_nepalinumber_float_is_divisible_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2
+            / self.nepalinumber_negative_float_10_1,
+            self.nepalinumber_integer_2,
+        )
+
+    # division negative testing
+    def test_nepalinumber_throws_error_when_divided_by_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_integer_10 / self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for /: 'nepalinumber' and 'type'",
+        )
+
+    def test_nepalinumber_throws_error_when_divided_to_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object / self.nepalinumber_integer_10
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for /: 'type' and 'nepalinumber'",
+        )
+
+    def test_nepalinumber_throws_error_when_divided_by_zero(self):
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = self.nepalinumber_integer_2 / 0
+
+        self.assertEqual(str(ze.exception), "division by zero")
+
+    def test_nepalinumber_throws_error_when_zero_nepalinumber_divides_other_numbers(
+        self,
+    ):
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = 12 / self.nepalinumber_zero
+
+        self.assertEqual(str(ze.exception), "division by zero")
+
+    def test_nepalinumber_throws_error_when_divided_by_zero_nepalinumber(self):
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = self.nepalinumber_integer_2 / self.nepalinumber_zero
+
+        self.assertEqual(str(ze.exception), "division by zero")
+
+    # floor divison
+    # nepalinumber positive integer division tests
+    def test_nepalinumber_integer_is_floor_divisible_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_20 // 2, self.nepalinumber_integer_10
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 // 2.5, self.nepalinumber_integer_4
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_20 // (-2), self.nepalinumber_negative_integer_10
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 // (-2.5), self.nepalinumber_negative_integer_4
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_20 // self.nepalinumber_integer_10,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 / self.nepalinumber_float_2_5,
+            self.nepalinumber_integer_4,
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_20 // self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_nepalinumber_integer_is_floor_divisible_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 // self.nepalinumber_negative_float_2_5,
+            self.nepalinumber_negative_integer_4,
+        )
+
+    # dividing other numbers by nepali number tests
+    def test_positive_integer_is_floor_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            20 // self.nepalinumber_integer_2, self.nepalinumber_integer_10
+        )
+
+    def test_positive_float_is_floor_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            20.2 // self.nepalinumber_integer_2, self.nepalinumber_integer_10
+        )
+
+    def test_negative_integer_is_floor_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            -20 // self.nepalinumber_integer_10, self.nepalinumber_negative_integer_2
+        )
+
+    def test_negative_integer_is_floor_divisible_by_negative_nepalinumber_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            (-20) // self.nepalinumber_negative_integer_10, self.nepalinumber_integer_2
+        )
+
+    def test_negative_float_is_floor_divisible_by_nepalinumber_integer(self):
+        self.assertEqual(
+            (-19.2) // self.nepalinumber_integer_2,
+            self.nepalinumber_negative_integer_10,
+        )
+
+    def test_negative_float_is_floor_divisible_by_negative_nepalinumber_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            (-20.2) // self.nepalinumber_negative_integer_2,
+            self.nepalinumber_integer_10,
+        )
+
+    # nepalinumber negative integer division tests
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // 5,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // 2.5,
+            self.nepalinumber_negative_integer_4,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_integer_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // -5, self.nepalinumber_integer_2
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // (-5),
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // (-2.5),
+            self.nepalinumber_integer_4,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_float_to_give_positive_nepali_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // -2.5, self.nepalinumber_integer_4
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_20 // self.nepalinumber_integer_10,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 // self.nepalinumber_float_2_5,
+            self.nepalinumber_negative_integer_4,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_20
+            // self.nepalinumber_negative_integer_10,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_20
+            // self.nepalinumber_negative_integer_2,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_integer_is_floor_divisible_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            // self.nepalinumber_negative_float_2_5,
+            self.nepalinumber_integer_4,
+        )
+
+    # nepalinumber positive float division tests
+    def test_nepalinumber_float_is_floor_divisible_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // 2, self.nepalinumber_integer_10
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // 10.1, self.nepalinumber_integer_2
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // (-2), self.nepalinumber_negative_integer_11
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // (-10.1),
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // self.nepalinumber_integer_2,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // self.nepalinumber_float_10_1,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_negative_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // self.nepalinumber_negative_integer_2,
+            self.nepalinumber_negative_integer_11,
+        )
+
+    def test_nepalinumber_float_is_floor_divisible_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_20_2 // self.nepalinumber_negative_float_10_1,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    # nepalinumber negative float division tests
+    def test_negative_nepalinumber_float_is_floor_divisible_by_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 // 2,
+            self.nepalinumber_negative_integer_11,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 // 10.1,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 // (-2),
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 // (-10.1),
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_postive_nepali_number_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 // self.nepalinumber_integer_2,
+            self.nepalinumber_negative_integer_11,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_positive_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2 // self.nepalinumber_float_10_1,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_negative_nepali_number_integer_to_give_positive_nepali_number(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2
+            // self.nepalinumber_negative_integer_2,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_float_is_floor_divisible_by_negative_nepali_number_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_20_2
+            // self.nepalinumber_negative_float_10_1,
+            self.nepalinumber_integer_2,
+        )
+
+    # division negative testing
+    def test_nepalinumber_throws_error_when_floor_divided_by_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_integer_10 // self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for //: 'nepalinumber' and 'type'",
+        )
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_float_10_1 // self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for //: 'nepalinumber' and 'type'",
+        )
+
+    def test_nepalinumber_throws_error_when_floor_divided_to_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object // self.nepalinumber_integer_10
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for //: 'type' and 'nepalinumber'",
+        )
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object // self.nepalinumber_float_10_1
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for //: 'type' and 'nepalinumber'",
+        )
+
+    def test_nepalinumber_throws_error_when_floor_floor_divided_by_zero(self):
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = self.nepalinumber_integer_2 // 0
+
+        self.assertEqual(str(ze.exception), "integer division or modulo by zero")
+
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = self.nepalinumber_float_10_1 // 0
+
+        python_version = sys.version_info
+
+        if python_version.major >= 3:
+            if python_version.minor <= 8:
+                self.assertEqual(str(ze.exception), "float divmod()")
+            else:
+                self.assertEqual(str(ze.exception), "float floor division by zero")
+
+    def test_nepalinumber_throws_error_when_zero_nepalinumber_floor_divides_other_numbers(
+        self,
+    ):
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = 12 // self.nepalinumber_zero
+
+        self.assertEqual(str(ze.exception), "integer division or modulo by zero")
+
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = 12.1 // self.nepalinumber_zero
+
+        python_version = sys.version_info
+
+        if python_version.major >= 3:
+            if python_version.minor <= 8:
+                self.assertEqual(str(ze.exception), "float divmod()")
+            else:
+                self.assertEqual(str(ze.exception), "float floor division by zero")
+
+    def test_nepalinumber_throws_error_when_floor_divided_by_zero_nepalinumber(self):
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = self.nepalinumber_integer_2 // self.nepalinumber_zero
+
+        self.assertEqual(str(ze.exception), "integer division or modulo by zero")
+
+        with self.assertRaises(ZeroDivisionError) as ze:
+            _ = self.nepalinumber_float_10_1 // self.nepalinumber_zero
+
+        python_version = sys.version_info
+
+        if python_version.major >= 3:
+            if python_version.minor <= 8:
+                self.assertEqual(str(ze.exception), "float divmod()")
+            else:
+                self.assertEqual(str(ze.exception), "float floor division by zero")
+
+    # mod
+    # nepalinumber positive integer modulo tests
+    def test_nepalinumber_integer_can_be_modulo_divided_by_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_10 % 4, self.nepalinumber_integer_2)
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_positive_float(self):
+        self.assertEqual(self.nepalinumber_integer_10 % 2.5, self.nepalinumber_zero)
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 % -4, self.nepalinumber_negative_integer_2
+        )
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_10 % -2.25, self.nepalinumber_negative_float_1_25
+        )
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 % self.nepalinumber_integer_2,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 % self.nepalinumber_float_2_5,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 % self.nepalinumber_negative_integer_20,
+            self.nepalinumber_negative_integer_10,
+        )
+
+    def test_nepalinumber_integer_can_be_modulo_divided_by_negative_nepainumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_10 % self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_float_5_5,
+        )
+
+    # nepalinumber other numbers modulo divided by positive nepalinumber tests
+    def test_positive_integer_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(4 % self.nepalinumber_integer_10, self.nepalinumber_integer_4)
+
+    def test_positive_float_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            15.5 % self.nepalinumber_integer_10, self.nepalinumber_float_5_5
+        )
+
+    def test_negative_integer_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(-5 % self.nepalinumber_integer_10, self.nepalinumber_integer_5)
+
+    def test_negative_float_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            -20.5 % self.nepalinumber_integer_2, self.nepalinumber_float_1_5
+        )
+
+    def test_positive_nepalinumber_float_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 % self.nepalinumber_integer_5,
+            self.nepalinumber_float_0_0_9,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 % self.nepalinumber_integer_20,
+            self.nepalinumber_integer_10,
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_positive_nepainumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_15_5 % self.nepalinumber_integer_10,
+            self.nepalinumber_float_4_5,
+        )
+
+    # nepalinumber negative integer modulo tests
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_positive_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 % 4, self.nepalinumber_integer_2
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_positive_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 % 2.5, self.nepalinumber_zero
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_negative_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 % -4,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_negative_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 % -2.5, self.nepalinumber_zero
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10 % self.nepalinumber_float_2_5,
+            self.nepalinumber_zero,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            % self.nepalinumber_negative_integer_20,
+            self.nepalinumber_negative_integer_10,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_modulo_divided_by_negative_nepainumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_10
+            % self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_integer_10,
+        )
+
+    # nepalinumber other numbers modulo divided by negative nepalinumber tests
+    def test_positive_integer_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            5 % self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_integer_5,
+        )
+
+    def test_positive_float_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            15.5 % self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_float_4_5,
+        )
+
+    def test_negative_integer_can_be_modulo_divided_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            -5 % self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_integer_5,
+        )
+
+    def test_negative_float_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            -5.5 % self.nepalinumber_negative_integer_2,
+            self.nepalinumber_negative_float_1_5,
+        )
+
+    def test_positive_nepalinumber_float_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_float_5_5,
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_negative_nepainumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_15_5
+            % self.nepalinumber_negative_integer_10,
+            self.nepalinumber_negative_float_5_5,
+        )
+
+    # nepalinumber positive float modulo tests
+    def test_nepalinumber_float_can_be_modulo_divided_by_positive_integer(self):
+        self.assertEqual(self.nepalinumber_float_4_5 % 2, self.nepalinumber_float_0_5)
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_positive_float(self):
+        self.assertEqual(self.nepalinumber_float_4_5 % 2.5, self.nepalinumber_integer_2)
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % -2, self.nepalinumber_negative_float_1_5
+        )
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_negative_float(self):
+        self.assertEqual(self.nepalinumber_float_4_5 % -2.25, self.nepalinumber_zero)
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % self.nepalinumber_integer_2,
+            self.nepalinumber_float_0_5,
+        )
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % self.nepalinumber_float_2_25,
+            self.nepalinumber_zero,
+        )
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % self.nepalinumber_negative_integer_20,
+            self.nepalinumber_negative_float_15_5,
+        )
+
+    def test_nepalinumber_float_can_be_modulo_divided_by_negative_nepainumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_integer_11,
+        )
+
+    # nepalinumber other numbers modulo divided by positive nepalinumber float tests
+    def test_positive_nepalinumber_float_can_be_modulo_divided_by_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_10_1 % self.nepalinumber_integer_5,
+            self.nepalinumber_float_0_0_9,
+        )
+
+    # nepalinumber negative float modulo tests
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_positive_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_15_5 % 4, self.nepalinumber_float_0_5
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_15_5 % 2.5, self.nepalinumber_integer_2
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_negative_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_4_5 % -20,
+            self.nepalinumber_negative_float_4_5,
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_4_5 % -2.5,
+            self.nepalinumber_negative_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_15_5 % self.nepalinumber_float_2_5,
+            self.nepalinumber_integer_2,
+        )
+
+    def test_negative_nepalinumber_float_can_be_modulo_divided_by_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_4_5
+            % self.nepalinumber_negative_integer_20,
+            self.nepalinumber_negative_float_4_5,
+        )
+
+    # nepalinumber other integers modulo divided by negative nepalinumber float tests
+    def test_positive_integer_can_be_modulo_divided_by_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            5 % self.nepalinumber_negative_float_2_5, self.nepalinumber_zero
+        )
+
+    def test_positive_float_can_be_modulo_divided_by_negative_nepalinumber_float(self):
+        self.assertEqual(
+            15.5 % self.nepalinumber_negative_float_15_5, self.nepalinumber_zero
+        )
+
+    def test_negative_integer_can_be_modulo_divided_by_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            -5 % self.nepalinumber_negative_float_2_5, self.nepalinumber_zero
+        )
+
+    def test_negative_float_can_be_modulo_divided_by_negative_nepalinumber_float(self):
+        self.assertEqual(
+            -5.5 % self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_float_5_5,
+        )
+
+    def test_positive_nepalinumber_float_can_be_modulo_divided_by_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_4_5 % self.nepalinumber_negative_float_15_5,
+            self.nepalinumber_negative_integer_11,
+        )
+
+    # modulo negative_testing
+    def test_nepalinumber_throws_error_when_object_other_than_int_or_float_modulo_divide(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.nepalinumber_integer_10 % self.random_object
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for %: 'nepalinumber' and 'type'",
+        )
+
+    def test_nepalinumber_throws_error_when_modulo_divided_with_objects_other_than_int_or_float(
+        self,
+    ):
+        self.assertNotIsInstance(self.random_object, int)
+        self.assertNotIsInstance(self.random_object, float)
+
+        with self.assertRaises(TypeError) as te:
+            _ = self.random_object % self.nepalinumber_integer_10
+
+        self.assertEqual(
+            str(te.exception),
+            "unsupported operand type(s) for %: 'type' and 'nepalinumber'",
+        )
+
+    # divmod
+    # divmod positive nepalinumber integer as dividend tests
+    def test_positive_nepalinumber_integer_can_be_divmod_with_positive_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, 2),
+            (self.nepalinumber_integer_5, self.nepalinumber_zero),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_positive_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, 2.5),
+            (self.nepalinumber_integer_4, self.nepalinumber_zero),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_negative_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, -4),
+            (
+                self.nepalinumber_negative_integer_3,
+                self.nepalinumber_negative_integer_2,
+            ),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_negative_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, -5.5),
+            (
+                self.nepalinumber_negative_integer_2,
+                self.nepalinumber_negative_integer_1,
+            ),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, self.nepalinumber_integer_2),
+            (self.nepalinumber_integer_5, self.nepalinumber_zero),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, self.nepalinumber_float_2_5),
+            (self.nepalinumber_integer_4, self.nepalinumber_zero),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, self.nepalinumber_negative_integer_4),
+            (
+                self.nepalinumber_negative_integer_3,
+                self.nepalinumber_negative_integer_2,
+            ),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_divmod_with_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_integer_10, self.nepalinumber_negative_float_5_5),
+            (
+                self.nepalinumber_negative_integer_2,
+                self.nepalinumber_negative_integer_1,
+            ),
+        )
+
+    # divmod positive nepalinumber integer as divisior tests
+    def test_positive_integer_can_be_divmod_with_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(10, self.nepalinumber_integer_2),
+            (self.nepalinumber_integer_5, self.nepalinumber_zero),
+        )
+
+    def test_positive_float_can_be_divmod_with_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(15.5, self.nepalinumber_integer_10),
+            (self.nepalinumber_integer_1, self.nepalinumber_float_5_5),
+        )
+
+    def test_negative_integer_can_be_divmod_with_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(-10, self.nepalinumber_integer_10),
+            (self.nepalinumber_negative_integer_1, self.nepalinumber_zero),
+        )
+
+    def test_negative_float_can_be_divmod_with_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(-15.5, self.nepalinumber_integer_5),
+            (self.nepalinumber_negative_integer_4, self.nepalinumber_float_4_5),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_15_5, self.nepalinumber_integer_10),
+            (self.nepalinumber_integer_1, self.nepalinumber_float_5_5),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_integer_10, self.nepalinumber_integer_10),
+            (self.nepalinumber_negative_integer_1, self.nepalinumber_zero),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_15_5, self.nepalinumber_integer_5),
+            (self.nepalinumber_negative_integer_4, self.nepalinumber_float_4_5),
+        )
+
+    # divmod positive nepalinumber float as dividend tests
+    def test_positive_nepalinumber_float_can_be_divmod_with_positive_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, 2),
+            (self.nepalinumber_integer_2, self.nepalinumber_float_0_5),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_positive_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, 2.5),
+            (self.nepalinumber_integer_1, self.nepalinumber_integer_2),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_negative_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, -3),
+            (
+                self.nepalinumber_negative_integer_2,
+                self.nepalinumber_negative_float_1_5,
+            ),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_negative_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, -2.25),
+            (self.nepalinumber_negative_integer_2, self.nepalinumber_zero),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, self.nepalinumber_float_4_5),
+            (self.nepalinumber_integer_1, self.nepalinumber_zero),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, -2),
+            (
+                self.nepalinumber_negative_integer_3,
+                self.nepalinumber_negative_float_1_5,
+            ),
+        )
+
+    def test_positive_nepalinumber_float_can_be_divmod_with_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_float_4_5, -2.5),
+            (
+                self.nepalinumber_negative_integer_2,
+                self.nepalinumber_negative_float_0_5,
+            ),
+        )
+
+    # divmod positive nepalinumber float as divisior tests
+    def test_positive_integer_can_be_divmod_with_positive_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(10, self.nepalinumber_float_2_5),
+            (self.nepalinumber_integer_4, self.nepalinumber_zero),
+        )
+
+    def test_positive_float_can_be_divmod_with_positive_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(4.5, self.nepalinumber_float_2_25),
+            (self.nepalinumber_integer_2, self.nepalinumber_zero),
+        )
+
+    def test_negative_integer_can_be_divmod_with_positive_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(-10, self.nepalinumber_float_2_25),
+            (self.nepalinumber_negative_integer_5, self.nepalinumber_float_1_25),
+        )
+
+    def test_negative_float_can_be_divmod_with_positive_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(-15.5, self.nepalinumber_float_1_5),
+            (self.nepalinumber_negative_integer_11, self.nepalinumber_integer_1),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_integer_10, self.nepalinumber_float_2_5),
+            (self.nepalinumber_negative_integer_4, self.nepalinumber_zero),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_20_2, self.nepalinumber_float_10_1),
+            (self.nepalinumber_negative_integer_2, self.nepalinumber_zero),
+        )
+
+    # divmod negative nepalinumber integer as dividend tests
+    def test_negative_nepalinumber_integer_can_be_divmod_with_positive_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_integer_10, 2),
+            (self.nepalinumber_negative_integer_5, self.nepalinumber_zero),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_positive_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_integer_10, 2.5),
+            (self.nepalinumber_negative_integer_4, self.nepalinumber_zero),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_negative_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_integer_10, -4),
+            (self.nepalinumber_integer_2, self.nepalinumber_negative_integer_2),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_negative_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_integer_10, -5.5),
+            (self.nepalinumber_integer_1, self.nepalinumber_negative_float_4_5),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(
+                self.nepalinumber_negative_integer_10,
+                self.nepalinumber_negative_integer_4,
+            ),
+            (self.nepalinumber_integer_2, self.nepalinumber_negative_integer_2),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_divmod_with_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(
+                self.nepalinumber_negative_integer_10,
+                self.nepalinumber_negative_float_5_5,
+            ),
+            (self.nepalinumber_integer_1, self.nepalinumber_negative_float_4_5),
+        )
+
+    # divmod negative nepalinumber integer as divisior tests
+    def test_positive_integer_can_be_divmod_with_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(10, self.nepalinumber_negative_integer_2),
+            (self.nepalinumber_negative_integer_5, self.nepalinumber_zero),
+        )
+
+    def test_positive_float_can_be_divmod_with_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(15.5, self.nepalinumber_negative_integer_10),
+            (
+                self.nepalinumber_negative_integer_2,
+                self.nepalinumber_negative_float_4_5,
+            ),
+        )
+
+    def test_negative_integer_can_be_divmod_with_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(-10, self.nepalinumber_negative_integer_10),
+            (self.nepalinumber_integer_1, self.nepalinumber_zero),
+        )
+
+    def test_negative_float_can_be_divmod_with_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            divmod(-4.5, self.nepalinumber_negative_integer_5),
+            (self.nepalinumber_zero, self.nepalinumber_negative_float_4_5),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            divmod(
+                self.nepalinumber_negative_float_4_5,
+                self.nepalinumber_negative_integer_2,
+            ),
+            (self.nepalinumber_integer_2, self.nepalinumber_negative_float_0_5),
+        )
+
+    # divmod negative nepalinumber float as dividend tests
+    def test_negative_nepalinumber_float_can_be_divmod_with_positive_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_4_5, 2),
+            (self.nepalinumber_negative_integer_3, self.nepalinumber_float_1_5),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_positive_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_4_5, 2.5),
+            (self.nepalinumber_negative_integer_2, self.nepalinumber_float_0_5),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_negative_integer(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_4_5, -3),
+            (self.nepalinumber_integer_1, self.nepalinumber_negative_float_1_5),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_negative_float(self):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_4_5, -2.25),
+            (self.nepalinumber_integer_2, self.nepalinumber_zero),
+        )
+
+    def test_negative_nepalinumber_float_can_be_divmod_with_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            divmod(self.nepalinumber_negative_float_4_5, -2.5),
+            (self.nepalinumber_integer_1, self.nepalinumber_negative_integer_2),
+        )
+
+    # divmod negative nepalinumber float as divisior tests
+    def test_positive_integer_can_be_divmod_with_negative_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(10, self.nepalinumber_negative_float_2_5),
+            (self.nepalinumber_negative_integer_4, self.nepalinumber_zero),
+        )
+
+    def test_positive_float_can_be_divmod_with_negative_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(4.5, self.nepalinumber_negative_float_2_25),
+            (self.nepalinumber_negative_integer_2, self.nepalinumber_zero),
+        )
+
+    def test_negative_integer_can_be_divmod_with_negative_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(-10, self.nepalinumber_negative_float_2_25),
+            (self.nepalinumber_integer_4, self.nepalinumber_negative_integer_1),
+        )
+
+    def test_negative_float_can_be_divmod_with_negative_nepalinumber_float(self):
+        self.assertEqual(
+            divmod(-15.5, self.nepalinumber_negative_float_1_5),
+            (self.nepalinumber_integer_10, self.nepalinumber_negative_float_0_5),
+        )
+
+    # pow
+    # pow positive nepalinumber integer as base
+    def test_positive_nepalinumber_integer_can_be_powered_to_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_2**2, self.nepalinumber_integer_4)
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_2**2.5, number.nepalinumber(2**2.5)
+        )
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_negative_integer(self):
+        self.assertEqual(self.nepalinumber_integer_2**-1, self.nepalinumber_float_0_5)
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_integer_2**-1.5, number.nepalinumber(2**-1.5)
+        )
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_2**self.nepalinumber_integer_2,
+            self.nepalinumber_integer_4,
+        )
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_2**self.nepalinumber_float_2_5,
+            number.nepalinumber(2**2.5),
+        )
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_2**self.nepalinumber_negative_integer_1,
+            self.nepalinumber_float_0_5,
+        )
+
+    def test_positive_nepalinumber_integer_can_be_powered_to_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_integer_2**self.nepalinumber_negative_float_1_5,
+            number.nepalinumber(2**-1.5),
+        )
+
+    # pow positive nepalinumber integer as exponent
+    def test_positive_integer_can_be_powered_to_positive_nepalinumber_integer(self):
+        self.assertEqual(2**self.nepalinumber_integer_2, self.nepalinumber_integer_4)
+
+    def test_positive_float_can_be_powered_to_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            2.5**self.nepalinumber_integer_2, number.nepalinumber(2.5**2)
+        )
+
+    def test_negative_integer_can_be_powered_to_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            (-1) ** self.nepalinumber_integer_2, self.nepalinumber_integer_1
+        )
+
+    def test_negative_float_can_be_powered_to_positive_nepalinumber_integer(self):
+        self.assertEqual(
+            (-1.5) ** self.nepalinumber_integer_2, number.nepalinumber((-1.5) ** 2)
+        )
+
+    def test_positive_nepalinumber_float_can_be_powered_to_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_2_5**self.nepalinumber_integer_2,
+            number.nepalinumber(2.5**2),
+        )
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_1**self.nepalinumber_integer_2,
+            self.nepalinumber_integer_1,
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_positive_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5**self.nepalinumber_integer_2,
+            number.nepalinumber((-1.5) ** 2),
+        )
+
+    # pow positive nepalinumber float as base
+    def test_positive_nepalinumber_float_can_be_powered_to_positive_integer(self):
+        self.assertEqual(self.nepalinumber_float_1_5**2, self.nepalinumber_float_2_25)
+
+    def test_positive_nepalinumber_float_can_be_powered_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_1_5**1.5, number.nepalinumber(1.5**1.5)
+        )
+
+    def test_positive_nepalinumber_float_can_be_powered_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_float_1_5**-2, number.nepalinumber(1.5**-2)
+        )
+
+    def test_positive_nepalinumber_float_can_be_powered_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_1_5**-1.5, number.nepalinumber(1.5**-1.5)
+        )
+
+    def test_positive_nepalinumber_float_can_be_powered_to_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_1_5**self.nepalinumber_float_1_5,
+            number.nepalinumber(1.5**1.5),
+        )
+
+    def test_positive_nepalinumber_float_can_be_powered_to_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_1_5**self.nepalinumber_negative_integer_2,
+            number.nepalinumber(1.5**-2),
+        )
+
+    def test_positive_nepalinumber_float_can_be_powered_to_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_float_1_5**self.nepalinumber_negative_float_1_5,
+            number.nepalinumber(1.5**-1.5),
+        )
+
+    # pow positive nepalinumber float as exponent
+    def test_positive_integer_can_be_powered_to_positive_nepalinumber_float(self):
+        self.assertEqual(
+            2**self.nepalinumber_float_1_5, number.nepalinumber(2**1.5)
+        )
+
+    def test_positive_float_can_be_powered_to_positive_nepalinumber_float(self):
+        self.assertEqual(
+            1.5**self.nepalinumber_float_1_5, number.nepalinumber(1.5**1.5)
+        )
+
+    def test_negative_integer_can_be_powered_to_positive_nepalinumber_float(self):
+        self.assertEqual((-2) ** self.nepalinumber_float_1_5, (-2) ** 1.5)
+
+    def test_negative_float_can_be_powered_to_positive_nepalinumber_float(self):
+        self.assertEqual((-1.5) ** self.nepalinumber_float_1_5, (-1.5) ** 1.5)
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2**self.nepalinumber_float_1_5,
+            (-2) ** 1.5,
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_positive_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5**self.nepalinumber_float_1_5,
+            (-1.5) ** 1.5,
+        )
+
+    # pow negative nepalinumber integer as base
+    def test_negative_nepalinumber_integer_can_be_powered_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2**2, self.nepalinumber_integer_4
+        )
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2**2.5,
+            (-2) ** 2.5,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2**-1,
+            self.nepalinumber_negative_float_0_5,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2**-1.5,
+            (-2) ** -1.5,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2
+            ** self.nepalinumber_negative_integer_1,
+            self.nepalinumber_negative_float_0_5,
+        )
+
+    def test_negative_nepalinumber_integer_can_be_powered_to_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_integer_2
+            ** self.nepalinumber_negative_float_1_5,
+            (-2) ** -1.5,
+        )
+
+    # pow negative nepalinumber integer as exponent
+    def test_positive_integer_can_be_powered_to_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            2**self.nepalinumber_negative_integer_2, number.nepalinumber(2**-2)
+        )
+
+    def test_positive_float_can_be_powered_to_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            2.5**self.nepalinumber_negative_integer_2, number.nepalinumber(2.5**-2)
+        )
+
+    def test_negative_integer_can_be_powered_to_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            (-1) ** self.nepalinumber_negative_integer_2, self.nepalinumber_integer_1
+        )
+
+    def test_negative_float_can_be_powered_to_negative_nepalinumber_integer(self):
+        self.assertEqual(
+            (-1.5) ** self.nepalinumber_negative_integer_2,
+            number.nepalinumber((-1.5) ** (-2)),
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_negative_nepalinumber_integer(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5
+            ** self.nepalinumber_negative_integer_2,
+            number.nepalinumber((-1.5) ** (-2)),
+        )
+
+    # pow negative nepalinumber float as base
+    def test_negative_nepalinumber_float_can_be_powered_to_positive_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5**2, self.nepalinumber_float_2_25
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5**1.5,
+            (-1.5) ** 1.5,
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_negative_integer(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5**-2,
+            number.nepalinumber((-1.5) ** -2),
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5**-1.5,
+            (-1.5) ** -1.5,
+        )
+
+    def test_negative_nepalinumber_float_can_be_powered_to_negative_nepalinumber_float(
+        self,
+    ):
+        self.assertEqual(
+            self.nepalinumber_negative_float_1_5
+            ** self.nepalinumber_negative_float_1_5,
+            (-1.5) ** -1.5,
+        )
+
+    # pow negative nepalinumber float as exponent
+    def test_positive_integer_can_be_powered_to_negative_nepalinumber_float(self):
+        self.assertEqual(
+            2**self.nepalinumber_negative_float_1_5, number.nepalinumber(2**-1.5)
+        )
+
+    def test_positive_float_can_be_powered_to_negative_nepalinumber_float(self):
+        self.assertEqual(
+            1.5**self.nepalinumber_negative_float_1_5,
+            number.nepalinumber(1.5**-1.5),
+        )
+
+    def test_negative_integer_can_be_powered_to_negative_nepalinumber_float(self):
+        self.assertEqual(
+            (-2) ** self.nepalinumber_negative_float_1_5,
+            (-2) ** -1.5,
+        )
+
+    def test_negative_float_can_be_powered_to_negative_nepalinumber_float(self):
+        self.assertEqual(
+            (-1.5) ** self.nepalinumber_negative_float_1_5,
+            (-1.5) ** -1.5,
+        )
+
+
+class TestNepaliNumberParse(unittest.TestCase):
+    def test_nepalinumber_parse_int(self):
+        num = nepalinumber(13)
+        self.assertEqual(num.value, 13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_int_negative(self):
+        num = nepalinumber(-13)
+        self.assertEqual(num.value, -13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_float(self):
+        num = nepalinumber(13.07)
+        self.assertEqual(num.value, 13.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_float_negative(self):
+        num = nepalinumber(-13.07)
+        self.assertEqual(num.value, -13.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_str_int(self):
+        num = nepalinumber("13")
+        self.assertEqual(num.value, 13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_str_int_negative(self):
+        num = nepalinumber("-13")
+        self.assertEqual(num.value, -13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_str_float(self):
+        num = nepalinumber("13.07")
+        self.assertEqual(num.value, 13.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_str_float_negative(self):
+        num = nepalinumber("-13.07")
+        self.assertEqual(num.value, -13.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_str_float_starting_dot(self):
+        num = nepalinumber(".07")
+        self.assertEqual(num.value, 0.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_str_float_starting_dot_and_negative(self):
+        num = nepalinumber("-.07")
+        self.assertEqual(num.value, -0.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_str_nepali_int(self):
+        num = nepalinumber("१३")
+        self.assertEqual(num.value, 13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_str_nepali_int_negative(self):
+        num = nepalinumber("-१३")
+        self.assertEqual(num.value, -13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_str_nepali_float(self):
+        num = nepalinumber("१३.०७")
+        self.assertEqual(num.value, 13.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_str_nepali_float_negative(self):
+        num = nepalinumber("-१३.०७")
+        self.assertEqual(num.value, -13.07)
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_raises_exception_for_chars_english(self):
+        with self.assertRaises(ValueError) as ex:
+            nepalinumber("invalid")
+        self.assertEqual(
+            str(ex.exception), "could not convert str to nepalinumber: 'invalid'"
+        )
+
+    def test_nepalinumber_raises_exception_for_chars_nepali(self):
+        with self.assertRaises(ValueError) as ex:
+            nepalinumber("आइतबार")
+
+    def test_nepalinumber_raises_exception_for_two_dots(self):
+        with self.assertRaises(ValueError) as ex:
+            nepalinumber("10..5")
+
+    def test_nepalinumber_raises_exception_for_nepali_aplha(self):
+        with self.assertRaises(ValueError) as ex:
+            nepalinumber("10..5")
+
+    def test_nepalinumber_raises_exception_for_special_chars(self):
+        with self.assertRaises(ValueError) as ex:
+            nepalinumber("!@#$%^&*()-+")
+
+    def test_nepalinumber_raise_exception_for_number_with_spaces(self):
+        with self.assertRaises(ValueError) as ex:
+            nepalinumber("10 20")
+
+    def test_nepalinumber_raises_exception_on_complex_number(self):
+        with self.assertRaises(TypeError) as ex:
+            nepalinumber(3 + 2j)
+        self.assertEqual(
+            str(ex.exception), "could not convert complex to nepalinumber: '(3+2j)'"
+        )
+
+    # Object parsing
+    def test_nepalinumber_parse_object_with_int(self):
+        class _test:
+            def __int__(self):
+                return 13
+
+        num = nepalinumber(_test())
+        self.assertEqual(num.value, int(_test()))
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_object_with_float(self):
+        class _test:
+            def __float__(self):
+                return 13.07
+
+        num = nepalinumber(_test())
+        self.assertEqual(num.value, float(_test()))
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_object_with_float_and_int(self):
+        class _test:
+            def __int__(self):
+                return 13
+
+            def __float__(self):
+                return 13.07
+
+        num = nepalinumber(_test())
+        self.assertNotEqual(num.value, int(_test()))
+        self.assertEqual(num.value, float(_test()))
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_parse_object_with_valid_number_str_int(self):
+        class _test:
+            def __str__(self):
+                return "13"
+
+        num = nepalinumber(_test())
+        self.assertEqual(num.value, int(str(_test())))
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parse_object_with_valid_number_str_float(self):
+        class _test:
+            def __str__(self):
+                return "13.07"
+
+        num = nepalinumber(_test())
+        self.assertEqual(num.value, float(str(_test())))
+        self.assertEqual(type(num.value), float)
+
+    def test_nepalinumber_raises_exception_for_invalid_object(self):
+        class _test:
+            def __str__(self):
+                return "13-03"
+
+        with self.assertRaises(TypeError) as ex:
+            nepalinumber(_test())
+        self.assertEqual(
+            str(ex.exception), "could not convert _test to nepalinumber: '13-03'"
+        )
+
+    # parsing inheritance with float and int
+    def test_nepalinumber_parses_inherited_int(self):
+        class _test(int):
+            pass
+
+        num = nepalinumber(_test(13))
+        self.assertEqual(num.value, 13)
+        self.assertEqual(type(num.value), int)
+
+    def test_nepalinumber_parses_inherited_float(self):
+        class _test(float):
+            pass
+
+        num = nepalinumber(_test(13.07))
+        self.assertEqual(num.value, 13.07)
+        self.assertEqual(type(num.value), float)
+
+
+class TestNepaliNumberMethods(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # positive integers
+        cls.nepalinumber_integer_999999 = number.nepalinumber(999999)
+        cls.nepalinumber_integer_1 = number.nepalinumber(1)
+        cls.nepalinumber_integer_0 = number.nepalinumber(0)
+        # positive floats
+        cls.nepalinumber_float_999999_999999 = number.nepalinumber(999999.999999)
+        cls.nepalinumber_float_1_25 = number.nepalinumber(1.25)
+        cls.nepalinumber_float_0_05 = number.nepalinumber(0.05)
+        cls.nepalinumber_float_0_0 = number.nepalinumber(0.0)
+        # negative numbers
+        cls.nepalinumber_negative_integer_999999 = number.nepalinumber(-999999)
+        cls.nepalinumber_negative_integer_1 = number.nepalinumber(-1)
+        # negative floats
+        cls.nepalinumber_negative_float_999999_999999 = number.nepalinumber(
+            -999999.999999
+        )
+        cls.nepalinumber_negative_float_1_25 = number.nepalinumber(-1.25)
+        cls.nepalinumber_negative_float_0_05 = number.nepalinumber(-0.05)
+
+    # tests for str_ne methods
+    def test_nepalinumber_str_ne_for_small_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_1.str_ne(), "१")
+
+    def test_nepalinumber_str_ne_for_large_positive_integer(self):
+        self.assertEqual(self.nepalinumber_integer_999999.str_ne(), "९९९९९९")
+
+    def test_nepalinumber_str_ne_for_small_negative_integer(self):
+        self.assertEqual(self.nepalinumber_negative_integer_1.str_ne(), "-१")
+
+    def test_nepalinumber_str_ne_for_large_negative_integer(self):
+        self.assertEqual(self.nepalinumber_negative_integer_999999.str_ne(), "-९९९९९९")
+
+    def test_nepalinumber_str_ne_for_small_positive_float(self):
+        self.assertEqual(self.nepalinumber_float_1_25.str_ne(), "१.२५")
+        self.assertEqual(self.nepalinumber_float_0_05.str_ne(), "०.०५")
+
+    def test_nepalinumber_str_ne_for_large_positive_float(self):
+        self.assertEqual(
+            self.nepalinumber_float_999999_999999.str_ne(), "९९९९९९.९९९९९९"
+        )
+
+    def test_nepalinumber_str_ne_for_small_negative_float(self):
+        self.assertEqual(self.nepalinumber_negative_float_1_25.str_ne(), "-१.२५")
+        self.assertEqual(self.nepalinumber_negative_float_0_05.str_ne(), "-०.०५")
+
+    def test_nepalinumber_str_ne_for_large_negative_float(self):
+        self.assertEqual(
+            self.nepalinumber_negative_float_999999_999999.str_ne(), "-९९९९९९.९९९९९९"
+        )
+
+    def test_nepalinumber_str_ne_for_zero(self):
+        self.assertEqual(self.nepalinumber_integer_0.str_ne(), "०")
+        self.assertEqual(self.nepalinumber_float_0_0.str_ne(), "०.०")