kececinumbers 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

kececinumbers/__init__.py

@@ -34,4 +34,4 @@ def eski_fonksiyon():
 
 
 # Paket sürüm numarası
-__version__ = "0.3.0"
+__version__ = "0.3.1"

kececinumbers/_version.py

@@ -1,6 +1,6 @@
 # _version.py
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 __license__ = "MIT"
 __description__ = "Keçeci Numbers: An Exploration of a Dynamic Sequence Across Diverse Number Sets."
 __author__ = "Mehmet Keçeci"

kececinumbers/kececinumbers.py

@@ -457,142 +457,6 @@ def _is_divisible(value, divisor, kececi_type):
         return False
     return False
 
-# ==============================================================================
-# --- CORE GENERATOR ---
-# ==============================================================================
-
-def unified_generator(kececi_type, start_input_raw, add_input_base_scalar, iterations):
-    """
-    Herhangi bir desteklenen türde Keçeci Sayı dizileri üreten çekirdek motor.
-    Bu sürüm, tüm tipler için sağlam tür dönüştürme ve özel format ayrıştırma içerir.
-    """
-    current_value = None
-    add_value_typed = None
-    ask_unit = None
-    use_integer_division = False
-
-    try:
-        # --- Adım 1: Keçeci Türüne Göre Başlatma ---
-        a_float = float(add_input_base_scalar)
-
-        if kececi_type in [TYPE_POSITIVE_REAL, TYPE_NEGATIVE_REAL]:
-            s_int = int(float(start_input_raw))
-            current_value = s_int
-            add_value_typed = int(a_float)
-            ask_unit = 1
-            use_integer_division = True
-            
-        elif kececi_type == TYPE_FLOAT:
-            current_value = float(start_input_raw)
-            add_value_typed = a_float
-            ask_unit = 1.0
-            
-        elif kececi_type == TYPE_RATIONAL:
-            current_value = Fraction(start_input_raw)
-            add_value_typed = Fraction(add_input_base_scalar)
-            ask_unit = Fraction(1)
-            
-        elif kececi_type == TYPE_COMPLEX:
-            current_value = _parse_complex(start_input_raw)
-            add_value_typed = complex(a_float, a_float)
-            ask_unit = 1 + 1j
-
-        elif kececi_type == TYPE_NEUTROSOPHIC:
-            a, b = _parse_neutrosophic(start_input_raw)
-            current_value = NeutrosophicNumber(a, b)
-            add_value_typed = NeutrosophicNumber(a_float, 0)
-            ask_unit = NeutrosophicNumber(1, 1)
-
-        # --- YENİ EKLENEN/DÜZELTİLEN BLOKLAR ---
-
-        elif kececi_type == TYPE_NEUTROSOPHIC_COMPLEX: # HATA DÜZELTİLDİ
-            s_complex = _parse_complex(start_input_raw)
-            # Başlangıç indeterminacy değerini 0 olarak varsayalım
-            current_value = NeutrosophicComplexNumber(s_complex.real, s_complex.imag, 0.0)
-            # Artış, deterministik reel kısma etki eder
-            add_value_typed = NeutrosophicComplexNumber(a_float, 0.0, 0.0)
-            ask_unit = NeutrosophicComplexNumber(1, 1, 1)
-
-        elif kececi_type == TYPE_HYPERREAL: # HATA DÜZELTİLDİ
-            a, b = _parse_hyperreal(start_input_raw)
-            # 'a' reel kısmı, 'b' ise sonsuz küçükleri ölçekler
-            sequence_list = [a + b / n for n in range(1, 11)]
-            current_value = HyperrealNumber(sequence_list)
-            # Artış, sadece standart (ilk) reel kısma etki eder
-            add_sequence = [a_float] + [0.0] * 9
-            add_value_typed = HyperrealNumber(add_sequence)
-            ask_unit = HyperrealNumber([1.0] * 10)
-
-        elif kececi_type == TYPE_BICOMPLEX: # Mantık aynı, sadece ayrıştırıcıyı kullanıyor
-            s_complex = _parse_complex(start_input_raw)
-            a_complex = complex(a_float)
-            current_value = BicomplexNumber(s_complex, s_complex / 2)
-            add_value_typed = BicomplexNumber(a_complex, a_complex / 2)
-            ask_unit = BicomplexNumber(complex(1, 1), complex(0.5, 0.5))
-
-        elif kececi_type == TYPE_NEUTROSOPHIC_BICOMPLEX: # HATA DÜZELTİLDİ
-            s_complex = _parse_complex(start_input_raw)
-            # Başlangıç değeri olarak kompleks sayıyı kullanıp diğer 6 bileşeni 0 yapalım
-            current_value = NeutrosophicBicomplexNumber(s_complex.real, s_complex.imag, 0, 0, 0, 0, 0, 0)
-            # Artış, sadece ana reel kısma etki eder
-            add_value_typed = NeutrosophicBicomplexNumber(a_float, 0, 0, 0, 0, 0, 0, 0)
-            ask_unit = NeutrosophicBicomplexNumber(*([1.0] * 8))
-
-        # --- DİĞER TİPLER ---
-
-        elif kececi_type == TYPE_QUATERNION:
-            s_float = float(start_input_raw)
-            current_value = np.quaternion(s_float, s_float, s_float, s_float)
-            add_value_typed = np.quaternion(a_float, a_float, a_float, a_float)
-            ask_unit = np.quaternion(1, 1, 1, 1)
-
-        else:
-            raise ValueError(f"Geçersiz veya desteklenmeyen Keçeci Sayı Tipi: {kececi_type}")
-
-    except (ValueError, TypeError) as e:
-        print(f"HATA: Tip {kececi_type} için '{start_input_raw}' girdisiyle başlatma başarısız: {e}")
-        return []
-
-    # --- Adım 2: İterasyon Döngüsü ---
-    sequence = [current_value]
-    last_divisor_used = None
-    ask_counter = 0
-    
-    for _ in range(iterations):
-        added_value = current_value + add_value_typed
-        sequence.append(added_value)
-        
-        result_value = added_value
-        divided_successfully = False
-
-        primary_divisor = 3 if last_divisor_used == 2 or last_divisor_used is None else 2
-        alternative_divisor = 2 if primary_divisor == 3 else 3
-        
-        for divisor in [primary_divisor, alternative_divisor]:
-            if _is_divisible(added_value, divisor, kececi_type):
-                result_value = added_value // divisor if use_integer_division else added_value / divisor
-                last_divisor_used = divisor
-                divided_successfully = True
-                break
-        
-        if not divided_successfully and is_prime(added_value):
-            modified_value = (added_value + ask_unit) if ask_counter == 0 else (added_value - ask_unit)
-            ask_counter = 1 - ask_counter
-            sequence.append(modified_value)
-            
-            result_value = modified_value 
-            
-            for divisor in [primary_divisor, alternative_divisor]:
-                if _is_divisible(modified_value, divisor, kececi_type):
-                    result_value = modified_value // divisor if use_integer_division else modified_value / divisor
-                    last_divisor_used = divisor
-                    break
-        
-        sequence.append(result_value)
-        current_value = result_value
-        
-    return sequence
-
 def _parse_complex(s: str) -> complex:
     """
     Bir string'i kompleks sayıya çevirir. 
@@ -700,6 +564,58 @@ def _parse_hyperreal(s: str) -> (float, float):
         
     return a, b
 
+def _parse_quaternion(s: str) -> np.quaternion:
+    """
+    Kullanıcıdan gelen metin girdisini ('a+bi+cj+dk' veya sadece skaler)
+    bir kuaterniyon nesnesine çevirir.
+
+    Örnekler:
+    - '2.5' -> quaternion(2.5, 2.5, 2.5, 2.5)
+    - '2.5+2.5i+2.5j+2.5k' -> quaternion(2.5, 2.5, 2.5, 2.5)
+    - '1-2i+3.5j-k' -> quaternion(1, -2, 3.5, -1)
+    """
+    s_clean = s.replace(" ", "").lower()
+    if not s_clean:
+        raise ValueError("Girdi boş olamaz.")
+
+    # Girdinin sadece bir sayı olup olmadığını kontrol et
+    try:
+        val = float(s_clean)
+        # Programın orijinal mantığına göre skalerden kuaterniyon oluştur
+        return np.quaternion(val, val, val, val)
+    except ValueError:
+        # Girdi tam bir kuaterniyon ifadesi, ayrıştırmaya devam et
+        pass
+    
+    # Tüm kuaterniyon bileşenlerini bulmak için daha esnek bir regex
+    # Örnek: '-10.5j', '+2i', '5', '-k' gibi parçaları yakalar
+    pattern = re.compile(r'([+-]?\d*\.?\d+)([ijk])?')
+    matches = pattern.findall(s_clean.replace('i', 'i ').replace('j', 'j ').replace('k', 'k ')) # Ayrıştırmayı kolaylaştır
+    
+    parts = {'w': 0.0, 'x': 0.0, 'y': 0.0, 'z': 0.0}
+    
+    # 'i', 'j', 'k' olmayan katsayıları ('-1k' gibi) düzeltmek için
+    s_temp = s_clean
+    for val_str, comp in re.findall(r'([+-])([ijk])', s_clean):
+        s_temp = s_temp.replace(val_str+comp, f'{val_str}1{comp}')
+    
+    matches = pattern.findall(s_temp)
+
+    if not matches:
+        raise ValueError(f"Geçersiz kuaterniyon formatı: '{s}'")
+
+    for value_str, component in matches:
+        value = float(value_str)
+        if component == 'i':
+            parts['x'] += value
+        elif component == 'j':
+            parts['y'] += value
+        elif component == 'k':
+            parts['z'] += value
+        else: # Reel kısım
+            parts['w'] += value
+            
+    return np.quaternion(parts['w'], parts['x'], parts['y'], parts['z'])
 
 def get_random_type(num_iterations, fixed_start_raw="0", fixed_add_base_scalar=9.0):
     """
@@ -730,6 +646,146 @@ def get_random_type(num_iterations, fixed_start_raw="0", fixed_add_base_scalar=9
     
     return generated_sequence
 
+# ==============================================================================
+# --- CORE GENERATOR ---
+# ==============================================================================
+
+def unified_generator(kececi_type, start_input_raw, add_input_base_scalar, iterations):
+    """
+    Herhangi bir desteklenen türde Keçeci Sayı dizileri üreten çekirdek motor.
+    Bu sürüm, tüm tipler için sağlam tür dönüştürme ve özel format ayrıştırma içerir.
+    """
+    current_value = None
+    add_value_typed = None
+    ask_unit = None
+    use_integer_division = False
+
+    try:
+        # --- Adım 1: Keçeci Türüne Göre Başlatma ---
+        a_float = float(add_input_base_scalar)
+
+        if kececi_type in [TYPE_POSITIVE_REAL, TYPE_NEGATIVE_REAL]:
+            s_int = int(float(start_input_raw))
+            current_value = s_int
+            add_value_typed = int(a_float)
+            ask_unit = 1
+            use_integer_division = True
+            
+        elif kececi_type == TYPE_FLOAT:
+            current_value = float(start_input_raw)
+            add_value_typed = a_float
+            ask_unit = 1.0
+            
+        elif kececi_type == TYPE_RATIONAL:
+            current_value = Fraction(start_input_raw)
+            add_value_typed = Fraction(add_input_base_scalar)
+            ask_unit = Fraction(1)
+            
+        elif kececi_type == TYPE_COMPLEX:
+            current_value = _parse_complex(start_input_raw)
+            add_value_typed = complex(a_float, a_float)
+            ask_unit = 1 + 1j
+
+        elif kececi_type == TYPE_NEUTROSOPHIC:
+            a, b = _parse_neutrosophic(start_input_raw)
+            current_value = NeutrosophicNumber(a, b)
+            add_value_typed = NeutrosophicNumber(a_float, 0)
+            ask_unit = NeutrosophicNumber(1, 1)
+
+        # --- YENİ EKLENEN/DÜZELTİLEN BLOKLAR ---
+
+        elif kececi_type == TYPE_NEUTROSOPHIC_COMPLEX: # HATA DÜZELTİLDİ
+            s_complex = _parse_complex(start_input_raw)
+            # Başlangıç indeterminacy değerini 0 olarak varsayalım
+            current_value = NeutrosophicComplexNumber(s_complex.real, s_complex.imag, 0.0)
+            # Artış, deterministik reel kısma etki eder
+            add_value_typed = NeutrosophicComplexNumber(a_float, 0.0, 0.0)
+            ask_unit = NeutrosophicComplexNumber(1, 1, 1)
+
+        elif kececi_type == TYPE_HYPERREAL: # HATA DÜZELTİLDİ
+            a, b = _parse_hyperreal(start_input_raw)
+            # 'a' reel kısmı, 'b' ise sonsuz küçükleri ölçekler
+            sequence_list = [a + b / n for n in range(1, 11)]
+            current_value = HyperrealNumber(sequence_list)
+            # Artış, sadece standart (ilk) reel kısma etki eder
+            add_sequence = [a_float] + [0.0] * 9
+            add_value_typed = HyperrealNumber(add_sequence)
+            ask_unit = HyperrealNumber([1.0] * 10)
+
+        elif kececi_type == TYPE_BICOMPLEX: # Mantık aynı, sadece ayrıştırıcıyı kullanıyor
+            s_complex = _parse_complex(start_input_raw)
+            a_complex = complex(a_float)
+            current_value = BicomplexNumber(s_complex, s_complex / 2)
+            add_value_typed = BicomplexNumber(a_complex, a_complex / 2)
+            ask_unit = BicomplexNumber(complex(1, 1), complex(0.5, 0.5))
+
+        elif kececi_type == TYPE_NEUTROSOPHIC_BICOMPLEX: # HATA DÜZELTİLDİ
+            s_complex = _parse_complex(start_input_raw)
+            # Başlangıç değeri olarak kompleks sayıyı kullanıp diğer 6 bileşeni 0 yapalım
+            current_value = NeutrosophicBicomplexNumber(s_complex.real, s_complex.imag, 0, 0, 0, 0, 0, 0)
+            # Artış, sadece ana reel kısma etki eder
+            add_value_typed = NeutrosophicBicomplexNumber(a_float, 0, 0, 0, 0, 0, 0, 0)
+            ask_unit = NeutrosophicBicomplexNumber(*([1.0] * 8))
+
+        # --- DİĞER TİPLER ---
+
+        elif kececi_type == TYPE_QUATERNION:
+            # Artık girdiyi doğrudan float'a çevirmek yerine, 
+            # hem skaler hem de tam ifadeyi ayrıştırabilen fonksiyonu kullanıyoruz.
+            current_value = _parse_quaternion(start_input_raw)
+            
+            # Artırım değeri (add_value) genellikle basit bir skalerdir,
+            # bu yüzden bu kısım aynı kalabilir.
+            add_value_typed = np.quaternion(a_float, a_float, a_float, a_float)
+            ask_unit = np.quaternion(1, 1, 1, 1)
+
+        else:
+            raise ValueError(f"Geçersiz veya desteklenmeyen Keçeci Sayı Tipi: {kececi_type}")
+
+    except (ValueError, TypeError) as e:
+        print(f"HATA: Tip {kececi_type} için '{start_input_raw}' girdisiyle başlatma başarısız: {e}")
+        return []
+
+    # --- Adım 2: İterasyon Döngüsü ---
+    sequence = [current_value]
+    last_divisor_used = None
+    ask_counter = 0
+    
+    for _ in range(iterations):
+        added_value = current_value + add_value_typed
+        sequence.append(added_value)
+        
+        result_value = added_value
+        divided_successfully = False
+
+        primary_divisor = 3 if last_divisor_used == 2 or last_divisor_used is None else 2
+        alternative_divisor = 2 if primary_divisor == 3 else 3
+        
+        for divisor in [primary_divisor, alternative_divisor]:
+            if _is_divisible(added_value, divisor, kececi_type):
+                result_value = added_value // divisor if use_integer_division else added_value / divisor
+                last_divisor_used = divisor
+                divided_successfully = True
+                break
+        
+        if not divided_successfully and is_prime(added_value):
+            modified_value = (added_value + ask_unit) if ask_counter == 0 else (added_value - ask_unit)
+            ask_counter = 1 - ask_counter
+            sequence.append(modified_value)
+            
+            result_value = modified_value 
+            
+            for divisor in [primary_divisor, alternative_divisor]:
+                if _is_divisible(modified_value, divisor, kececi_type):
+                    result_value = modified_value // divisor if use_integer_division else modified_value / divisor
+                    last_divisor_used = divisor
+                    break
+        
+        sequence.append(result_value)
+        current_value = result_value
+        
+    return sequence
+
 def print_detailed_report(sequence, params):
     """
     Generates and prints a detailed report of the Keçeci sequence results.

{kececinumbers-0.3.0.dist-info → kececinumbers-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -218,7 +218,17 @@ Keçeci Number Types:
 
 6: Quaternions (scalar start input becomes q(s,s,s,s): e.g.,  1 or 2.5)
 
-Please select Keçeci Number Type (1-6):  1
+7: Neutrosophic     
+
+8: Neutro-Complex   
+
+9: Hyperreal
+ 
+10: Bicomplex        
+
+11: Neutro-Bicomplex
+
+Please select Keçeci Number Type (1-11):  1
 
 Enter the starting number (e.g., 0 or 2.5, complex:3+4j, rational: 3/4, quaternions: 1)  :  0
 

kececinumbers-0.3.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+kececinumbers/__init__.py,sha256=LvYVIpFwtVQFC96CoVl_6Dl-wGDq5Z_wdYNM9xEOm_o,1427
+kececinumbers/_version.py,sha256=5Me7OC9f5i_J_SZL1X16-PL4uJBlBEVYbEQzP10j62Y,428
+kececinumbers/kececinumbers.py,sha256=yoYthgKqEx4h4Mk3vAcKuc5bQ9R6nQqcPK7fBT8FXfY,48675
+kececinumbers-0.3.1.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
+kececinumbers-0.3.1.dist-info/METADATA,sha256=jOkFLfHvc2MUC8re9-YaiV9w1jp3iI02lwdFB9wDM1o,15499
+kececinumbers-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kececinumbers-0.3.1.dist-info/top_level.txt,sha256=VvlbQKmTjOlzBbvq54-AaXp_WPRZ5dOhw91lV-ytPRQ,14
+kececinumbers-0.3.1.dist-info/RECORD,,

kececinumbers-0.3.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-kececinumbers/__init__.py,sha256=PPcSRN9XDmCebyzqVkNUIv2lWsMGRc2F_C8QDv0DPL4,1427
-kececinumbers/_version.py,sha256=4nBagc2NMpbf3Ot8Of1OyJ26DHuiiw3plqDzffzYx3Q,428
-kececinumbers/kececinumbers.py,sha256=xQVXYKnhdm2-7ExXkTIPeIvV26Y4Z9flKXyCDdAG4qo,46489
-kececinumbers-0.3.0.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
-kececinumbers-0.3.0.dist-info/METADATA,sha256=0T0kaFaiz7je-_aDd-USw6-QeTXmMftybMLcwVspLvQ,15394
-kececinumbers-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kececinumbers-0.3.0.dist-info/top_level.txt,sha256=VvlbQKmTjOlzBbvq54-AaXp_WPRZ5dOhw91lV-ytPRQ,14
-kececinumbers-0.3.0.dist-info/RECORD,,