adnus 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

adnus/__init__.py

@@ -15,7 +15,20 @@ from .main import (
     HyperrealNumber,
     oresme_sequence,
     harmonic_numbers,
-    binet_formula
+    binet_formula,
+    generate_cayley_dickson_number,
+    generate_cd_chain,
+    reals, 
+    Complex, 
+    Quaternion, 
+    Octonion, 
+    Sedenion, 
+    Pathion, 
+    Chingon, 
+    Routon, 
+    Voudon, 
+    cayley_dickson_construction, 
+    cayley_dickson_algebra
 )
 
 # __all__ listesi, "from adnus import *" komutu kullanıldığında nelerin import edileceğini tanımlar.
@@ -29,5 +42,18 @@ __all__ = [
     "HyperrealNumber",
     "oresme_sequence",
     "harmonic_numbers",
-    "binet_formula"
+    "binet_formula",
+    "generate_cayley_dickson_number",
+    "generate_cd_chain",
+    "reals", 
+    "Complex", 
+    "Quaternion", 
+    "Octonion", 
+    "Sedenion", 
+    "Pathion", 
+    "Chingon", 
+    "Routon", 
+    "Voudon", 
+    "cayley_dickson_construction", 
+    "cayley_dickson_algebra"
 ]

adnus/_version.py

@@ -1,6 +1,6 @@
 # _version.py
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 __license__ = "MIT"
 __description__ = "adnus (AdNuS):  Advanced Number Systems."
 __author__ = "Mehmet Keçeci"

adnus/main.py

@@ -8,7 +8,8 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from fractions import Fraction
 import math
-from typing import List, Union, Generator, Tuple
+from typing import List, Union, Generator, Tuple, Any
+from hypercomplex import reals, Complex, Quaternion, Octonion, Sedenion, Pathion, Chingon, Routon, Voudon, cayley_dickson_construction, cayley_dickson_algebra
 
 class AdvancedNumber(ABC):
     """Abstract Base Class for advanced number systems."""
@@ -44,8 +45,18 @@ class BicomplexNumber(AdvancedNumber):
     Represents a bicomplex number z = z1 + z2j, where z1 and z2 are complex
     numbers and j^2 = -1, but j is an independent imaginary unit from i.
     """
-    z1: complex
-    z2: complex
+    z1: Complex
+    z2: Complex
+
+    def __init__(self, z1: Union[Complex, complex, float, int], 
+                 z2: Union[Complex, complex, float, int]):
+        # Convert inputs to Complex type if needed
+        if not isinstance(z1, Complex):
+            z1 = Complex(z1)
+        if not isinstance(z2, Complex):
+            z2 = Complex(z2)
+        object.__setattr__(self, 'z1', z1)
+        object.__setattr__(self, 'z2', z2)
 
     def __add__(self, other: BicomplexNumber) -> BicomplexNumber:
         if not isinstance(other, BicomplexNumber):
@@ -57,8 +68,8 @@ class BicomplexNumber(AdvancedNumber):
             return NotImplemented
         return BicomplexNumber(self.z1 - other.z1, self.z2 - other.z2)
 
-    def __mul__(self, other: Union[BicomplexNumber, float, int, complex]) -> BicomplexNumber:
-        if isinstance(other, (float, int, complex)):
+    def __mul__(self, other: Union[BicomplexNumber, float, int, complex, Complex]) -> BicomplexNumber:
+        if isinstance(other, (float, int, complex, Complex)):
             return BicomplexNumber(self.z1 * other, self.z2 * other)
         if not isinstance(other, BicomplexNumber):
             return NotImplemented
@@ -69,10 +80,26 @@ class BicomplexNumber(AdvancedNumber):
         )
 
     def __truediv__(self, other: BicomplexNumber) -> BicomplexNumber:
-        # Division is more complex and requires the inverse.
-        # For simplicity, this is left as an exercise. A common method involves
-        # multiplying by the conjugate and dividing by the squared modulus.
-        raise NotImplementedError("Division for bicomplex numbers is not implemented.")
+        # Division using the conjugate approach
+        if isinstance(other, (float, int, complex, Complex)):
+            return BicomplexNumber(self.z1 / other, self.z2 / other)
+        
+        if not isinstance(other, BicomplexNumber):
+            return NotImplemented
+        
+        # Compute the conjugate of the denominator
+        conjugate = BicomplexNumber(other.z1, -other.z2)
+        
+        # Multiply numerator and denominator by conjugate
+        numerator = self * conjugate
+        denominator = other * conjugate
+        
+        # Denominator should be a real number (only z1 component)
+        if abs(denominator.z2.real) > 1e-10 or abs(denominator.z2.imag) > 1e-10:
+            raise ValueError("Division resulted in non-real denominator")
+            
+        return BicomplexNumber(numerator.z1 / denominator.z1.real, 
+                              numerator.z2 / denominator.z1.real)
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, BicomplexNumber):
@@ -93,8 +120,8 @@ class NeutrosophicNumber(AdvancedNumber):
     Represents a neutrosophic number z = a + bI, where 'a' is the determinate part,
     'b' is the indeterminate part, and I is the indeterminacy, satisfying I^2 = I.
     """
-    a: float
-    b: float
+    a: Union[float, int, Fraction]
+    b: Union[float, int, Fraction]
 
     def __add__(self, other: NeutrosophicNumber) -> NeutrosophicNumber:
         if not isinstance(other, NeutrosophicNumber):
@@ -116,8 +143,23 @@ class NeutrosophicNumber(AdvancedNumber):
         )
 
     def __truediv__(self, other: NeutrosophicNumber) -> NeutrosophicNumber:
-        # Division is not uniquely defined without further constraints.
-        raise NotImplementedError("Division for neutrosophic numbers is not implemented.")
+        # Division using the conjugate approach
+        if not isinstance(other, NeutrosophicNumber):
+            return NotImplemented
+        
+        # Compute conjugate (a - bI)
+        conjugate = NeutrosophicNumber(other.a, -other.b)
+        
+        # Multiply numerator and denominator by conjugate
+        numerator = self * conjugate
+        denominator = other * conjugate
+        
+        # Denominator should be a real number (only a component)
+        if abs(denominator.b) > 1e-10:
+            raise ValueError("Division resulted in non-real denominator")
+            
+        return NeutrosophicNumber(numerator.a / denominator.a, 
+                                 numerator.b / denominator.a)
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, NeutrosophicNumber):
@@ -135,8 +177,18 @@ class NeutrosophicComplexNumber(AdvancedNumber):
     This can be seen as a neutrosophic number whose determinate and indeterminate
     parts are complex numbers.
     """
-    determinate: complex
-    indeterminate: complex
+    determinate: Complex
+    indeterminate: Complex
+
+    def __init__(self, determinate: Union[Complex, complex, float, int], 
+                 indeterminate: Union[Complex, complex, float, int]):
+        # Convert inputs to Complex type if needed
+        if not isinstance(determinate, Complex):
+            determinate = Complex(determinate)
+        if not isinstance(indeterminate, Complex):
+            indeterminate = Complex(indeterminate)
+        object.__setattr__(self, 'determinate', determinate)
+        object.__setattr__(self, 'indeterminate', indeterminate)
 
     def __add__(self, other: NeutrosophicComplexNumber) -> NeutrosophicComplexNumber:
         if not isinstance(other, NeutrosophicComplexNumber):
@@ -165,7 +217,23 @@ class NeutrosophicComplexNumber(AdvancedNumber):
         return NeutrosophicComplexNumber(determinate_part, indeterminate_part)
 
     def __truediv__(self, other: NeutrosophicComplexNumber) -> NeutrosophicComplexNumber:
-        raise NotImplementedError("Division for neutrosophic complex numbers is not implemented.")
+        # Division using the conjugate approach
+        if not isinstance(other, NeutrosophicComplexNumber):
+            return NotImplemented
+        
+        # Compute conjugate (C - DI)
+        conjugate = NeutrosophicComplexNumber(other.determinate, -other.indeterminate)
+        
+        # Multiply numerator and denominator by conjugate
+        numerator = self * conjugate
+        denominator = other * conjugate
+        
+        # Denominator should be a complex number (only determinate part)
+        if abs(denominator.indeterminate.real) > 1e-10 or abs(denominator.indeterminate.imag) > 1e-10:
+            raise ValueError("Division resulted in non-complex denominator")
+            
+        return NeutrosophicComplexNumber(numerator.determinate / denominator.determinate, 
+                                        numerator.indeterminate / denominator.determinate)
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, NeutrosophicComplexNumber):
@@ -213,7 +281,24 @@ class NeutrosophicBicomplexNumber(AdvancedNumber):
         return NeutrosophicBicomplexNumber(determinate_part, indeterminate_part)
 
     def __truediv__(self, other: NeutrosophicBicomplexNumber) -> NeutrosophicBicomplexNumber:
-        raise NotImplementedError("Division for neutrosophic bicomplex numbers is not implemented.")
+        # Division using the conjugate approach
+        if not isinstance(other, NeutrosophicBicomplexNumber):
+            return NotImplemented
+        
+        # Compute conjugate (C - DI)
+        conjugate = NeutrosophicBicomplexNumber(other.determinate, -other.indeterminate)
+        
+        # Multiply numerator and denominator by conjugate
+        numerator = self * conjugate
+        denominator = other * conjugate
+        
+        # Denominator should be a bicomplex number (only determinate part)
+        if abs(denominator.indeterminate.z1.real) > 1e-10 or abs(denominator.indeterminate.z1.imag) > 1e-10 or \
+           abs(denominator.indeterminate.z2.real) > 1e-10 or abs(denominator.indeterminate.z2.imag) > 1e-10:
+            raise ValueError("Division resulted in non-bicomplex denominator")
+            
+        return NeutrosophicBicomplexNumber(numerator.determinate / denominator.determinate, 
+                                          numerator.indeterminate / denominator.determinate)
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, NeutrosophicBicomplexNumber):
@@ -256,7 +341,7 @@ class HyperrealNumber(AdvancedNumber):
         # Avoid division by zero in the sequence
         def div_func(n):
             denominator = other.sequence_func(n)
-            if denominator == 0:
+            if abs(denominator) < 1e-10:
                 # This case needs a more rigorous definition based on the ultrafilter.
                 # For simplicity, we return 0, but this is not generally correct.
                 return 0
@@ -271,6 +356,63 @@ class HyperrealNumber(AdvancedNumber):
     def __repr__(self) -> str:
         return f"Hyperreal(sequence: {self.sequence_func(1)}, {self.sequence_func(2)}, ...)"
 
+# =============================================
+# Cayley-Dickson Construction Wrapper
+# =============================================
+
+def generate_cayley_dickson_number(dimension: int, *components: float) -> Any:
+    """
+    Creates a hypercomplex number using the Cayley-Dickson construction.
+    
+    Args:
+        dimension: The dimension of the hypercomplex number (2^n)
+        *components: The components of the number
+        
+    Returns:
+        A hypercomplex number of the specified dimension
+    """
+    if dimension not in [1, 2, 4, 8, 16, 32, 64, 128, 256]:
+        raise ValueError("Dimension must be a power of 2 up to 256")
+    
+    if len(components) != dimension:
+        raise ValueError(f"Expected {dimension} components, got {len(components)}")
+    
+    # Map dimension to the appropriate hypercomplex class
+    dimension_map = {
+        1: reals,
+        2: Complex,
+        4: Quaternion,
+        8: Octonion,
+        16: Sedenion,
+        32: Pathion,
+        64: Chingon,
+        128: Routon,
+        256: Voudon
+    }
+    
+    return dimension_map[dimension](*components)
+
+# =============================================
+# Cayley-Dickson Construction Helper
+# =============================================
+
+def generate_cd_chain(max_level: int = 8) -> List:
+    """
+    Creates a chain of Cayley-Dickson algebras up to the specified level.
+    
+    Args:
+        max_level: Maximum level of the Cayley-Dickson construction
+        
+    Returns:
+        List of hypercomplex number types [CD0, CD1, CD2, ..., CD_max_level]
+    """
+    CD = [reals()]  # CD0 = Real numbers
+    
+    for i in range(max_level):
+        CD.append(cayley_dickson_construction(CD[-1]))
+    
+    return CD
+
 
 # =============================================
 # Helper Functions
@@ -303,3 +445,76 @@ def binet_formula(n: int) -> float:
     sqrt5 = math.sqrt(5)
     phi = (1 + sqrt5) / 2
     return (phi**n - (1 - phi)**n) / sqrt5
+
+# =============================================
+# Example Usage
+# =============================================
+
+if __name__ == "__main__":
+    # Create Cayley-Dickson chain
+    CD = generate_cd_chain(8)  # Up to 256 dimensions (CD0 to CD8)
+    
+    # CD chain mapping:
+    # CD[0] = Real numbers (1 dimension)
+    # CD[1] = Complex numbers (2 dimensions)
+    # CD[2] = Quaternions (4 dimensions)
+    # CD[3] = Octonions (8 dimensions)
+    # CD[4] = Sedenions (16 dimensions)
+    # CD[5] = Pathions (32 dimensions)
+    # CD[6] = Chingons (64 dimensions)
+    # CD[7] = Routons (128 dimensions)
+    # CD[8] = Voudons (256 dimensions)
+    
+    # Create an octonion (8 dimensions)
+    octonion = CD[3](1, 0, 2, 0, 3)  # Missing components auto-filled with zeros
+    print(f"Octonion: {octonion}")  # -> (1 0 2 0 3 0 0 0)
+    
+    # Create other types
+    complex_num = CD[1](1, 2)  # Complex number
+    quaternion = CD[2](1, 2, 3, 4)  # Quaternion
+    sedenion = CD[4](*range(1, 17))  # Sedenion with values 1-16
+    
+    print(f"Complex: {complex_num}")
+    print(f"Quaternion: {quaternion}")
+    print(f"Sedenion: {sedenion}")
+    
+    # Or use the predefined types directly
+    octonion2 = Octonion(1, 0, 2, 0, 3)
+    print(f"Octonion (predefined): {octonion2}")
+    
+    # Bicomplex number example
+    bc1 = BicomplexNumber(Complex(1, 2), Complex(3, 4))
+    bc2 = BicomplexNumber(Complex(5, 6), Complex(7, 8))
+    print(f"Bicomplex multiplication: {bc1} * {bc2} = {bc1 * bc2}")
+
+
+    # Example usage of hypercomplex numbers
+    c1 = Complex(1, 2)
+    c2 = Complex(3, 4)
+    print(f"Complex numbers: {c1} + {c2} = {c1 + c2}")
+    
+    q1 = Quaternion(1, 2, 3, 4)
+    q2 = Quaternion(5, 6, 7, 8)
+    print(f"Quaternions: {q1} * {q2} = {q1 * q2}")
+    
+    
+    # Create higher dimension numbers using cayley_dickson_algebra
+    octonion_type = cayley_dickson_algebra(3)  # 2^3 = 8 dimensions
+    octonion = octonion_type(1, 2, 3, 4, 5, 6, 7, 8)
+    print(f"Octonion: {octonion}")
+    
+    # Or use the predefined types
+    sedenion = Sedenion(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
+    print(f"Sedenion: {sedenion}") # 2^4 = 16 dimensions
+
+    pathion = Pathion(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32)
+    print(f"Pathion: {pathion}") # 2^5 = 32 dimensions
+
+    Real=reals()
+    print(Real(4))               # -> (4)
+    C = cayley_dickson_construction(Complex)
+    print(C(3-7j))               # -> (3 -7)
+    CD4 = cayley_dickson_construction(CD[1])
+    print(CD4(.1, -2.2, 3.3e3))  # -> (0.1 -2.2 3300 0)
+    CD[3] = cayley_dickson_construction(CD[2])
+    print(CD[3](1, 0, 2, 0, 3))  # -> (1 0 2 0 3 0 0 0)

{adnus-0.1.1.dist-info → adnus-0.1.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: adnus
-Version: 0.1.1
-Summary: A Python library for Advanced Number Systems (AdNuS), including Bicomplex, Neutrosophic, and Hyperreal numbers.
+Version: 0.1.2
+Summary: A Python library for Advanced Number Systems (AdNuS), including Bicomplex, Neutrosophic, Hyperreal numbers, reals, Complex, Quaternion, Octonion, Sedenion, Pathion, Chingon, Routon, Voudon.
 License: MIT
 Author: Mehmet Keçeci
 Author-email: mkececi@yaani.com
@@ -11,7 +11,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: numpy (>=2.3.2,<3.0.0)
+Requires-Dist: hypercomplex (==0.3.4)
+Requires-Dist: numpy (>=2.3,<3.0)
 Description-Content-Type: text/markdown
 
 # adnus (AdNuS):  Advanced Number Systems.
@@ -100,6 +101,15 @@ Description-Content-Type: text/markdown
 - **Hyperreal Numbers**: A conceptual implementation of hyperreal numbers.
 - **Extensible Design**: Built with an abstract base class to easily extend and add new number systems.
 - **Fully Typed**: The library is fully type-hinted for better code quality and maintainability.
+- **Real numbers**
+- **Complex numbers**
+- **Quaternion numbers**
+- **Octonion numbers**
+- **Sedenion numbers**
+- **Pathion numbers**
+- **Chingon numbers**
+- **Routon numbers**
+- **Voudon  numbers**
 
 ## Installation
 
@@ -146,6 +156,19 @@ print(f"Addition: {n1 + n2}")
 print(f"Multiplication: {n1 * n2}")
 ```
 
+```python
+import adnus as ad 
+C = cayley_dickson_construction(ad.Complex)
+print(C(3-7j))
+```
+
+```python
+import adnus as ad 
+q1 = ad.Quaternion(1, 2, 3, 4)
+q2 = ad.Quaternion(5, 6, 7, 8)
+print(f"Quaternions: {q1} * {q2} = {q1 * q2}")
+```
+
 ## Running Tests
 
 To ensure everything is working correctly, you can run the included tests using `pytest`:
@@ -236,6 +259,8 @@ Keçeci, M. (2025). adnus [Data set]. WorkflowHub. https://doi.org/10.48546/work
 
 Keçeci, M. (2025). adnus. Open Science Articles (OSAs), Zenodo. https://doi.org/10.5281/zenodo.16341919
 
+```
+
 ### Chicago
 
 ```

adnus-0.1.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+adnus/__init__.py,sha256=kTimUAw-wKQMWgyjXx5u7aA6uQ6itzSO_0UfjKY6Yoc,1439
+adnus/_version.py,sha256=OZVSyDN1PQ7mCrsn9lH_hK_n4AsLIoshK55HG5_i_qw,370
+adnus/main.py,sha256=i4Sq0dEWNcjLoGIU46OdAbnlWV27aM0gGMG-PlpCDBk,20216
+adnus-0.1.2.dist-info/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
+adnus-0.1.2.dist-info/METADATA,sha256=UyuHsOcHnMIyycNSJZwAFgltspzTMOcc5jXiZeXMSY8,9600
+adnus-0.1.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+adnus-0.1.2.dist-info/RECORD,,

adnus-0.1.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-adnus/__init__.py,sha256=H5pQpNmEf921qquSDg5B2Mo7Sxt8ZkxyDk9iWNymOV4,917
-adnus/_version.py,sha256=guuWvmmZ0FRRBsgXWGYvookl-2X3wjLCCuYAU_BChMk,370
-adnus/main.py,sha256=uyo7DeDXDkzUvC_P8ZXbkTeFqN8Pt7cqjPsQ6pWLcnQ,11825
-adnus-0.1.1.dist-info/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
-adnus-0.1.1.dist-info/METADATA,sha256=8nbpaVhyhnDmx18k-mbuqHFpIibjTYI_brNmjKLzjLw,9046
-adnus-0.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-adnus-0.1.1.dist-info/RECORD,,