kececinumbers 0.4.7__tar.gz → 0.4.8__tar.gz

{kececinumbers-0.4.7/kececinumbers.egg-info → kececinumbers-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.4.7
+Version: 0.4.8
 Summary: Keçeci Numbers: An Exploration of a Dynamic Sequence Across Diverse Number Sets
 Home-page: https://github.com/WhiteSymmetry/kececinumbers
 Author: Mehmet Keçeci

kececinumbers-0.4.8/docs/conf.py

@@ -0,0 +1,34 @@
+# Project Information
+project = 'kececinumbers'
+author = 'Mehmet Keçeci'
+copyright = '2025, Mehmet Keçeci'
+
+# Version Management
+# from setuptools_scm import get_version
+# version = get_version(root='..', relative_to=__file__)
+# Sürüm Bilgisi (setuptools_scm kullanmıyorsanız sabit olarak tanımlayın)
+# Gerçek sürümü modülden al (eğer mümkünse)
+try:
+    from kececinumbers import __version__
+    version = __version__
+    release = __version__
+except (ImportError, AttributeError) as e:
+    print(f"Warning: Could not import __version__ from kececinumbers: {e}")
+    # Varsayılan değerler korunur
+#version = '0.4.1'  # Replace with your actual version number
+#release = version
+
+# General Configuration
+master_doc = 'index'
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.napoleon'
+]
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# HTML Output Configuration
+html_theme = 'sphinx_rtd_theme'
+html_static_path = ['_static']
+html_logo = '_static/logo.png'  # Optional: Add your project logo
+html_favicon = '_static/favicon.ico'  # Optional: Add a favicon

{kececinumbers-0.4.7 → kececinumbers-0.4.8}/kececinumbers/__init__.py

@@ -21,7 +21,7 @@ import warnings
     # importlib.reload(kececinumbers) # F821 undefined name 'kececinumbers'
 
 # Paket sürüm numarası
-__version__ = "0.4.6"
+__version__ = "0.4.7"
 __author__ = "Mehmet Keçeci"
 __email__ = "mkececi@yaani.com"
 

{kececinumbers-0.4.7 → kececinumbers-0.4.8/kececinumbers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.4.7
+Version: 0.4.8
 Summary: Keçeci Numbers: An Exploration of a Dynamic Sequence Across Diverse Number Sets
 Home-page: https://github.com/WhiteSymmetry/kececinumbers
 Author: Mehmet Keçeci

{kececinumbers-0.4.7 → kececinumbers-0.4.8}/kececinumbers.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 pyproject.toml
 setup.cfg
 setup.py
+docs/conf.py
 kececinumbers/__init__.py
 kececinumbers/_version.py
 kececinumbers/kececinumbers.py

kececinumbers-0.4.8/kececinumbers.egg-info/top_level.txt

@@ -0,0 +1,6 @@
+dist
+docs
+examples
+kececinumbers
+recipe
+tests

{kececinumbers-0.4.7 → kececinumbers-0.4.8}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kececinumbers"
-version = "0.4.7"
+version = "0.4.8"
 
 # Diğer proje bilgileri (isteğe bağlı ama tavsiye edilir)
 authors = [
@@ -44,6 +44,9 @@ test = [
     "sympy",
 ]
 
+[tool.setuptools.packages.find]
+where = ["."]
+
 [project.urls]
 "Homepage" = "https://github.com/WhiteSymmetry/kececinumbers"
 "Bug Tracker" = "https://github.com/WhiteSymmetry/kececinumbers/issues"

{kececinumbers-0.4.7 → kececinumbers-0.4.8}/setup.py

@@ -11,6 +11,9 @@ import sys
 with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
+with open("kececinumbers/kececinumbers.py", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
 sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
 
 

kececinumbers-0.4.8/tests/test_sample.py

@@ -0,0 +1,283 @@
+# -*- coding: utf-8 -*-
+# test_sample.py
+"""
+Comprehensive unit tests for the kececinumbers module.
+Tests core functionality, number type generation, and mathematical properties.
+"""
+
+import unittest
+import numpy as np
+import quaternion
+from kececinumbers import (
+    # Constants
+    TYPE_POSITIVE_REAL,
+    TYPE_NEGATIVE_REAL,
+    TYPE_COMPLEX,
+    TYPE_FLOAT,
+    TYPE_RATIONAL,
+    TYPE_QUATERNION,
+    TYPE_NEUTROSOPHIC,
+    TYPE_NEUTROSOPHIC_COMPLEX,
+    TYPE_HYPERREAL,
+    TYPE_BICOMPLEX,
+    TYPE_NEUTROSOPHIC_BICOMPLEX,
+
+    # Core generator
+    unified_generator,
+
+    # Helper functions
+    is_prime,
+    _get_integer_representation,
+    find_kececi_prime_number,
+
+    # Custom classes
+    NeutrosophicNumber,
+    NeutrosophicComplexNumber,
+    HyperrealNumber,
+    BicomplexNumber,
+    NeutrosophicBicomplexNumber,
+)
+
+
+class TestKececiNumbers(unittest.TestCase):
+
+    def setUp(self):
+        """Run before each test."""
+        self.iterations = 10
+
+    def test_positive_real_generation(self):
+        """Test sequence generation for positive real numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_POSITIVE_REAL,
+            start_input_raw="5",
+            add_input_base_scalar=3.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], int)
+        self.assertGreaterEqual(seq[0], 0)
+
+    def test_negative_real_generation(self):
+        """Test sequence generation for negative real numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_NEGATIVE_REAL,
+            start_input_raw="-7",
+            add_input_base_scalar=2.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], int)
+        self.assertLessEqual(seq[0], 0)
+
+    def test_float_generation(self):
+        """Test sequence generation for float numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_FLOAT,
+            start_input_raw="3.14",
+            add_input_base_scalar=1.5,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], float)
+
+    def test_complex_generation(self):
+        """Test sequence generation for complex numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_COMPLEX,
+            start_input_raw="2+3j",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], complex)
+        self.assertEqual(seq[0].real, 2.0)
+        self.assertEqual(seq[0].imag, 3.0)
+
+    def test_rational_generation(self):
+        """Test sequence generation for rational numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_RATIONAL,
+            start_input_raw="7/3",
+            add_input_base_scalar=2.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        from fractions import Fraction
+        self.assertIsInstance(seq[0], Fraction)
+        self.assertEqual(str(seq[0]), "7/3")
+
+    def test_quaternion_generation(self):
+        """Test sequence generation for quaternions."""
+        seq = unified_generator(
+            kececi_type=TYPE_QUATERNION,
+            start_input_raw="1+2i-3j+k",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], np.quaternion)
+        # Check if parsing worked
+        q = seq[0]
+        self.assertAlmostEqual(q.w, 1.0)
+        self.assertAlmostEqual(q.x, 2.0)
+        self.assertAlmostEqual(q.y, -3.0)
+        self.assertAlmostEqual(q.z, 1.0)
+
+    def test_neutrosophic_generation(self):
+        """Test sequence generation for neutrosophic numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_NEUTROSOPHIC,
+            start_input_raw="5+2I",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], NeutrosophicNumber)
+        self.assertEqual(seq[0].a, 5.0)
+        self.assertEqual(seq[0].b, 2.0)
+
+    def test_neutrosophic_complex_generation(self):
+        """Test sequence generation for neutrosophic complex numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_NEUTROSOPHIC_COMPLEX,
+            start_input_raw="1-2j",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], NeutrosophicComplexNumber)
+        self.assertAlmostEqual(seq[0].real, 1.0)
+        self.assertAlmostEqual(seq[0].imag, -2.0)
+        self.assertAlmostEqual(seq[0].indeterminacy, 0.0)
+
+    def test_hyperreal_generation(self):
+        """Test sequence generation for hyperreal numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_HYPERREAL,
+            start_input_raw="5+3e",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], HyperrealNumber)
+        self.assertGreater(len(seq[0].sequence), 0)
+
+    def test_bicomplex_generation(self):
+        """Test sequence generation for bicomplex numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_BICOMPLEX,
+            start_input_raw="2+1j",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], BicomplexNumber)
+        z1, z2 = seq[0].z1, seq[0].z2
+        self.assertIsInstance(z1, complex)
+        self.assertIsInstance(z2, complex)
+
+    def test_neutrosophic_bicomplex_generation(self):
+        """Test sequence generation for neutrosophic bicomplex numbers."""
+        seq = unified_generator(
+            kececi_type=TYPE_NEUTROSOPHIC_BICOMPLEX,
+            start_input_raw="1+2j",
+            add_input_base_scalar=1.0,
+            iterations=self.iterations
+        )
+        self.assertTrue(len(seq) > 0)
+        self.assertIsInstance(seq[0], NeutrosophicBicomplexNumber)
+
+    def test_get_integer_representation(self):
+        """Test _get_integer_representation for various types."""
+        self.assertEqual(_get_integer_representation(42), 42)
+        self.assertEqual(_get_integer_representation(-15), 15)
+        self.assertEqual(_get_integer_representation(3.14), 3)
+        self.assertEqual(_get_integer_representation(complex(5, 3)), 5)
+        self.assertEqual(_get_integer_representation(np.quaternion(7, 1, 2, 3)), 7)
+        self.assertEqual(_get_integer_representation(NeutrosophicNumber(9.5, 2.1)), 9)
+        self.assertEqual(_get_integer_representation(HyperrealNumber([10.1, 11.2])), 10)
+        self.assertEqual(_get_integer_representation(None), None)
+
+    def test_is_prime_with_supported_types(self):
+        """Test is_prime function with various number types."""
+        # Prime numbers
+        self.assertTrue(is_prime(2))
+        self.assertTrue(is_prime(3))
+        self.assertTrue(is_prime(5))
+        self.assertTrue(is_prime(7))
+
+        # Non-prime
+        self.assertFalse(is_prime(1))
+        self.assertFalse(is_prime(4))
+        self.assertFalse(is_prime(6))
+
+        # Complex: uses real part
+        self.assertTrue(is_prime(complex(3, 4)))  # 3 is prime
+        self.assertFalse(is_prime(complex(4, 5)))  # 4 is not prime
+
+        # Quaternion: uses scalar part
+        q = np.quaternion(5, 1, 2, 3)
+        self.assertTrue(is_prime(q))  # 5 is prime
+
+        # Neutrosophic: uses 'a' component
+        n = NeutrosophicNumber(7.0, 1.0)
+        self.assertTrue(is_prime(n))  # 7 is prime
+
+        # Invalid input
+        self.assertFalse(is_prime("invalid"))
+        self.assertFalse(is_prime(None))
+
+    def test_find_kececi_prime_number(self):
+        """Test if a repeating prime is correctly identified."""
+        # Simulate a sequence where 3 appears multiple times
+        mock_sequence = [
+            2, 3, 4, 5, 3, 6, 3  # 3 repeats
+        ]
+        kpn = find_kececi_prime_number(mock_sequence)
+        self.assertEqual(kpn, 3)
+
+        # No prime repeats
+        mock_sequence2 = [2, 3, 5, 7]  # all prime but no repeat
+        kpn2 = find_kececi_prime_number(mock_sequence2)
+        self.assertIsNone(kpn2)
+
+        # Empty sequence
+        self.assertIsNone(find_kececi_prime_number([]))
+
+    def test_divisibility_and_logic_flow(self):
+        """Basic check that generator does not crash and produces expected types."""
+        seq = unified_generator(
+            kececi_type=TYPE_POSITIVE_REAL,
+            start_input_raw="10",
+            add_input_base_scalar=2.0,
+            iterations=5
+        )
+        self.assertGreater(len(seq), 5)
+        # Should include integers, possibly divided by 2 or 3
+        for item in seq:
+            self.assertIsInstance(item, int)
+
+    def test_edge_case_empty_start(self):
+        """Test handling of invalid or empty input."""
+        seq = unified_generator(
+            kececi_type=TYPE_FLOAT,
+            start_input_raw="",  # empty
+            add_input_base_scalar=1.0,
+            iterations=1
+        )
+        self.assertEqual(len(seq), 0)  # should fail gracefully
+
+    def test_unsupported_type(self):
+        """Test that unsupported type raises ValueError."""
+        with self.assertRaises(ValueError):
+            unified_generator(
+                kececi_type=99,  # invalid
+                start_input_raw="0",
+                add_input_base_scalar=1.0,
+                iterations=1
+            )
+
+
+if __name__ == '__main__':
+    unittest.main()
+

kececinumbers-0.4.7/kececinumbers.egg-info/top_level.txt

@@ -1 +0,0 @@
-kececinumbers

kececinumbers-0.4.7/tests/test_sample.py

@@ -1,2 +0,0 @@
-def test_placeholder():
-    assert True