Merge master fixes

Author: hlouzada

README.md

@@ -12,16 +12,6 @@ The uncertainty calculations are in accordance with gaussian’s propagation, as
 
 Made by and for Physics Laboratory students in IFSC, who can't use uncertainties.py because of mean’s absolute deviation used in its calculation.
 
-To get this library on google colaboratory:
-
-```
-!curl --remote-name \
-
--H 'Accept: application/vnd.github.v3.raw' \
-
---location https://raw.githubusercontent.com/phisgroup/labfis.py/development/labfis/main.py
-```
-
 ## Usage
 
 Just import with `from labfis import labfloat` and create an *labfloat* object, as this exemple below:
@@ -33,7 +23,8 @@ Just import with `from labfis import labfloat` and create an *labfloat* object,
 >>> a*b
 (2 ± 7)
 ```
-Check the Wiki for more details
+
+Check the [Wiki]() for more details.
 
 ## Instalation
 

labfis/__init__.py

@@ -3,8 +3,8 @@
 # Copyright © 2020 labfis.py
 # (see LICENSE for details)
 
-__version__ = '1.1.5'
+__version__ = '1.2.0b'
 
 # Local imports
-from labfis.main import labfloat
-labfloat
+from labfis.uncertainty import labfloat
+labfloat

labfis/main.py labfis/uncertainty.pylabfis/main.py renamed to labfis/uncertainty.py

@@ -1,51 +1,107 @@
-from math import floor, ceil, trunc, log, log10, sqrt
+import logging
+from math import floor, ceil, trunc, log, log10, sqrt, cos, sin, tan
 from numbers import Number
 
+logger = logging.getLogger(__name__)
+
+try:
+    import numpy
+except ImportError:
+    numpy = None
+    logger.warning(
+        'Faild to import numpy; sqrt, sin, cos, tan and numpy.ndarray list method wont function')
+
+
+def skipif(condition, message):
+    def decorator(fnc):
+        def wrapper(*args, **kwargs):
+            if condition:
+                return fnc(*args, **kwargs)
+            else:
+                logger.info(message)
+                pass
+        return wrapper
+    return decorator
+
+
 class LabFloatError(Exception):
     def __init__(self, *args):
         if args:
             if args[0] == 0:
-                self.message = "Essa operação não é suportado nesta classe, apenas as operações mencionadas na apostila de Laboratório de Física 2 do IFSC."
+                self.message = "This operation is not supported."
             elif args[0] == 1:
-                self.message = "Too many args in list, expected '[...,[val,err],...]' got '{0}'".format(args[1])
-            elif isinstance(args[0],str):
-                self.message = "{0}{1}".format(args[0],args[1])
+                self.message = "Too many arguments, expected '(val,err)' or '([(val,err),...])' , got: '{0}'".format(
+                    args[1])
+            elif args[0] == 2:
+                self.message = "Mean list and Uncertainty list must have the same size, expected: '[[val1,val2,...,valn],[err1,err2,...,errn]]' , got: '{0}'".format(
+                    args[1:])
+            elif args[0] == 3:
+                self.message = "Uncertanty or mean list missing, expected: '[[val1,val2,...,valn],[err1,err2,...,errn],...]' , got: '{0}'".format(
+                    args[1])
+            elif args[0] == 4:
+                self.message = "Too many arguments, expected: '(precision)' or '(mean precision,err precision)' , got: '{0}'".format(
+                    args[1])
+            elif isinstance(args[0], str):
+                self.message = "{0}{1}".format(args[0], args[1:])
+            else:
+                self.message = None
         else:
             self.message = None
 
     def __str__(self):
         if self.message:
-            return '{0}'.format(self.message)
+            return self.message
         else:
-            return 'LabFloatError has been raised'
+            return 'A generic LabFloatError has been raised'
+
 
 class labfloat:
+    def __new__(cls, *args, **kwargs):
+        listlabfloat = kwargs.get('list', [])
+        if args:
+            if numpy:
+                if isinstance(args[0], (list, numpy.ndarray)):
+                    listlabfloat = args
+            else:
+                if isinstance(args[0], list):
+                    listlabfloat = args
+        if listlabfloat != []:
+            if len(listlabfloat) % 2 == 0:
+                return cls.list(listlabfloat)
+            else:
+                raise LabFloatError(3, listlabfloat)
+
+        return object.__new__(cls)
+
     def __init__(self, *args, **kwargs):
-        mean = kwargs.get('mean',0.0)
-        uncertainty = kwargs.get('uncertainty',0.0)
+        mean = kwargs.get('mean', 0.0)
+        uncertainty = kwargs.get('uncertainty', 0.0)
 
         if args:
             if len(args) == 1:
                 mean = args[0]
             elif len(args) == 2:
                 mean = args[0]
                 uncertainty = args[1]
-            else:
-                raise LabFloatError("Too many arguments, expected (val,err) or ([(val,err),...]), got: ",args)
+            elif len(args) > 2:
+                raise LabFloatError(1, args)
 
         self.mean = float(mean)
         self.uncertainty = abs(float(uncertainty))
 
     @classmethod
-    def list(cls,listargs):
+    def list(cls, listargs):
         listlabfloat = []
-        for j in range(len(listargs)):
-            if len(listargs[j]) == 2:
-                listlabfloat += [cls(listargs[j][0],listargs[j][1])]
-            elif len(listargs[j]) == 1:
-                listlabfloat += [cls(listargs[j][0])]
-            elif len(listargs[j]) > 2:
-                raise LabFloatError(1,listargs[j])
+        for j in range(0, len(listargs), 2):
+            if len(listargs[j]) == len(listargs[j+1]):
+                colum = []
+                for k in range(len(listargs[j])):
+                    colum += [cls(listargs[j][k], listargs[j+1][k])]
+                listlabfloat += [colum]
+            else:
+                raise LabFloatError(2, listargs[j], listargs[j+1])
+        if len(listlabfloat) == 1:
+            listlabfloat = listlabfloat[0]
         return(listlabfloat)
 
     def format(self):
@@ -55,7 +111,7 @@ def format(self):
             r = - len(su) + 1
             m = round(self.mean, r)
             u = round(self.uncertainty, r)
-            return((m,u))
+            return((m, u))
         else:
             r = -i
             r += 1
@@ -65,32 +121,29 @@ def format(self):
                 elif su[j+1] == "9" and r > 0:
                     m = round(self.mean, r-1)
                     u = round(self.uncertainty, r)
-                    return((m,u))
+                    return((m, u))
                 elif su[j] != ".":
                     m = round(self.mean, r)
                     u = round(self.uncertainty, r)
-                    return((m,u))
+                    return((m, u))
 
         m = round(self.mean, r)
         u = round(self.uncertainty, r)
-        return((m,u))
+        return((m, u))
 
     def split(self):
-        if self.uncertainty == 0:
-            return(["{:g}".format(self.mean)])
-        else:
-            m, u = self.format()
-            return(["{:g}".format(m),"{:g}".format(u)])
-          
-    def tex(self,*args,**kwargs):
+        m, u = self.format()
+        return(["{:g}".format(m), "{:g}".format(u)])
+
+    def tex(self, *args, **kwargs):
         precision = kwargs.get('precision')
         if args:
             if len(args) == 2:
                 precision = args
             elif len(args) > 2:
-                raise LabFloatError("Too many arguments, expected: (precision) or (mean precision,err precision) got: ",args)
+                raise LabFloatError(4, args)
             else:
-                precision = [args[0],args[0]]
+                precision = [args[0], args[0]]
 
         if self.uncertainty == 0:
             if precision:
@@ -106,7 +159,7 @@ def tex(self,*args,**kwargs):
             return("{0}".format(m))
         else:
             if precision:
-                precision = (str(precision[0]),str(precision[1]))
+                precision = (str(precision[0]), str(precision[1]))
                 m, u = self.format()
                 m = eval("'{:."+precision[0]+"e}'.format(m)")
                 u = eval("'{:."+precision[1]+"e}'.format(u)")
@@ -125,17 +178,13 @@ def tex(self,*args,**kwargs):
             return(r"({0}\, \pm \,{1})".format(m, u))
 
     def __str__(self):
-        val = self.split()
-        if len(val) == 1:
-            return("{0}".format(val[0]))
-        else:
-            return("({0} ± {1})".format(*val))
+        return("({0} ± {1})".format(*self.split()))
 
     def __repr__(self):
         return self.__str__()
-    
+
     def __getitem__(self, idx):
-        vals = [self.mean,self.uncertainty]
+        vals = [self.mean, self.uncertainty]
         return vals[idx]
 
     def __pos__(self):
@@ -171,25 +220,25 @@ def __ne__(self, other):
         if isinstance(other, Number):
             return abs(self.mean - other) > 3 * self.uncertainty
 
-    def __lt__(self,other):
+    def __lt__(self, other):
         if isinstance(other, labfloat):
             return self.mean + self.uncertainty < other.mean - other.uncertainty
         if isinstance(other, Number):
             return self.mean + self.uncertainty < other
 
-    def __gt__(self,other):
+    def __gt__(self, other):
         if isinstance(other, labfloat):
             return self.mean - self.uncertainty > other.mean + other.uncertainty
         if isinstance(other, Number):
             return self.mean - self.uncertainty > other
 
-    def __le__(self,other):
+    def __le__(self, other):
         if isinstance(other, labfloat):
             return self.mean + self.uncertainty <= other.mean + other.uncertainty
         if isinstance(other, Number):
             return self.mean + self.uncertainty <= other
 
-    def __ge__(self,other):
+    def __ge__(self, other):
         if isinstance(other, labfloat):
             return self.mean - self.uncertainty >= other.mean - other.uncertainty
         if isinstance(other, Number):
@@ -236,7 +285,7 @@ def __imul__(self, other):
 
     def __div__(self, other):
         if isinstance(other, labfloat):
-            return labfloat(self.mean / other.mean, sqrt((self.uncertainty / other.mean) ** 2 + (self.mean * other.uncertainty / (other.mean ** 2)) ** 2 ))
+            return labfloat(self.mean / other.mean, sqrt((self.uncertainty / other.mean) ** 2 + (self.mean * other.uncertainty / (other.mean ** 2)) ** 2))
         if isinstance(other, Number):
             return labfloat(self.mean / other, abs(self.uncertainty / other))
 
@@ -251,7 +300,7 @@ def __itruediv__(self, other):
 
     def __rdiv__(self, other):
         if isinstance(other, labfloat):
-            return labfloat(other.mean / self.mean, sqrt((other.uncertainty / self.mean) ** 2 + (other.mean * self.uncertainty / (self.mean ** 2)) ** 2 ))
+            return labfloat(other.mean / self.mean, sqrt((other.uncertainty / self.mean) ** 2 + (other.mean * self.uncertainty / (self.mean ** 2)) ** 2))
         if isinstance(other, Number):
             return labfloat(other / self.mean, abs(other * self.uncertainty / self.mean ** 2))
 
@@ -273,6 +322,22 @@ def __rpow__(self, other):
     def __ipow__(self, other):
         return self.__pow__(other)
 
+    @skipif(numpy, "The sqrt() method is not supported without numpy")
+    def sqrt(self):
+        return self.__pow__(0.5)
+
+    @skipif(numpy, "The cos() method is not supported without numpy")
+    def cos(self):
+        return labfloat(cos(self.mean), abs(-(sin(self.mean)) * self.uncertainty))
+
+    @skipif(numpy, "The sin() method is not supported without numpy")
+    def sin(self):
+        return labfloat(sin(self.mean), abs(cos(self.mean) * self.uncertainty))
+
+    @skipif(numpy, "The tan() method is not supported without numpy")
+    def tan(self):
+        return labfloat(tan(self.mean), sqrt((cos(self.mean) ** -4) * self.uncertainty ** 2))
+
     def __int__(self):
         return int(self.mean)
 
@@ -286,4 +351,4 @@ def __oct__(self):
         return oct(self.mean)
 
     def __hex__(self):
-        return hex(self.mean)
+        return hex(self.mean)

setup.py

@@ -56,11 +56,12 @@ def find_version(*file_paths):
     'Operating System :: Microsoft :: Windows',
     'Operating System :: POSIX',
     'License :: OSI Approved :: MIT License',
-    'Programming Language :: Python :: 2.7',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3.8']
 
-python_ver = '>=2.7'
+#requirements = ['numpy']
+
+python_ver = '>=3.6'
 
 setup(name=APP_NAME,
     version=version,
@@ -74,5 +75,6 @@ def find_version(*file_paths):
     long_description_content_type="text/markdown",
     packages=find_packages(),
     classifiers=classifiers,
+#    install_requires=requirements,
     python_requires=python_ver,
 )