kececinumbers 0.2.3__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.2.3"
+__version__ = "0.3.1"

kececinumbers/_version.py

@@ -1,6 +1,6 @@
 # _version.py
 
-__version__ = "0.2.3"
+__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.
@@ -922,8 +978,8 @@ def find_kececi_prime_number(kececi_numbers_list):
 
 def plot_numbers(sequence, title="Keçeci Number Sequence Analysis"):
     """
-    Plots the generated Keçeci Number sequence with appropriate visualizations
-    for each number type.
+    Plots the generated Keçeci Number sequence with appropriate, detailed
+    visualizations for each number type.
     """
     plt.style.use('seaborn-v0_8-whitegrid')
     
@@ -931,25 +987,19 @@ def plot_numbers(sequence, title="Keçeci Number Sequence Analysis"):
         print("Sequence is empty, nothing to plot.")
         return
 
-    fig = plt.figure(figsize=(15, 8))
+    fig = plt.figure(figsize=(16, 9)) # Daha geniş bir görünüm için boyut ayarlandı
     plt.suptitle(title, fontsize=16, y=0.98)
     first_elem = sequence[0]
     
-    # --- Plotting logic per type ---
+    # --- Her Türe Özel Çizim Mantığı ---
     
-    # CORRECTED: Check for the actual Python types.
-    # This correctly handles types 1, 2, and 4 (Positive/Negative Real, Float).
-    if isinstance(first_elem, (int, float)):
+    if isinstance(first_elem, (int, float, Fraction)):
         ax = fig.add_subplot(1, 1, 1)
-        ax.plot([float(x) for x in sequence], 'o-')
+        ax.plot([float(x) for x in sequence], 'o-', label="Value")
         ax.set_title("Value over Iterations")
-        ax.set_xlabel("Index"); ax.set_ylabel("Value")
-
-    elif isinstance(first_elem, Fraction):
-        ax = fig.add_subplot(1, 1, 1)
-        ax.plot([float(x) for x in sequence], 'o-')
-        ax.set_title("Value over Iterations (as float)")
-        ax.set_xlabel("Index"); ax.set_ylabel("Value")
+        ax.set_xlabel("Index")
+        ax.set_ylabel("Value")
+        ax.legend()
 
     elif isinstance(first_elem, complex):
         gs = GridSpec(2, 2, figure=fig)
@@ -974,17 +1024,18 @@ def plot_numbers(sequence, title="Keçeci Number Sequence Analysis"):
     elif isinstance(first_elem, np.quaternion):
         gs = GridSpec(2, 1, figure=fig)
         ax1 = fig.add_subplot(gs[0, 0])
-        ax2 = fig.add_subplot(gs[1, 0])
+        ax2 = fig.add_subplot(gs[1, 0], sharex=ax1) # X eksenini paylaş
         
         ax1.plot([q.w for q in sequence], 'o-', label='w (scalar)')
         ax1.plot([q.x for q in sequence], 's--', label='x')
         ax1.plot([q.y for q in sequence], '^--', label='y')
         ax1.plot([q.z for q in sequence], 'd--', label='z')
-        ax1.set_title("Quaternion Components"); ax1.legend()
+        ax1.set_title("Quaternion Components over Iterations"); ax1.legend()
 
         magnitudes = [np.sqrt(q.w**2 + q.x**2 + q.y**2 + q.z**2) for q in sequence]
         ax2.plot(magnitudes, 'o-', color='purple', label='Magnitude')
-        ax2.set_title("Quaternion Magnitude"); ax2.legend()
+        ax2.set_title("Quaternion Magnitude over Iterations"); ax2.legend()
+        ax2.set_xlabel("Index")
 
     elif isinstance(first_elem, BicomplexNumber):
         gs = GridSpec(2, 2, figure=fig)
@@ -1000,8 +1051,8 @@ def plot_numbers(sequence, title="Keçeci Number Sequence Analysis"):
         ax2.plot(z2r, label='z2.real'); ax2.plot(z2i, label='z2.imag')
         ax2.set_title("Component z2"); ax2.legend()
         
-        ax3.plot(z1r, z1i, '.-'); ax3.set_title("z1 in Complex Plane")
-        ax4.plot(z2r, z2i, '.-'); ax4.set_title("z2 in Complex Plane")
+        ax3.plot(z1r, z1i, '.-'); ax3.set_title("z1 Trajectory"); ax3.set_xlabel("Real"); ax3.set_ylabel("Imaginary")
+        ax4.plot(z2r, z2i, '.-'); ax4.set_title("z2 Trajectory"); ax4.set_xlabel("Real"); ax4.set_ylabel("Imaginary")
         
     elif isinstance(first_elem, NeutrosophicNumber):
         gs = GridSpec(1, 2, figure=fig)
@@ -1009,25 +1060,72 @@ def plot_numbers(sequence, title="Keçeci Number Sequence Analysis"):
         
         a = [x.a for x in sequence]; b = [x.b for x in sequence]
         ax1.plot(a, label='Determinate (a)'); ax1.plot(b, label='Indeterminate (b)')
-        ax1.set_title("Components"); ax1.legend()
+        ax1.set_title("Components over Iterations"); ax1.legend()
         
         sc = ax2.scatter(a, b, c=range(len(a)), cmap='viridis')
-        ax2.set_title("Determinate vs. Indeterminate"); fig.colorbar(sc, ax=ax2)
+        ax2.set_title("Trajectory (colored by time)"); ax2.set_xlabel("Determinate Part"); ax2.set_ylabel("Indeterminate Part"); fig.colorbar(sc, ax=ax2, label="Iteration")
 
     elif isinstance(first_elem, NeutrosophicComplexNumber):
-        gs = GridSpec(1, 2, figure=fig)
-        ax1 = fig.add_subplot(gs[0, 0]); ax2 = fig.add_subplot(gs[0, 1])
+        gs = GridSpec(2, 1, figure=fig)
+        ax1 = fig.add_subplot(gs[0, 0]); ax2 = fig.add_subplot(gs[1, 0])
         
         r = [x.real for x in sequence]; i = [x.imag for x in sequence]; ind = [x.indeterminacy for x in sequence]
         ax1.plot(r, label='Real'); ax1.plot(i, label='Imag'); ax1.plot(ind, label='Indeterminacy', linestyle=':')
-        ax1.set_title("Components"); ax1.legend()
+        ax1.set_title("Components over Iterations"); ax1.legend()
         
-        sc = ax2.scatter(r, i, c=ind, cmap='magma')
-        ax2.set_title("Complex Plane (colored by Indeterminacy)"); fig.colorbar(sc, ax=ax2, label='Indeterminacy')
+        sc = ax2.scatter(r, i, c=ind, cmap='magma', s=20)
+        ax2.set_title("Trajectory in Complex Plane (colored by Indeterminacy)"); 
+        ax2.set_xlabel("Real Part"); ax2.set_ylabel("Imaginary Part");
+        fig.colorbar(sc, ax=ax2, label='Indeterminacy')
+        ax2.axis('equal')
+
+    # --- YENİ EKLENEN BLOKLAR ---
     
-    else: # Fallback for Hyperreal, Neutro-Bicomplex, and others
+    elif isinstance(first_elem, HyperrealNumber):
+        gs = GridSpec(2, 1, figure=fig)
+        ax1 = fig.add_subplot(gs[0, 0])
+        ax2 = fig.add_subplot(gs[1, 0])
+        
+        # İlk birkaç bileşeni çiz
+        num_components_to_plot = min(len(first_elem.sequence), 4)
+        for i in range(num_components_to_plot):
+            comp_data = [h.sequence[i] for h in sequence]
+            ax1.plot(comp_data, label=f'Component {i}')
+        ax1.set_title("Hyperreal Components over Iterations"); ax1.legend()
+        
+        # En önemli iki bileşenin yörüngesini çiz
+        comp0 = [h.sequence[0] for h in sequence]
+        comp1 = [h.sequence[1] for h in sequence]
+        sc = ax2.scatter(comp0, comp1, c=range(len(comp0)), cmap='plasma')
+        ax2.set_title("Trajectory in Standard-Infinitesimal Plane (C0 vs C1)")
+        ax2.set_xlabel("Standard Part (C0)"); ax2.set_ylabel("Primary Infinitesimal (C1)")
+        fig.colorbar(sc, ax=ax2, label="Iteration")
+        
+    elif isinstance(first_elem, NeutrosophicBicomplexNumber):
+        gs = GridSpec(2, 2, figure=fig)
+        ax1 = fig.add_subplot(gs[0, 0]); ax2 = fig.add_subplot(gs[0, 1])
+        ax3 = fig.add_subplot(gs[1, 0]); ax4 = fig.add_subplot(gs[1, 1])
+        
+        # Ana 4 yörüngeyi çizelim
+        r = [n.real for n in sequence]; i = [n.imag for n in sequence]
+        ax1.plot(r, i, '.-', label='(1, i1)')
+        ax1.set_title("Primary Deterministic Plane"); ax1.legend()
+
+        nr = [n.neut_real for n in sequence]; ni = [n.neut_imag for n in sequence]
+        ax2.plot(nr, ni, '.-', label='(I, I*i1)')
+        ax2.set_title("Primary Neutrosophic Plane"); ax2.legend()
+        
+        jr = [n.j_real for n in sequence]; ji = [n.j_imag for n in sequence]
+        ax3.plot(jr, ji, '.-', label='(i2, i1*i2)')
+        ax3.set_title("Secondary Deterministic Plane"); ax3.legend()
+
+        njr = [n.j_neut_real for n in sequence]; nji = [n.j_neut_imag for n in sequence]
+        ax4.plot(njr, nji, '.-', label='(I*i2, I*i1*i2)')
+        ax4.set_title("Secondary Neutrosophic Plane"); ax4.legend()
+
+    else: # Gelecekte eklenebilecek diğer tipler için yedek blok
         ax = fig.add_subplot(1, 1, 1)
-        ax.text(0.5, 0.5, f"Plotting for type '{type(first_elem).__name__}'\nis not specifically implemented.\nShowing string representation of first 3 elements:\n\n1. {sequence[0]}\n2. {sequence[1]}\n3. {sequence[2]}",
+        ax.text(0.5, 0.5, f"Plotting for type '{type(first_elem).__name__}' is not specifically implemented.",
                 ha='center', va='center', fontsize=12, bbox=dict(facecolor='lightyellow'))
     
     plt.tight_layout(rect=[0, 0, 1, 0.96])

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.2.3
+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
-Author-email: bilginomi@yaani.com
+Author-email: mkececi@yaani.com
 Maintainer: Mehmet Keçeci
-Maintainer-email: bilginomi@yaani.com
+Maintainer-email: mkececi@yaani.com
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -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.2.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-kececinumbers/__init__.py,sha256=WIyxRjeIKuHHrzqcqiU38Topi2gyLCeaOe_uMJvXv_0,1427
-kececinumbers/_version.py,sha256=JEAyNI1JmKj3piUdMG7qoVLaD_5sllx8xnucwQfbMI8,428
-kececinumbers/kececinumbers.py,sha256=D7bwhI8vJRC8HU07t5mkl9rPXDfOcyD2GROISnIn9Vo,44279
-kececinumbers-0.2.3.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
-kececinumbers-0.2.3.dist-info/METADATA,sha256=j7BXyx-MVh61JeHk0yf4hL6QjNm1-rgHqyNqwGgWJ4k,15398
-kececinumbers-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kececinumbers-0.2.3.dist-info/top_level.txt,sha256=VvlbQKmTjOlzBbvq54-AaXp_WPRZ5dOhw91lV-ytPRQ,14
-kececinumbers-0.2.3.dist-info/RECORD,,