adnus 0.1.4__tar.gz → 0.1.5__tar.gz

adnus-0.1.5/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include data *.json

{adnus-0.1.4 → adnus-0.1.5}/PKG-INFO

@@ -1,19 +1,29 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: adnus
-Version: 0.1.4
+Version: 0.1.5
 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
+Home-page: https://github.com/WhiteSymmetry/adnus
 Author: Mehmet Keçeci
-Author-email: mkececi@yaani.com
-Requires-Python: >=3.11,<4.0
-Classifier: License :: OSI Approved :: MIT License
-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: hypercomplex (==0.3.4)
-Requires-Dist: numpy (>=2.3,<3.0)
+Author-email: Mehmet Keçeci <mkececi@yaani.com>
+Maintainer: Mehmet Keçeci
+Maintainer-email: mkececi@yaani.com
+License: MIT
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0.0,>=2.3.3
+Requires-Dist: hypercomplex==0.3.4
+Provides-Extra: dev
+Requires-Dist: pytest<9.0.0,>=8.4.2; extra == "dev"
+Provides-Extra: build
+Requires-Dist: setuptools<81.0.0,>=80.9.0; extra == "build"
+Requires-Dist: cython<4.0.0,>=3.1.3; extra == "build"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-python
 
 # adnus (AdNuS):  Advanced Number Systems.
 
@@ -287,4 +297,3 @@ This project is licensed under the MIT License.
 
 Contributions are welcome! Please feel free to submit a pull request or open an issue for any bugs or feature requests.
 
-

adnus-0.1.5/adnus.egg-info/PKG-INFO

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: adnus
+Version: 0.1.5
+Summary: A Python library for Advanced Number Systems (AdNuS), including Bicomplex, Neutrosophic, Hyperreal numbers, reals, Complex, Quaternion, Octonion, Sedenion, Pathion, Chingon, Routon, Voudon.
+Home-page: https://github.com/WhiteSymmetry/adnus
+Author: Mehmet Keçeci
+Author-email: Mehmet Keçeci <mkececi@yaani.com>
+Maintainer: Mehmet Keçeci
+Maintainer-email: mkececi@yaani.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0.0,>=2.3.3
+Requires-Dist: hypercomplex==0.3.4
+Provides-Extra: dev
+Requires-Dist: pytest<9.0.0,>=8.4.2; extra == "dev"
+Provides-Extra: build
+Requires-Dist: setuptools<81.0.0,>=80.9.0; extra == "build"
+Requires-Dist: cython<4.0.0,>=3.1.3; extra == "build"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-python
+
+# adnus (AdNuS):  Advanced Number Systems.
+
+---
+[![PyPI version](https://badge.fury.io/py/adnus.svg)](https://badge.fury.io/py/adnus)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.16341919.svg)](https://doi.org/10.5281/zenodo.16341919)
+
+[![WorkflowHub DOI](https://img.shields.io/badge/DOI-10.48546/workflowhub.datafile.23.1-blue)](https://doi.org/10.48546/workflowhub.datafile.23.1)
+
+[![figshare DOI](https://img.shields.io/badge/DOI-10.6084/m9.figshare.29621336-blue)](https://doi.org/10.6084/m9.figshare.29621336)
+
+[![OSF DOI](https://img.shields.io/badge/DOI-10.17605/OSF.IO/9C26Y-blue)](https://doi.org/10.17605/OSF.IO/9C26Y)
+
+[![Anaconda-Server Badge](https://anaconda.org/bilgi/adnus/badges/version.svg)](https://anaconda.org/bilgi/adnus)
+[![Anaconda-Server Badge](https://anaconda.org/bilgi/adnus/badges/latest_release_date.svg)](https://anaconda.org/bilgi/adnus)
+[![Anaconda-Server Badge](https://anaconda.org/bilgi/adnus/badges/platforms.svg)](https://anaconda.org/bilgi/adnus)
+[![Anaconda-Server Badge](https://anaconda.org/bilgi/adnus/badges/license.svg)](https://anaconda.org/bilgi/adnus)
+
+[![Open Source](https://img.shields.io/badge/Open%20Source-Open%20Source-brightgreen.svg)](https://opensource.org/)
+[![Documentation Status](https://app.readthedocs.org/projects/adnus/badge/?0.1.0=main)](https://adnus.readthedocs.io/en/latest)
+
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/-/badge)](https://www.bestpractices.dev/projects/-)
+
+[![Python CI](https://github.com/WhiteSymmetry/adnus/actions/workflows/python_ci.yml/badge.svg?branch=main)](https://github.com/WhiteSymmetry/adnus/actions/workflows/python_ci.yml)
+[![codecov](https://codecov.io/gh/WhiteSymmetry/adnus/graph/badge.svg?token=ES98M5WZFI)](https://codecov.io/gh/WhiteSymmetry/adnus)
+[![Documentation Status](https://readthedocs.org/projects/adnus/badge/?version=latest)](https://adnus.readthedocs.io/en/latest/)
+[![Binder](https://terrarium.evidencepub.io/badge_logo.svg)](https://terrarium.evidencepub.io/v2/gh/WhiteSymmetry/adnus/HEAD)
+[![PyPI version](https://badge.fury.io/py/adnus.svg)](https://badge.fury.io/py/adnus)
+[![PyPI Downloads](https://static.pepy.tech/badge/adnus)](https://pepy.tech/projects/adnus)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
+[![Linted with Ruff](https://img.shields.io/badge/Linted%20with-Ruff-green?logo=python&logoColor=white)](https://github.com/astral-sh/ruff)
+
+---
+
+<p align="left">
+    <table>
+        <tr>
+            <td style="text-align: center;">PyPI</td>
+            <td style="text-align: center;">
+                <a href="https://pypi.org/project/adnus/">
+                    <img src="https://badge.fury.io/py/adnus.svg" alt="PyPI version" height="18"/>
+                </a>
+            </td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">Conda</td>
+            <td style="text-align: center;">
+                <a href="https://anaconda.org/bilgi/adnus">
+                    <img src="https://anaconda.org/bilgi/adnus/badges/version.svg" alt="conda-forge version" height="18"/>
+                </a>
+            </td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">DOI</td>
+            <td style="text-align: center;">
+                <a href="https://doi.org/10.5281/zenodo.16341919">
+                    <img src="https://zenodo.org/badge/DOI/10.5281/zenodo.16341919.svg" alt="DOI" height="18"/>
+                </a>
+            </td>
+        </tr>
+        <tr>
+            <td style="text-align: center;">License: MIT</td>
+            <td style="text-align: center;">
+                <a href="https://opensource.org/licenses/MIT">
+                    <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License" height="18"/>
+                </a>
+            </td>
+        </tr>
+    </table>
+</p>
+
+---
+# adnus (AdNuS):  Advanced Number Systems.
+
+`adnus` is a Python library that provides an implementation of various advanced number systems. This library is designed for mathematicians, researchers, and developers who need to work with number systems beyond the standard real and complex numbers.
+
+## Features
+
+- **Harmonic and Oresme Sequences**: Functions to generate harmonic numbers and Oresme sequences.
+- **Bicomplex Numbers**: A class for bicomplex numbers with full arithmetic support.
+- **Neutrosophic Numbers**: Classes for neutrosophic numbers, including their complex and bicomplex extensions.
+- **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
+
+To install the library, clone the repository and use Poetry:
+
+```bash
+git clone https://github.com/WhiteSymmetry/adnus.git
+cd adnus
+poetry install
+```
+
+## Kullanım (Türkçe) / Usage (English)
+
+```python
+import adnus
+adnus.__version__
+```
+
+Here's a quick overview of how to use the different number systems available in `adnus`.
+
+### Bicomplex Numbers
+
+```python
+import adnus as ad
+#from adnus import BicomplexNumber
+
+z1 = ad.BicomplexNumber(1 + 2j, 3 + 4j)
+z2 = ad.BicomplexNumber(5 + 6j, 7 + 8j)
+
+print(f"Addition: {z1 + z2}")
+print(f"Multiplication: {z1 * z2}")
+```
+
+### Neutrosophic Numbers
+
+```python
+import adnus as ad
+# from adnus import NeutrosophicNumber
+
+n1 = ad.NeutrosophicNumber(1.5, 2.5)
+n2 = ad. NeutrosophicNumber(3.0, 4.0)
+
+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`:
+
+```bash
+poetry run pytest
+```
+
+---
+
+## Kurulum (Türkçe) / Installation (English)
+
+### Python ile Kurulum / Install with pip, conda, mamba
+```bash
+pip install adnus -U
+python -m pip install -U adnus
+conda install bilgi::adnus -y
+mamba install bilgi::adnus -y
+```
+
+```diff
+- pip uninstall adnus -y
++ pip install -U adnus
++ python -m pip install -U adnus
+```
+
+[PyPI](https://pypi.org/project/adnus/)
+
+### Test Kurulumu / Test Installation
+
+```bash
+pip install -i https://test.pypi.org/simple/ adnus -U
+```
+
+### Github Master Kurulumu / GitHub Master Installation
+
+**Terminal:**
+
+```bash
+pip install git+https://github.com/WhiteSymmetry/adnus.git
+```
+
+**Jupyter Lab, Notebook, Visual Studio Code:**
+
+```python
+!pip install git+https://github.com/WhiteSymmetry/adnus.git
+# or
+%pip install git+https://github.com/WhiteSymmetry/adnus.git
+```
+
+---
+
+### Development
+```bash
+# Clone the repository
+git clone https://github.com/WhiteSymmetry/adnus.git
+cd adnus
+
+# Install in development mode
+python -m pip install -ve . # Install package in development mode
+
+# Run tests
+pytest
+
+Notebook, Jupyterlab, Colab, Visual Studio Code
+!python -m pip install git+https://github.com/WhiteSymmetry/adnus.git
+```
+---
+
+## Citation
+
+If this library was useful to you in your research, please cite us. Following the [GitHub citation standards](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/about-citation-files), here is the recommended citation.
+
+### BibTeX
+
+
+### APA
+
+```
+
+Keçeci, M. (2025). adnus [Data set]. ResearchGate. https://doi.org/
+
+Keçeci, M. (2025). adnus [Data set]. OSF. https://doi.org/10.17605/OSF.IO/9C26Y
+
+Keçeci, M. (2025). adnus [Data set]. figshare. https://doi.org/10.6084/m9.figshare.29621336
+
+Keçeci, M. (2025). adnus [Data set]. WorkflowHub. https://doi.org/10.48546/workflowhub.datafile.23.1
+
+Keçeci, M. (2025). adnus. Open Science Articles (OSAs), Zenodo. https://doi.org/10.5281/zenodo.16341919
+
+```
+
+### Chicago
+
+```
+
+
+Keçeci, Mehmet. adnus [Data set]. ResearchGate, 2025. https://doi.org/
+
+Keçeci, M. (2025). <i>adnus</i> (Version 1). figshare. https://doi.org/10.6084/m9.figshare.29621336
+
+Keçeci, Mehmet. adnus [Data set]. WorkflowHub, 2025. https://doi.org/10.48546/workflowhub.datafile.23.1
+
+Keçeci, Mehmet. adnus. Open Science Articles (OSAs), Zenodo, 2025. https://doi.org/10.5281/zenodo.16341919
+
+```
+
+
+### Lisans (Türkçe) / License (English)
+
+```
+This project is licensed under the MIT License.
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a pull request or open an issue for any bugs or feature requests.
+

adnus-0.1.5/adnus.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+adnus.egg-info/PKG-INFO
+adnus.egg-info/SOURCES.txt
+adnus.egg-info/dependency_links.txt
+adnus.egg-info/requires.txt
+adnus.egg-info/top_level.txt
+tests/test_adnus.py

adnus-0.1.5/adnus.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

adnus-0.1.5/adnus.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy<3.0.0,>=2.3.3
+hypercomplex==0.3.4
+
+[build]
+setuptools<81.0.0,>=80.9.0
+cython<4.0.0,>=3.1.3
+
+[dev]
+pytest<9.0.0,>=8.4.2

adnus-0.1.5/adnus.egg-info/top_level.txt

@@ -0,0 +1 @@
+

adnus-0.1.5/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "adnus"
+version = "0.1.5"
+description = "A Python library for Advanced Number Systems (AdNuS), including Bicomplex, Neutrosophic, Hyperreal numbers, reals, Complex, Quaternion, Octonion, Sedenion, Pathion, Chingon, Routon, Voudon."
+authors = [
+    {name = "Mehmet Keçeci", email = "mkececi@yaani.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "numpy>=2.3.3,<3.0.0",
+    "hypercomplex==0.3.4"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.4.2,<9.0.0"
+]
+build = [
+    "setuptools>=80.9.0,<81.0.0",
+    "cython>=3.1.3,<4.0.0"
+]
+
+[build-system]
+requires = [
+    "setuptools>=61.0",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

adnus-0.1.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

adnus-0.1.5/setup.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import io
+import re
+from setuptools import setup, find_packages
+import sys
+
+
+setup(
+    name="adnus",
+    version="0.1.5",
+    description="adnus",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Mehmet Keçeci",
+    maintainer="Mehmet Keçeci",
+    author_email="mkececi@yaani.com",
+    maintainer_email="mkececi@yaani.com",
+    url="https://github.com/WhiteSymmetry/adnus",
+    packages=find_packages(),  # 'adnus' klasörünü otomatik bulur
+    package_data={
+        "adnus": ["__init__.py", "_version.py"]  # Gerekli dosyaları dahil et
+    },
+    install_requires=[
+        "hypercomplex",
+
+    ],
+    extras_require={
+        'test': [
+            "pytest",
+            "pytest-cov",
+        ]
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent"
+    ],
+    python_requires='>=3.10',
+    license="MIT",
+)

adnus-0.1.5/tests/test_adnus.py

@@ -0,0 +1,112 @@
+# tests/test_adnus.py
+import pytest
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from fractions import Fraction
+import math
+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
+from adnus.main import (
+    AdvancedNumber,
+    BicomplexNumber,
+    NeutrosophicNumber,
+    NeutrosophicComplexNumber,
+    NeutrosophicBicomplexNumber,
+    HyperrealNumber,
+    oresme_sequence,
+    harmonic_numbers,
+    binet_formula,
+    generate_cayley_dickson_number,
+    generate_cd_chain,
+    reals, 
+    Complex, 
+    Quaternion, 
+    Octonion, 
+    Sedenion, 
+    Pathion, 
+    Chingon, 
+    Routon, 
+    Voudon, 
+    cayley_dickson_construction, 
+    cayley_dickson_algebra
+)
+
+class TestBicomplexNumber:
+    def test_addition(self):
+        bc1 = BicomplexNumber(1 + 2j, 3 + 4j)
+        bc2 = BicomplexNumber(5 + 6j, 7 + 8j)
+        assert bc1 + bc2 == BicomplexNumber(6 + 8j, 10 + 12j)
+
+    def test_subtraction(self):
+        bc1 = BicomplexNumber(1 + 2j, 3 + 4j)
+        bc2 = BicomplexNumber(5 + 6j, 7 + 8j)
+        assert bc1 - bc2 == BicomplexNumber(-4 - 4j, -4 - 4j)
+
+    def test_multiplication(self):
+        bc1 = BicomplexNumber(1 + 1j, 1 + 1j)
+        bc2 = BicomplexNumber(1 + 1j, 1 + 1j)
+        # (1+i)(1+i) - (1+i)(1+i) = 2i - 2i = 0
+        # (1+i)(1+i) + (1+i)(1+i) = 2i + 2i = 4i
+        assert bc1 * bc2 == BicomplexNumber(0, 4j)
+
+    def test_norm(self):
+        bc = BicomplexNumber(3 + 4j, 5 + 12j) # |3+4j|=5, |5+12j|=13
+        assert math.isclose(bc.norm(), math.sqrt(5**2 + 13**2))
+
+
+class TestNeutrosophicNumber:
+    def test_addition(self):
+        n1 = NeutrosophicNumber(1.5, 2.5)
+        n2 = NeutrosophicNumber(3.0, 4.0)
+        assert n1 + n2 == NeutrosophicNumber(4.5, 6.5)
+
+    def test_multiplication(self):
+        n1 = NeutrosophicNumber(2, 3)
+        n2 = NeutrosophicNumber(4, 5)
+        # a*c = 2*4 = 8
+        # ad+bc+bd = 2*5 + 3*4 + 3*5 = 10 + 12 + 15 = 37
+        assert n1 * n2 == NeutrosophicNumber(8, 37)
+
+
+class TestNeutrosophicComplexNumber:
+    def test_addition(self):
+        nc1 = NeutrosophicComplexNumber(1 + 2j, 3 + 4j)
+        nc2 = NeutrosophicComplexNumber(5 + 6j, 7 + 8j)
+        assert nc1 + nc2 == NeutrosophicComplexNumber(6 + 8j, 10 + 12j)
+
+    def test_multiplication(self):
+        A, B = 1 + 1j, 2 + 2j
+        C, D = 3 + 3j, 4 + 4j
+        nc1 = NeutrosophicComplexNumber(A, B)
+        nc2 = NeutrosophicComplexNumber(C, D)
+        # AC
+        det_part = A * C
+        # AD + BC + BD
+        ind_part = A * D + B * C + B * D
+        assert nc1 * nc2 == NeutrosophicComplexNumber(det_part, ind_part)
+
+
+class TestNeutrosophicBicomplexNumber:
+    def test_addition(self):
+        nbc1 = NeutrosophicBicomplexNumber(BicomplexNumber(1,1j), BicomplexNumber(2,2j))
+        nbc2 = NeutrosophicBicomplexNumber(BicomplexNumber(3,3j), BicomplexNumber(4,4j))
+        result = nbc1 + nbc2
+        assert result.determinate == BicomplexNumber(4, 4j)
+        assert result.indeterminate == BicomplexNumber(6, 6j)
+
+
+class TestHelperFunctions:
+    def test_oresme_sequence(self):
+        assert oresme_sequence(3) == [1/2, 2/4, 3/8]
+        assert oresme_sequence(0) == []
+
+    def test_harmonic_numbers(self):
+        harmonics = list(harmonic_numbers(3))
+        assert harmonics == [Fraction(1, 1), Fraction(3, 2), Fraction(11, 6)]
+
+    def test_binet_formula(self):
+        # F(10) = 55
+        assert math.isclose(binet_formula(10), 55.0)
+        with pytest.raises(ValueError):
+            binet_formula(-1)

adnus-0.1.4/pyproject.toml

@@ -1,19 +0,0 @@
-[tool.poetry]
-name = "adnus"
-version = "0.1.4"
-description = "A Python library for Advanced Number Systems (AdNuS), including Bicomplex, Neutrosophic, Hyperreal numbers, reals, Complex, Quaternion, Octonion, Sedenion, Pathion, Chingon, Routon, Voudon."
-authors = ["Mehmet Keçeci <mkececi@yaani.com>"]
-license = "MIT"
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = "^3.11"
-numpy = "^2.3"
-hypercomplex = "0.3.4"
-
-[tool.poetry.dev-dependencies]
-pytest = "^8.4.1"
-
-[build-system]
-requires = ["poetry-core", "cython", "setuptools"]
-build-backend = "poetry.core.masonry.api"

adnus-0.1.4/src/adnus/__init__.py

@@ -1,59 +0,0 @@
-# src/adnus/__init__.py
-"""
-adnus (AdNuS): Advanced Number Systems.
-
-A Python library for exploring number systems beyond the standard real and complex numbers.
-"""
-
-# main.py dosyasındaki ana sınıfları ve fonksiyonları buraya import et
-from .main import (
-    AdvancedNumber,
-    BicomplexNumber,
-    NeutrosophicNumber,
-    NeutrosophicComplexNumber,
-    NeutrosophicBicomplexNumber,
-    HyperrealNumber,
-    oresme_sequence,
-    harmonic_numbers,
-    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.
-# Bu, kütüphanenizin genel arayüzünü (public API) belirlemek için iyi bir pratiktir.
-__all__ = [
-    "AdvancedNumber",
-    "BicomplexNumber",
-    "NeutrosophicNumber",
-    "NeutrosophicComplexNumber",
-    "NeutrosophicBicomplexNumber",
-    "HyperrealNumber",
-    "oresme_sequence",
-    "harmonic_numbers",
-    "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-0.1.4/src/adnus/_version.py

@@ -1,9 +0,0 @@
-# _version.py
-
-__version__ = "0.1.3"
-__license__ = "MIT"
-__description__ = "adnus (AdNuS):  Advanced Number Systems."
-__author__ = "Mehmet Keçeci"
-__url__ = "https://github.com/WhiteSymmetry/adnus"
-__docs__ = "https://WhiteSymmetry.github.io/adnus"  # Opsiyonel: Dokümantasyon linki
-__dependencies__ = ["python>=3.9"]  # Diğer bağımlılıkları da ekleyebilirsiniz

adnus-0.1.4/src/adnus/main.py

@@ -1,516 +0,0 @@
-# src/adnus/main.py
-"""
-adnus (AdNuS): A Python library for Advanced Number Systems.
-"""
-
-from __future__ import annotations
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from fractions import Fraction
-import math
-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."""
-
-    @abstractmethod
-    def __add__(self, other):
-        pass
-
-    @abstractmethod
-    def __sub__(self, other):
-        pass
-
-    @abstractmethod
-    def __mul__(self, other):
-        pass
-
-    @abstractmethod
-    def __truediv__(self, other):
-        pass
-
-    @abstractmethod
-    def __eq__(self, other) -> bool:
-        pass
-
-    @abstractmethod
-    def __repr__(self) -> str:
-        pass
-
-
-@dataclass(frozen=True)
-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
-
-    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):
-            return NotImplemented
-        return BicomplexNumber(self.z1 + other.z1, self.z2 + other.z2)
-
-    def __sub__(self, other: BicomplexNumber) -> BicomplexNumber:
-        if not isinstance(other, BicomplexNumber):
-            return NotImplemented
-        return BicomplexNumber(self.z1 - other.z1, self.z2 - other.z2)
-
-    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
-        # (z1 + z2j)(w1 + w2j) = (z1w1 - z2w2) + (z1w2 + z2w1)j
-        return BicomplexNumber(
-            self.z1 * other.z1 - self.z2 * other.z2,
-            self.z1 * other.z2 + self.z2 * other.z1
-        )
-
-    def __truediv__(self, other: BicomplexNumber) -> BicomplexNumber:
-        # 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):
-            return NotImplemented
-        return self.z1 == other.z1 and self.z2 == other.z2
-
-    def __repr__(self) -> str:
-        return f"({self.z1}) + ({self.z2})j"
-
-    def norm(self) -> float:
-        """Returns the Euclidean norm of the bicomplex number."""
-        return math.sqrt(abs(self.z1)**2 + abs(self.z2)**2)
-
-
-@dataclass(frozen=True)
-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: Union[float, int, Fraction]
-    b: Union[float, int, Fraction]
-
-    def __add__(self, other: NeutrosophicNumber) -> NeutrosophicNumber:
-        if not isinstance(other, NeutrosophicNumber):
-            return NotImplemented
-        return NeutrosophicNumber(self.a + other.a, self.b + other.b)
-
-    def __sub__(self, other: NeutrosophicNumber) -> NeutrosophicNumber:
-        if not isinstance(other, NeutrosophicNumber):
-            return NotImplemented
-        return NeutrosophicNumber(self.a - other.a, self.b - other.b)
-
-    def __mul__(self, other: NeutrosophicNumber) -> NeutrosophicNumber:
-        if not isinstance(other, NeutrosophicNumber):
-            return NotImplemented
-        # (a + bI)(c + dI) = ac + (ad + bc + bd)I
-        return NeutrosophicNumber(
-            self.a * other.a,
-            self.a * other.b + self.b * other.a + self.b * other.b
-        )
-
-    def __truediv__(self, other: NeutrosophicNumber) -> NeutrosophicNumber:
-        # 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):
-            return NotImplemented
-        return self.a == other.a and self.b == other.b
-
-    def __repr__(self) -> str:
-        return f"{self.a} + {self.b}I"
-
-
-@dataclass(frozen=True)
-class NeutrosophicComplexNumber(AdvancedNumber):
-    """
-    Represents a neutrosophic complex number z = (a + bi) + (c + di)I.
-    This can be seen as a neutrosophic number whose determinate and indeterminate
-    parts are complex numbers.
-    """
-    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):
-            return NotImplemented
-        return NeutrosophicComplexNumber(
-            self.determinate + other.determinate,
-            self.indeterminate + other.indeterminate
-        )
-
-    def __sub__(self, other: NeutrosophicComplexNumber) -> NeutrosophicComplexNumber:
-        if not isinstance(other, NeutrosophicComplexNumber):
-            return NotImplemented
-        return NeutrosophicComplexNumber(
-            self.determinate - other.determinate,
-            self.indeterminate - other.indeterminate
-        )
-
-    def __mul__(self, other: NeutrosophicComplexNumber) -> NeutrosophicComplexNumber:
-        if not isinstance(other, NeutrosophicComplexNumber):
-            return NotImplemented
-        # (A + BI)(C + DI) = AC + (AD + BC + BD)I, where A, B, C, D are complex.
-        determinate_part = self.determinate * other.determinate
-        indeterminate_part = (self.determinate * other.indeterminate +
-                              self.indeterminate * other.determinate +
-                              self.indeterminate * other.indeterminate)
-        return NeutrosophicComplexNumber(determinate_part, indeterminate_part)
-
-    def __truediv__(self, other: NeutrosophicComplexNumber) -> NeutrosophicComplexNumber:
-        # 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):
-            return NotImplemented
-        return self.determinate == other.determinate and self.indeterminate == other.indeterminate
-
-    def __repr__(self) -> str:
-        return f"({self.determinate}) + ({self.indeterminate})I"
-
-
-@dataclass(frozen=True)
-class NeutrosophicBicomplexNumber(AdvancedNumber):
-    """
-    Represents a neutrosophic bicomplex number z = (z1 + z2j) + (w1 + w2j)I.
-    This can be seen as a neutrosophic number whose determinate and indeterminate
-    parts are bicomplex numbers.
-    """
-    determinate: BicomplexNumber
-    indeterminate: BicomplexNumber
-
-    def __add__(self, other: NeutrosophicBicomplexNumber) -> NeutrosophicBicomplexNumber:
-        if not isinstance(other, NeutrosophicBicomplexNumber):
-            return NotImplemented
-        return NeutrosophicBicomplexNumber(
-            self.determinate + other.determinate,
-            self.indeterminate + other.indeterminate
-        )
-
-    def __sub__(self, other: NeutrosophicBicomplexNumber) -> NeutrosophicBicomplexNumber:
-        if not isinstance(other, NeutrosophicBicomplexNumber):
-            return NotImplemented
-        return NeutrosophicBicomplexNumber(
-            self.determinate - other.determinate,
-            self.indeterminate - other.indeterminate
-        )
-
-    def __mul__(self, other: NeutrosophicBicomplexNumber) -> NeutrosophicBicomplexNumber:
-        if not isinstance(other, NeutrosophicBicomplexNumber):
-            return NotImplemented
-        # (A + BI)(C + DI) = AC + (AD + BC + BD)I, where A, B, C, D are bicomplex.
-        determinate_part = self.determinate * other.determinate
-        indeterminate_part = (self.determinate * other.indeterminate +
-                              self.indeterminate * other.determinate +
-                              self.indeterminate * other.indeterminate)
-        return NeutrosophicBicomplexNumber(determinate_part, indeterminate_part)
-
-    def __truediv__(self, other: NeutrosophicBicomplexNumber) -> NeutrosophicBicomplexNumber:
-        # 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):
-            return NotImplemented
-        return self.determinate == other.determinate and self.indeterminate == other.indeterminate
-
-    def __repr__(self) -> str:
-        return f"({self.determinate}) + ({self.indeterminate})I"
-
-
-@dataclass(frozen=True)
-class HyperrealNumber(AdvancedNumber):
-    """
-    Represents a hyperreal number as a sequence of real numbers.
-    Note: This is a conceptual implementation. A full implementation requires
-    a non-principal ultrafilter, which is non-constructive.
-    """
-    sequence_func: callable
-
-    def __post_init__(self):
-        if not callable(self.sequence_func):
-            raise TypeError("sequence_func must be a callable function.")
-
-    def __add__(self, other: HyperrealNumber) -> HyperrealNumber:
-        if not isinstance(other, HyperrealNumber):
-            return NotImplemented
-        return HyperrealNumber(lambda n: self.sequence_func(n) + other.sequence_func(n))
-
-    def __sub__(self, other: HyperrealNumber) -> HyperrealNumber:
-        if not isinstance(other, HyperrealNumber):
-            return NotImplemented
-        return HyperrealNumber(lambda n: self.sequence_func(n) - other.sequence_func(n))
-
-    def __mul__(self, other: HyperrealNumber) -> HyperrealNumber:
-        if not isinstance(other, HyperrealNumber):
-            return NotImplemented
-        return HyperrealNumber(lambda n: self.sequence_func(n) * other.sequence_func(n))
-
-    def __truediv__(self, other: HyperrealNumber) -> HyperrealNumber:
-        # Avoid division by zero in the sequence
-        def div_func(n):
-            denominator = other.sequence_func(n)
-            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
-            return self.sequence_func(n) / denominator
-        return HyperrealNumber(div_func)
-
-    def __eq__(self, other) -> bool:
-        # Equality for hyperreals means the set of indices where sequences are equal
-        # belongs to the ultrafilter. This cannot be implemented directly.
-        raise NotImplementedError("Equality for hyperreal numbers cannot be determined constructively.")
-
-    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:
-    """
-    Generates 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:
-    """
-    Generates 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
-# =============================================
-
-def oresme_sequence(n_terms: int) -> List[float]:
-    """Generates the first n terms of the Oresme sequence (n / 2^n)."""
-    if n_terms <= 0:
-        return []
-    return [n / (2 ** n) for n in range(1, n_terms + 1)]
-
-
-def harmonic_numbers(n_terms: int) -> Generator[Fraction, None, None]:
-    """
-    Generates the first n harmonic numbers (H_n = 1 + 1/2 + ... + 1/n)
-    as exact fractions.
-    """
-    if n_terms <= 0:
-        return
-    current_sum = Fraction(0)
-    for i in range(1, n_terms + 1):
-        current_sum += Fraction(1, i)
-        yield current_sum
-
-
-def binet_formula(n: int) -> float:
-    """Calculates the nth Fibonacci number using Binet's formula."""
-    if n < 0:
-        raise ValueError("The Fibonacci sequence is not defined for negative integers.")
-    sqrt5 = math.sqrt(5)
-    phi = (1 + sqrt5) / 2
-    return (phi**n - (1 - phi)**n) / sqrt5
-
-# =============================================
-# Example Usage
-# =============================================
-
-if __name__ == "__main__":
-    # Generate 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)
-    
-    # Generate 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)
-    
-    # Generate 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}")
-    
-    
-    # Generate 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)