Change Complex.py to number.py+Updating version to 0.7.7

Things are getting better, hopefully

Author: omdxp

cmpx/__init__.py

@@ -1,11 +1,11 @@
-from .Complex import Complex
+from .number import Complex
 from .error import print_err
 
 __title__      = 'PythonComplex'
 __author__     = 'Omar Belghaouti'
 __maintainer__ = 'Omar Belghaouti'
 __email__      = 'bel_omar18@yahoo.com'
-__version__    = '0.7.5'
+__version__    = '0.7.7'
 __license__    = 'MIT'
 __all__ = [
     'Complex'

cmpx/equations/solve.py

@@ -6,7 +6,7 @@
 # Function to solve a second degree (or linear) equation with passing arguments seperatly
 def solve(a, b, c=0):
     try:
-        if a and b == 0:
+        if a or a and b == 0 :
             raise ValueError('At least give a number to the first two coefficents')
         if c != 0:
             delta = b**2 - 4 * a * c

cmpx/Complex.py cmpx/number.pycmpx/Complex.py renamed to cmpx/number.py

@@ -4,7 +4,8 @@
 
 @author: Omar Belghaouti
 """
-from cmpx import print_err
+from colorama import Fore, Style
+from .error import print_err
 from math import sqrt
 
 # Complex class for complex number manipulations
@@ -16,9 +17,60 @@ class Complex():
     restore : whenever an error occurs on any operation of a complex number, the last instance will be restored (By default it's true)
     """
     def __init__(self, re=0, im=0, restore=True):
+        try:
+            if not ((isinstance(re, int) or isinstance(re, float)) and (isinstance(im, int) or isinstance(im, float))):
+                raise ValueError('Arguments re and im arguments are neither integers nor floats')
+            if not isinstance(restore, bool):
+                raise ValueError('Argument restore is not boolean')
+            self.re = re
+            self.im = im
+            self.restore = restore
+        except ValueError as err:
+            print_err(err)
+    """
+    This method instanciate a Complex object from a complex number
+    """
+    @classmethod
+    def fromComplex(self, comp, restore=True):
+        try:
+            if isinstance(comp, complex):
+                self.re = comp.real
+                self.im = comp.imag
+                self.restore = restore
+            else:
+                raise ValueError('The number you passed is not a complex')
+        except ValueError as err:
+            print_err(err)
+    # Getters
+    @property
+    def re(self):
+        return self.re
+    @property
+    def im(self):
+        return self.im
+    @property
+    def restore(self):
+        return self.restore
+    # Setters
+    @re.setter
+    def re(self, re):
         self.re = re
+    @im.setter
+    def im(self, im):
         self.im = im
+    @restore.setter
+    def restore(self, restore):
         self.restore = restore
+    # Deleters
+    @re.deleter
+    def re(self):
+        del self.re
+    @im.deleter
+    def im(self):
+        del self.im
+    @restore.deleter
+    def restore(self):
+        del self.restore
     # Operator overloading 1 : +
     def __add__(self, other):
         try:
@@ -28,7 +80,7 @@ def __add__(self, other):
                 other = Complex(other)
             return Complex(self.re + other.re, self.im + other.im, self.restore)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 2 : -
     def __sub__(self, other):
         try:
@@ -38,7 +90,7 @@ def __sub__(self, other):
                 other = Complex(other)
             return Complex(self.re - other.re, self.im - other.im, self.restore)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 3 : *
     def __mul__(self, other):
         try:
@@ -48,7 +100,7 @@ def __mul__(self, other):
                 other = Complex(other)
             return Complex(self.re * other.re - self.im * other.im, self.re * other.im + self.im * other.re, self.restore)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 4 : /
     def __truediv__(self, other):
         try:
@@ -65,7 +117,7 @@ def __truediv__(self, other):
                 return Complex(self.re, self.im, self.restore)
             return Complex(num.re / den.re, num.im / den.re, self.restore)
         except (ZeroDivisionError, ValueError) as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 5 : //
     def __floordiv__(self, other):
         try:
@@ -82,7 +134,7 @@ def __floordiv__(self, other):
                 return Complex(self.re, self.im, self.restore)
             return Complex(num.re // den.re, num.im // den.re, self.restore)
         except (ZeroDivisionError, ValueError) as err:
-            self.print_err(err)
+            print_err(err)
     def __gt__(self, other):
         try:
             if other is None:
@@ -91,7 +143,7 @@ def __gt__(self, other):
                 other = Complex(other)
             return self.mod() > other.mod()
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 7 : >=
     def __ge__(self, other):
         try:
@@ -101,7 +153,7 @@ def __ge__(self, other):
                 other = Complex(other)
             return self.mod() >= other.mod()
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 8: <
     def __lt__(self, other):
         try:
@@ -111,7 +163,7 @@ def __lt__(self, other):
                 other = Complex(other)
             return not self >= other
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 9: <=
     def __le__(self, other):
         try:
@@ -121,7 +173,7 @@ def __le__(self, other):
                 other = Complex(other)
             return not self > other
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 10: ==
     def __eq__(self, other):
         try:
@@ -131,7 +183,7 @@ def __eq__(self, other):
                 other = Complex(other)
             return (self.re == other.re) and (self.im == other.im)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 11: !=
     def __ne__(self, other):
         try:
@@ -141,7 +193,7 @@ def __ne__(self, other):
                 other = Complex(other)
             return not self == other
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 12: +=
     def __iadd__(self, other):
         try:
@@ -153,7 +205,7 @@ def __iadd__(self, other):
             self.im += other.im
             return Complex(self.re, self.im, self.restore)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 13: -=
     def __isub__(self, other):
         try:
@@ -165,7 +217,7 @@ def __isub__(self, other):
             self.im -= other.im
             return Complex(self.re, self.im, self.restore)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 14: *=
     def __imul__(self, other):
         try:
@@ -177,7 +229,7 @@ def __imul__(self, other):
             self.im = self.re * other.im + self.im * other.re
             return Complex(self.re, self.im, self.restore)
         except ValueError as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 15: /=
     def __idiv__(self, other):
         try:
@@ -196,7 +248,7 @@ def __idiv__(self, other):
             self.im = num.im / den.re
             return Complex(self.re, self.im, self.restore)
         except (ZeroDivisionError, ValueError) as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 16: //=
     def __ifloordiv__(self, other):
         try:
@@ -215,7 +267,7 @@ def __ifloordiv__(self, other):
             self.im = num.im // den.re
             return Complex(self.re, self.im, self.restore)
         except (ZeroDivisionError, ValueError) as err:
-            self.print_err(err)
+            print_err(err)
     # Operator overloading 17: - (Unary operator)
     def __neg__(self):
         return Complex(-self.re, -self.im, self.restore)

setup.py

@@ -5,7 +5,7 @@
 
 setup_args = dict(
     name='cmpx',
-    version='0.7.5',
+    version='0.7.7',
     description='A package for different operations on complex numbers',
     long_description_content_type='text/markdown',
     long_description=README,

tests/main.py

@@ -1,78 +1,10 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Sep 10 17:37:40 2019
-
-@author: Omar Belghaouti
-"""
-from cmpx.Complex import Complex
+from cmpx import Complex
 
 def main():
-    # Instanciation 1
-    number = Complex() # --> Real = 0, Imaginary = 0
-    print(number)
-    # Instanctiation 2
-    number = Complex(42) # --> Real = 42, Imaginary = 0
-    print(number)
-    # Instanciation 3
-    number = Complex(12, -3.2) # --> Real = 12, Imaginary = -3.2
-    print(number)
-    # Instanciation 4
-    number = Complex(im=13.2, re=5) # --> Real = 5, Imaginary = 13.2
-    print(number)
-    
-    # Basic operations
-    num1 = Complex(re=3, im=-2.5)
-    num2 = Complex(re=4.2, im=13.2)
-    # Summation
-    print('({}) + ({}) = {}'.format(num1, num2, num1 + num2))
-    # Substraction
-    print('({}) - ({}) = {}'.format(num1, num2, num1 - num2))
-    # Multiplication
-    print('({}) * ({}) = {}'.format(num1, num2, num1 * num2))
-    # Division
-    print('({}) / ({}) = {}'.format(num1, num2, num1 / num2))
-    # Floor division
-    print('({}) // ({}) = {}'.format(num1, num2, num1 // num2))
-    ## Affecting the result directly on the number
-    # Summation
-    print('({}) += ({})'.format(num1, 2), end=' --> ')
-    num1 += 2
-    print(num1)
-    # Substraction
-    print('({}) -= ({})'.format(num1, num2), end=' --> ')
-    num1 -= num2
-    print(num1)
-    # Multiplication
-    print('({}) *= ({})'.format(num1, 2), end=' --> ')
-    num1 *= 2
-    print(num1)
-    # Division
-    print('({}) /= ({})'.format(num1, num2), end=' --> ')
-    num1 /= num2
-    print(num1)
-    # Floor division
-    print('({}) //= ({})'.format(num1, 2), end=' --> ')
-    num1 /= 2
-    print(num1)
-    # Congugated of a complex number
-    print('con({}) = {}'.format(num2, num2.con()))
-    # Module of a complex number
-    print('mod({}) = {}'.format(num2, num2.mod()))
-    
-    # Basic comparisons
-    num1 = Complex(im=3.1, re=-5)
-    num2 = Complex(im=-1.5, re=0.6)
-    # Greater than
-    if(num1 > num2): print('({}) > ({})'.format(num1, num2))
-    # Greater or equal
-    if(num1 >= num2): print('({}) >= ({})'.format(num1, num2))
-    # Less than
-    if(num1 < num2): print('({}) < ({})'.format(num1, num2))
-    # Less or equal
-    if(num1 <= num2): print('({}) <= ({})'.format(num1, num2))
-    # Equal
-    if(num1 == num2): print('({}) == ({})'.format(num1, num2))
-    # Not equal
-    if(num1 != num2): print('({}) != ({})'.format(num1, num2))
-    
-if __name__ == '__main__': main()
+    a = 4 + 3 - 5j
+    print(a.real)
+    print(a.imag)
+    cmplx = Complex(a, 1)
+    print(cmplx)
+
+if __name__ == '__main__': main()