UnitValues 0.1.1__tar.gz → 0.1.3__tar.gz

{unitvalues-0.1.1/src/UnitValues.egg-info → unitvalues-0.1.3}/PKG-INFO

@@ -1,20 +1,21 @@
 Metadata-Version: 2.1
 Name: UnitValues
-Version: 0.1.1
-Summary: A small package for using units in Python. Allows for computation with dimensioned qauntities and allows you to convert between different units. Do anything you would do with regular floats or integers in Python except now with units. I think you'll find this implementation more elegant then most other unit packages.
+Version: 0.1.3
+Summary: A small package for using units in Python. Allows for computation with dimensioned qauntities and allows you to convert between different units. Do anything you would do with regular floats or integers in Python except now with units. Package is compatible with NumPy, SciPy + Pandas are in the works. I think you'll find this implementation more elegant then most other unit packages.
 Author-email: Brody Howard <brody.howard@mail.utoronto.ca>
 Project-URL: Homepage, https://github.com/BroRocket/unitvalue/
 Project-URL: Issues, https://github.com/BroRocket/unitvalue/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy>=1.23.2
 
-# UnitValue Package
+# UnitValues Package
 ## Introduction
-The UnitValue package is designed to allow easy manipulation and conversion of numerical values associated with units. It currently supports both Imperial and Metric systems and includes commonly used units, with the flexibility to add more units as needed. It works with numpy as well.
+The UnitValue package is designed to allow easy manipulation and conversion of numerical values associated with units. It currently supports both Imperial and Metric systems and includes commonly used units, with the flexibility to add more units as needed. It works with numpy as well, empowering you to use units in your numpy arrays and funciton calls.
 
 This package is ideal for applications that require precise unit conversions and tracking of units alongside numerical values.
 

{unitvalues-0.1.1 → unitvalues-0.1.3}/README.md

@@ -1,6 +1,6 @@
-# UnitValue Package
+# UnitValues Package
 ## Introduction
-The UnitValue package is designed to allow easy manipulation and conversion of numerical values associated with units. It currently supports both Imperial and Metric systems and includes commonly used units, with the flexibility to add more units as needed. It works with numpy as well.
+The UnitValue package is designed to allow easy manipulation and conversion of numerical values associated with units. It currently supports both Imperial and Metric systems and includes commonly used units, with the flexibility to add more units as needed. It works with numpy as well, empowering you to use units in your numpy arrays and funciton calls.
 
 This package is ideal for applications that require precise unit conversions and tracking of units alongside numerical values.
 

{unitvalues-0.1.1 → unitvalues-0.1.3}/pyproject.toml

@@ -1,12 +1,16 @@
 [project]
 name = "UnitValues"
-version = "0.1.1"
+version = "0.1.3"
+dependencies = [
+  "numpy >= 1.23.2"
+]
+requires-python = ">=3.10"
 authors = [
   { name="Brody Howard", email="brody.howard@mail.utoronto.ca" },
 ]
-description = "A small package for using units in Python. Allows for computation with dimensioned qauntities and allows you to convert between different units. Do anything you would do with regular floats or integers in Python except now with units. I think you'll find this implementation more elegant then most other unit packages."
+description = "A small package for using units in Python. Allows for computation with dimensioned qauntities and allows you to convert between different units. Do anything you would do with regular floats or integers in Python except now with units. Package is compatible with NumPy, SciPy + Pandas are in the works. I think you'll find this implementation more elegant then most other unit packages."
 readme = "README.md"
-requires-python = ">=3.8"
+
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

{unitvalues-0.1.1 → unitvalues-0.1.3/src/UnitValues.egg-info}/PKG-INFO

@@ -1,20 +1,21 @@
 Metadata-Version: 2.1
 Name: UnitValues
-Version: 0.1.1
-Summary: A small package for using units in Python. Allows for computation with dimensioned qauntities and allows you to convert between different units. Do anything you would do with regular floats or integers in Python except now with units. I think you'll find this implementation more elegant then most other unit packages.
+Version: 0.1.3
+Summary: A small package for using units in Python. Allows for computation with dimensioned qauntities and allows you to convert between different units. Do anything you would do with regular floats or integers in Python except now with units. Package is compatible with NumPy, SciPy + Pandas are in the works. I think you'll find this implementation more elegant then most other unit packages.
 Author-email: Brody Howard <brody.howard@mail.utoronto.ca>
 Project-URL: Homepage, https://github.com/BroRocket/unitvalue/
 Project-URL: Issues, https://github.com/BroRocket/unitvalue/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy>=1.23.2
 
-# UnitValue Package
+# UnitValues Package
 ## Introduction
-The UnitValue package is designed to allow easy manipulation and conversion of numerical values associated with units. It currently supports both Imperial and Metric systems and includes commonly used units, with the flexibility to add more units as needed. It works with numpy as well.
+The UnitValue package is designed to allow easy manipulation and conversion of numerical values associated with units. It currently supports both Imperial and Metric systems and includes commonly used units, with the flexibility to add more units as needed. It works with numpy as well, empowering you to use units in your numpy arrays and funciton calls.
 
 This package is ideal for applications that require precise unit conversions and tracking of units alongside numerical values.
 

{unitvalues-0.1.1 → unitvalues-0.1.3}/src/UnitValues.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/UnitValues.egg-info/PKG-INFO
 src/UnitValues.egg-info/SOURCES.txt
 src/UnitValues.egg-info/dependency_links.txt
+src/UnitValues.egg-info/requires.txt
 src/UnitValues.egg-info/top_level.txt
 src/unitvalue/__init__.py
 src/unitvalue/units.py

unitvalues-0.1.3/src/UnitValues.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.23.2

{unitvalues-0.1.1 → unitvalues-0.1.3}/src/unitvalue/units.py

@@ -6,7 +6,7 @@ Typically used units are supported and more can be added upon request or in your
 import warnings
 import numpy as np
 
-class UnitValue: 
+class UnitValue: # add specific heat
     """
     Represents a value with dimension/units.
 
@@ -26,7 +26,7 @@ class UnitValue:
                            "AREA": {"in^2": 0.00064516, "mi^2": 2590000, "yd^2": 0.836127, "ft^2": 0.092903},
                            "TEMPERATURE": {"f": None, "R":None},
                            "MASS FLOW RATE": {"lb/s": 0.453592, "ton/s": 907.1847, "st/s": 6.35029, "oz": 0.0283495, "lb/min": 0.00755987},
-                           "ENERGY": {"ftlb": 1.35582, "kcal": 4184, "cal": 4.184},
+                           "ENERGY": {"BTU": 1055.05585, "ftlb": 1.35582, "kcal": 4184, "cal": 4.184},
                            "TIME": {"s": 1, "h": 3600, "min": 60, "ms": 0.001},
                            "MOMENTUM": {"slugft/s": 4.449670915354, "lbft/s": 0.1383}, 
                            "FREQUENCY": {"rpm": 0.016667},
@@ -35,10 +35,11 @@ class UnitValue:
                            "ENERGY PER UNIT MASS": {"ft^2/s^2": 0.09290304}, 
                            "MASS PER UNIT LENGTH": {"lb/ft": 1.48816, "oz/in": 1.11612},
                            "MASS PER AREA": {"lb/ft^2": 4.88243},
-                           "VOLUMETRIC FLOW RATE": {"ft^3/s": 0.0283168, "gal/s": 0.00378541},
+                           "VOLUMETRIC FLOW RATE": {"ft^3/s": 0.0283168, "gal/s": 0.00378541, "ft^3/min": 0.000471947},
                            "DYNAMIC VISCOCITY": {"lb/fts": 1.488163943568},
                            "KINEMATIC VISCOCITY": {"ft^2/s": 0.092903},
-                           "MASS FLUX": {"lb/ft^2s": 4.88243} 
+                           "MASS FLUX": {"lb/ft^2s": 4.88243},
+                           "SPECIFIC HEAT": {"BTU/lbf": 4186.8000000087}
                          }, 
              "METRIC": {
                          "DISTANCE": {"m": 1, "km": 1000, "cm": 0.01, "mm": 0.001}, 
@@ -62,11 +63,12 @@ class UnitValue:
                          "VOLUMETRIC FLOW RATE": {"m^3/s": 1, "cm^3/s": 0.000001},
                          "DYNAMIC VISCOCITY": {"kg/ms": 1, "g/cms":0.1},
                          "KINEMATIC VISCOCITY": {"m^2/s": 1, "cm^2/s": 0.0001},
-                         "MASS FLUX": {"kg/m^2s": 1}
+                         "MASS FLUX": {"kg/m^2s": 1},
+                         "SPECIFIC HEAT": {"m^2/s^2K": 1, "J/kgK": 1, "J/kgc": 1}
                         }
             }
     
-    SPELLING_MAP = {'mtr': 'm', 'meters': 'm', 'mtr.': 'm', 'metres': 'm', 'metre': 'm', 'm ': 'm', 'meter': 'm', 'kilometer': 'km', 'kilometre': 'km', 'kilo meter': 'km', 'k meter': 'km', 'klometer': 'km', 'km ': 'km', 'kmeter': 'km', 'kmtr': 'km', 'centemeter': 'cm', 'centimetre': 'cm', 'cn': 'cm', 'c meter': 'cm', 'cm ': 'cm', 'centi meter': 'cm', 'centimeter': 'cm', 'cmeter': 'cm', 'cmtr': 'cm', 'mmeter': 'mm', 'millimeter': 'mm', 'milimeter': 'mm', 'milli meter': 'mm', 'millimetre': 'mm', 'm meter': 'mm', 'mn': 'mm', 'mmtr': 'mm', 'mm ': 'mm', 'g ': 'g', 'gramme': 'g', 'grm': 'g', 'gms': 'g', 'gram': 'g', 'gm': 'g', 'gramm': 'g', 'gram ': 'g', 'kilograms': 'kg', 'k gram': 'kg', 'kilogramme': 'kg', 'kilogram ': 'kg', 'kilogramme ': 'kg', 'kilogrammes': 'kg', 'kg ': 'kg', 'kilogram': 'kg', 'kilo gram': 'kg', 'kgrm': 'kg', 'liters': 'L', 'l': 'L', 'litres': 'L', 'ltrs': 'L', 'liter': 'L', 'litre ': 'L', 'litre': 'L', 'liters ': 'L', 'liter ': 'L', 'litter': 'L', 'ltr': 'L', 'ml': 'mL', 'milliliter': 'mL', 'mlitres': 'mL', 'millilitre': 'mL', 'milli litre': 'mL', 'mliters': 'mL', 'milli liter': 'mL', 'mltr': 'mL', 'sec': 's', 'seconds': 's', 'sedonds': 's', 'sconds': 's', 'second': 's', 'secs': 's', 'secnd': 's', 'minute': 'min', 'minuts': 'min', 'mins': 'min', 'minutes': 'min', 'min': 'min', 'minut': 'min', 'hours': 'h', 'hr': 'h', 'howr': 'h', 'houer': 'h', 'hour': 'h', 'hou': 'h', 'hrs': 'h', 'square meters': 'm^2', 'square meter': 'm^2', 'sqr meter': 'm^2', 'square metre': 'm^2', 'sq meter': 'm^2', 'sqmetre': 'm^2', 'sq metres': 'm^2', 'sqm': 'm^2', 'cube meter': 'm^3', 'cu meter': 'm^3', 'cbm': 'm^3', 'cubic meters': 'm^3', 'cubic metre': 'm^3', 'cubic meter': 'm^3', 'cu m': 'm^3', 'degree centigrade': 'c', 'degree celsius': 'c', 'celcius': 'c', 'deg celsius': 'c', 'celsius degree': 'c', 'celsus': 'c', 'celsius': 'c', 'deg c': 'c', 'fahrenheit degree': 'f', 'deg f': 'f', 'deg fahrenheit': 'f', 'fahrenhiet': 'f', 'degree fahrenheit': 'f', 'farhenheit': 'f', 'force': 'kgm/s^2', 'Newton': 'kgm/s^2', 'newtn': 'kgm/s^2', 'nwton': 'kgm/s^2', 'nwt': 'kgm/s^2', 'newton': 'kgm/s^2', 'joule': 'kgm^2/s^2', 'energy': 'kgm^2/s^2', 'juole': 'kgm^2/s^2', 'jl': 'kgm^2/s^2', 'joules': 'kgm^2/s^2', 'juul': 'kgm^2/s^2', 'inck': 'in', 'inche': 'in', 'inch': 'in', 'inc': 'in', 'inch ': 'in', 'inchh': 'in', 'foot': 'ft', 'foott': 'ft', 'fot': 'ft', 'foor': 'ft', 'foot ': 'ft', 'feet': 'ft', 'yardd': 'yd', 'yad': 'yd', 'yarrd': 'yd', 'yard ': 'yd', 'yard': 'yd', 'mille': 'mi', 'mile ': 'mi', 'milee': 'mi', 'mil': 'mi', 'mile': 'mi', 'pounds': 'lb', 'pounnd': 'lb', 'pound ': 'lb', 'pound': 'lb', 'lbs': 'lb', 'poundd': 'lb', 'galln': 'gal', 'gllon': 'gal', 'gallon': 'gal', 'galllon': 'gal', 'gallon ': 'gal', 'ounze': 'oz', 'ouncce': 'oz', 'ounce ': 'oz', 'ozs': 'oz', 'ounce': 'oz', 'ounc': 'oz', 'ounc ': 'oz', 'stn': 'st', 'stone ': 'st', 'sts': 'st', 'stone': 'st', 'st ': 'st', 'ft2': 'ft^2', 'square foot': 'ft^2', 'sqft': 'ft^2', 'square feet': 'ft^2', 'sq foot': 'ft^2', 'ft3': 'ft^3', 'cft': 'ft^3', 'cubic foot': 'ft^3', 'cu ft': 'ft^3', 'cubic feet': 'ft^3'}
+    SPELLING_MAP = {'mtr': 'm', 'meters': 'm', 'mtr.': 'm', 'metres': 'm', 'metre': 'm', 'm ': 'm', 'meter': 'm', 'kilometer': 'km', 'kilometre': 'km', 'kilo meter': 'km', 'k meter': 'km', 'klometer': 'km', 'km ': 'km', 'kmeter': 'km', 'kmtr': 'km', 'centemeter': 'cm', 'centimetre': 'cm', 'cn': 'cm', 'c meter': 'cm', 'cm ': 'cm', 'centi meter': 'cm', 'centimeter': 'cm', 'cmeter': 'cm', 'cmtr': 'cm', 'mmeter': 'mm', 'millimeter': 'mm', 'milimeter': 'mm', 'milli meter': 'mm', 'millimetre': 'mm', 'm meter': 'mm', 'mn': 'mm', 'mmtr': 'mm', 'mm ': 'mm', 'g ': 'g', 'gramme': 'g', 'grm': 'g', 'gms': 'g', 'gram': 'g', 'gm': 'g', 'gramm': 'g', 'gram ': 'g', 'kilograms': 'kg', 'k gram': 'kg', 'kilogramme': 'kg', 'kilogram ': 'kg', 'kilogramme ': 'kg', 'kilogrammes': 'kg', 'kg ': 'kg', 'kilogram': 'kg', 'kilo gram': 'kg', 'kgrm': 'kg', 'liters': 'L', 'l': 'L', 'litres': 'L', 'ltrs': 'L', 'liter': 'L', 'litre ': 'L', 'litre': 'L', 'liters ': 'L', 'liter ': 'L', 'litter': 'L', 'ltr': 'L', 'ml': 'mL', 'milliliter': 'mL', 'mlitres': 'mL', 'millilitre': 'mL', 'milli litre': 'mL', 'mliters': 'mL', 'milli liter': 'mL', 'mltr': 'mL', 'sec': 's', 'seconds': 's', 'sedonds': 's', 'sconds': 's', 'second': 's', 'secs': 's', 'secnd': 's', 'minute': 'min', 'minuts': 'min', 'mins': 'min', 'minutes': 'min', 'min': 'min', 'minut': 'min', 'hours': 'h', 'hr': 'h', 'howr': 'h', 'houer': 'h', 'hour': 'h', 'hou': 'h', 'hrs': 'h', 'square meters': 'm^2', 'square meter': 'm^2', 'sqr meter': 'm^2', 'square metre': 'm^2', 'sq meter': 'm^2', 'sqmetre': 'm^2', 'sq metres': 'm^2', 'sqm': 'm^2', 'cube meter': 'm^3', 'cu meter': 'm^3', 'cbm': 'm^3', 'cubic meters': 'm^3', 'cubic metre': 'm^3', 'cubic meter': 'm^3', 'cu m': 'm^3', 'C': 'c','degree centigrade': 'c', 'degree celsius': 'c', 'celcius': 'c', 'deg celsius': 'c', 'celsius degree': 'c', 'celsus': 'c', 'celsius': 'c', 'deg c': 'c', 'fahrenheit degree': 'f', 'deg f': 'f', 'deg fahrenheit': 'f', 'fahrenhiet': 'f', 'degree fahrenheit': 'f', 'farhenheit': 'f', 'force': 'kgm/s^2', 'Newton': 'kgm/s^2', 'newtn': 'kgm/s^2', 'nwton': 'kgm/s^2', 'nwt': 'kgm/s^2', 'newton': 'kgm/s^2', 'joule': 'kgm^2/s^2', 'energy': 'kgm^2/s^2', 'juole': 'kgm^2/s^2', 'jl': 'kgm^2/s^2', 'joules': 'kgm^2/s^2', 'juul': 'kgm^2/s^2', 'inck': 'in', 'inche': 'in', 'inch': 'in', 'inc': 'in', 'inch ': 'in', 'inchh': 'in', 'foot': 'ft', 'foott': 'ft', 'fot': 'ft', 'foor': 'ft', 'foot ': 'ft', 'feet': 'ft', 'yardd': 'yd', 'yad': 'yd', 'yarrd': 'yd', 'yard ': 'yd', 'yard': 'yd', 'mille': 'mi', 'mile ': 'mi', 'milee': 'mi', 'mil': 'mi', 'mile': 'mi', 'pounds': 'lb', 'pounnd': 'lb', 'pound ': 'lb', 'pound': 'lb', 'lbs': 'lb', 'poundd': 'lb', 'galln': 'gal', 'gllon': 'gal', 'gallon': 'gal', 'galllon': 'gal', 'gallon ': 'gal', 'ounze': 'oz', 'ouncce': 'oz', 'ounce ': 'oz', 'ozs': 'oz', 'ounce': 'oz', 'ounc': 'oz', 'ounc ': 'oz', 'stn': 'st', 'stone ': 'st', 'sts': 'st', 'stone': 'st', 'st ': 'st', 'ft2': 'ft^2', 'square foot': 'ft^2', 'sqft': 'ft^2', 'square feet': 'ft^2', 'sq foot': 'ft^2', 'ft3': 'ft^3', 'cft': 'ft^3', 'cubic foot': 'ft^3', 'cu ft': 'ft^3', 'cubic feet': 'ft^3'}
     
     @classmethod
     def add_custom_unit(cls, system: str, dimension:str, unit:str, conversion_factor: float) -> None:
@@ -323,10 +325,13 @@ class UnitValue:
                 return self.value * m.value
                     
             return UnitValue(None, None, new_unit, self.value * m.value)
-        elif isinstance(m, (int, float, np.ndarray)):
+        elif isinstance(m, (int, float)):
             return UnitValue(self.__system, self.__dimension, self.__unit, self.value * m)
         else:
-            return NotImplemented
+            try: 
+                return self * float(m) # checking if whatever the type is if it can be converted to float and then used 
+            except:
+                return NotImplemented
             
     def __rmul__(self, m) -> 'UnitValue':
         return self.__mul__(m)
@@ -365,10 +370,13 @@ class UnitValue:
                 return self.value / d.value
                     
             return UnitValue(None, None, new_unit, self.value / d.value)
-        elif isinstance(d, (int, float, np.ndarray)):
+        elif isinstance(d, (int, float)):
             return UnitValue(self.__system, self.__dimension, self.__unit, self.value / d)
         else:
-            return NotImplemented
+            try: 
+                return self / float(d) 
+            except:
+                return NotImplemented
         
     def __rtruediv__(self, d) -> 'UnitValue':
         """
@@ -404,7 +412,7 @@ class UnitValue:
                 return d.value / self.value
                     
             return UnitValue(None, None, new_unit, d.value / self.value)
-        elif isinstance(d, (int, float, np.ndarray)):
+        elif isinstance(d, (int, float)):
             
             units = {}
             self.__process_unit(self.__unit, units, -1)
@@ -429,7 +437,10 @@ class UnitValue:
             new_unit = numer + denom
             return UnitValue(None, None, new_unit, d / self.value)
         else:
-            return NotImplemented
+            try: 
+                return  float(d) / self
+            except:
+                return NotImplemented
 
     def __pow__(self, p)  -> 'UnitValue':
         """
@@ -466,7 +477,10 @@ class UnitValue:
             return UnitValue(None, None, new_unit, self.value ** p)
 
         else:
-            raise NotImplementedError(f"Raising to the power with type {type(p)} not supported")
+            try: 
+                return self ** float(p) 
+            except:
+                return NotImplemented
 
     def __add__(self, a)  -> 'UnitValue':
         """
@@ -480,11 +494,14 @@ class UnitValue:
             self.convert_base_metric()
             a.convert_base_metric()
             return UnitValue(self.__system, self.__dimension, self.__unit, self.value + a.value)
-        
-        elif isinstance(a, (int, float, np.ndarray)):
+        elif isinstance(a, (int, float)):
+            warnings.warn("Adding unitless value to quantity with units")
             return UnitValue(self.__system, self.__dimension, self.__unit, self.value + a)
         else:
-            return NotImplemented
+            try: 
+                return self + float(a) 
+            except:
+                return NotImplemented
         
     def __radd__(self, a)  -> 'UnitValue':
         return self.__add__(a)
@@ -501,16 +518,36 @@ class UnitValue:
             self.convert_base_metric()
             s.convert_base_metric()
             return UnitValue(self.__system, self.__dimension, self.__unit, self.value - s.value)
-        elif isinstance(s, (int, float, np.ndarray)):
+        elif isinstance(s, (int, float)):
+            warnings.warn("Subtracting unitless value to quantity with units")
             return UnitValue(self.__system, self.__dimension, self.__unit, self.value - s) 
-        else: 
-            return NotImplemented
+        else:
+            try: 
+                return self - float(s) 
+            except:
+                return NotImplemented
         
     def __rsub__(self, s)  -> 'UnitValue':
         return -self.__sub__(s)
 
     def __neg__(self):
         return UnitValue(self.__system, self.__dimension, self.__unit, -self.value)
+    
+    def __mod__(self, other) -> int:
+        if isinstance(other, UnitValue):
+            return self.value % other.value
+        elif isinstance(other, (int, float)):
+            return self.value % other
+        else:
+            return NotImplemented
+        
+    def __rmod__(self, other) -> int:
+        if isinstance(other, UnitValue):
+            return  other.value % self.value
+        elif isinstance(other, (int, float)):
+            return other % self.value
+        else:
+            return NotImplemented
 
     def __abs__(self):
         """
@@ -523,8 +560,8 @@ class UnitValue:
         Checks if UnitValue object is equal to other.
         """
         if isinstance(other, UnitValue):
-            a = self.__cpy().convert_base_metric()
-            b = other.__cpy().convert_base_metric()
+            a = self.copy().convert_base_metric()
+            b = other.copy().convert_base_metric()
             return a.value == b.value and a.__unit == b.__unit
         elif isinstance(other, (int, float)):
             return self.value == other
@@ -532,8 +569,8 @@ class UnitValue:
 
     def __ne__(self, other) -> bool:
         if isinstance(other, UnitValue):
-            a = self.__cpy().convert_base_metric()
-            b = other.__cpy().convert_base_metric()
+            a = self.copy().convert_base_metric()
+            b = other.copy().convert_base_metric()
             return a.value != b.value and a.__unit != b.__unit
         elif isinstance(other, (int, float)):
             return self.value != other
@@ -541,8 +578,8 @@ class UnitValue:
     
     def __lt__(self, other) -> bool:
         if isinstance(other, UnitValue):
-            a = self.__cpy().convert_base_metric()
-            b = other.__cpy().convert_base_metric()
+            a = self.copy().convert_base_metric()
+            b = other.copy().convert_base_metric()
             return a.value < b.value
         elif isinstance(other, (int, float)):
             return self.value < other
@@ -550,8 +587,8 @@ class UnitValue:
     
     def __le__(self, other) -> bool:
         if isinstance(other, UnitValue):
-            a = self.__cpy().convert_base_metric()
-            b = other.__cpy().convert_base_metric()
+            a = self.copy().convert_base_metric()
+            b = other.copy().convert_base_metric()
             return a.value <= b.value
         elif isinstance(other, (int, float)):
             return self.value <= other
@@ -559,8 +596,8 @@ class UnitValue:
     
     def __gt__(self, other) -> bool:
         if isinstance(other, UnitValue):
-            a = self.__cpy().convert_base_metric()
-            b = other.__cpy().convert_base_metric()
+            a = self.copy().convert_base_metric()
+            b = other.copy().convert_base_metric()
             return a.value > b.value
         elif isinstance(other, (int, float)):
             return self.value > other
@@ -568,8 +605,8 @@ class UnitValue:
     
     def __ge__(self, other) -> bool:
         if isinstance(other, UnitValue):
-            a = self.__cpy().convert_base_metric()
-            b = other.__cpy().convert_base_metric()
+            a = self.copy().convert_base_metric()
+            b = other.copy().convert_base_metric()
             return a.value >= b.value
         elif isinstance(other, (int, float)):
             return self.value >= other
@@ -599,17 +636,55 @@ class UnitValue:
         Handle NumPy ufunc (universal function) operations for UnitValue objects.
         """
         out = kwargs.get('out', ())
-        inputs = [i.value if isinstance(i, UnitValue) else i for i in inputs]
         
-        result = getattr(ufunc, method)(*inputs, **kwargs)
-        
-        if method == 'reduce':
-            return UnitValue(self.__system, self.__dimension, self.__unit, result)
-        elif method == 'outer':
-            return np.vectorize(lambda x: UnitValue(self.__system, self.__dimension, self.__unit, x))(result)
-        else:
-            return UnitValue(self.__system, self.__dimension, self.__unit, result)
+        if method == "__call__":
+            if isinstance(inputs[0], np.ndarray):
+                inputs = [inputs[0], inputs[1]]
+                for ind, element in enumerate(inputs[0]):
+                    inputs[0][ind] = ufunc(element, inputs[1], **kwargs)
+                return inputs[0]
+            elif len(inputs) > 1 and isinstance(inputs[1], np.ndarray):
+                inputs = [inputs[0], inputs[1]]
+                for ind, element in enumerate(inputs[1]):
+                    inputs[1][ind] = ufunc(inputs[0], element, **kwargs)
+                return inputs[1]
+            else:
+                if isinstance(inputs[0], (np.float64, np.int64)):
+                    inputs = [float(inputs[0]), inputs[1]]
+                if ufunc == np.add:
+                    return inputs[0] + inputs[1]
+                elif ufunc == np.subtract:
+                    return inputs[0] - inputs[1]
+                elif ufunc == np.multiply:
+                    return inputs[0] * inputs[1]
+                elif ufunc == np.divide:
+                    return inputs[0] / inputs[1]
+                elif ufunc == np.sqrt:
+                    return inputs[0] ** 0.5
+                elif ufunc == np.power:
+                    return inputs[0] ** inputs[1]
+                elif ufunc == np.mod:
+                    return inputs[0] % inputs[1]
+                elif ufunc == np.log10:
+                    return np.log10(inputs[0].value)
+                else:
+                    return NotImplemented
     
+    def __array_function__(self, func, types, *args, **kwargs):
+        if func is np.concatenate:
+            unit_cache = []
+            for arr in args[0]:
+                unit_cache += [item.get_unit if isinstance(item, UnitValue) else None for item in arr]
+                for i in range(len(arr)):
+                    arr[i] = arr[i].value if isinstance(arr[i], UnitValue) else arr[i]
+            new_array = np.concatenate(args[0], **kwargs)
+            for ind, unit in enumerate(unit_cache):
+                if unit is not None:
+                    new_array[ind] = self.create_unit(unit, new_array[ind])
+            return new_array
+        else:
+            return NotImplemented
+
     def __convert_system(self, unit: str = "") -> None:
         self.value *= UnitValue.UNITS[self.__system][self.__dimension][self.__unit] 
         self.__system = "IMPERIAL" if self.__system == "METRIC" else "METRIC"
@@ -636,7 +711,7 @@ class UnitValue:
         else:
             raise Exception(f"Unit {unit} invalid: Unit must be {list(UnitValue.UNITS[self.__system][self.__dimension].keys())} for {self.__system} {self.__dimension}")
 
-    def __cpy(self)  -> 'UnitValue':
+    def copy(self)  -> 'UnitValue':
         return UnitValue(self.__system, self.__dimension, self.__unit, self.value)
     
     def __temperature_handler(self, old_unit: str, new_unit: str): # add Rankine
@@ -772,5 +847,4 @@ class UnitValue:
     @property
     def get_system(self) -> str:
         return self.__system
-    
-print(UnitValue.available_units())
+