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

kececinumbers/__init__.py

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

kececinumbers/_version.py

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

kececinumbers/kececinumbers.py

@@ -33,6 +33,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import quaternion  # Requires: pip install numpy numpy-quaternion
 from matplotlib.gridspec import GridSpec
+import re
 
 # ==============================================================================
 # --- MODULE CONSTANTS: KEÇECI NUMBER TYPES ---
@@ -53,24 +54,6 @@ TYPE_NEUTROSOPHIC_BICOMPLEX = 11
 # --- CUSTOM NUMBER CLASS DEFINITIONS ---
 # ==============================================================================
 
-def get_random_type(num_iterations, use_fixed_params_for_selected_type=True,
-                    fixed_start_raw="0", fixed_add_base_scalar=9.0, random_factor=10):
-    """
-    Generates Keçeci Numbers for a randomly selected type.
-    """
-    random_type_choice = random.randint(1, 6)
-    type_names_list = ["Positive Integer", "Negative Integer", "Complex", "Float", "Rational", "Quaternion"]
-    print(f"\nRandomly selected Keçeci Number Type: {random_type_choice} ({type_names_list[random_type_choice-1]})")
-    
-    # get_with_params fonksiyonu zaten KPN'yi yazdıracak, bu yüzden burada tekrar yazdırmaya gerek yok.
-    # Sadece get_with_params'ı çağırıyoruz.
-    generated_sequence = get_with_params(random_type_choice, num_iterations,
-                                         start_value_raw=fixed_start_raw,
-                                         add_value_base_scalar=fixed_add_base_scalar,
-                                         fixed_params=use_fixed_params_for_selected_type,
-                                         random_range_factor=random_factor)
-    return generated_sequence # get_with_params zaten KPN yazdırıyor.
-
 @dataclass
 class NeutrosophicNumber:
     """
@@ -480,22 +463,19 @@ def _is_divisible(value, divisor, kececi_type):
 
 def unified_generator(kececi_type, start_input_raw, add_input_base_scalar, iterations):
     """
-    The core engine for generating Keçeci Number sequences of any supported type.
-    This version includes robust type conversion to prevent initialization errors.
+    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.
     """
-    # --- Step 1: Initialization based on Keçeci Type ---
     current_value = None
     add_value_typed = None
     ask_unit = None
     use_integer_division = False
 
     try:
-        # Convert the ADD value once, as it's always a scalar float.
+        # --- Adım 1: Keçeci Türüne Göre Başlatma ---
         a_float = float(add_input_base_scalar)
 
-        # Handle START value conversion properly within each type-specific block.
         if kececi_type in [TYPE_POSITIVE_REAL, TYPE_NEGATIVE_REAL]:
-            # Correctly handle float strings like "2.5" by converting to float first.
             s_int = int(float(start_input_raw))
             current_value = s_int
             add_value_typed = int(a_float)
@@ -508,82 +488,83 @@ def unified_generator(kececi_type, start_input_raw, add_input_base_scalar, itera
             ask_unit = 1.0
             
         elif kececi_type == TYPE_RATIONAL:
-            # The Fraction constructor correctly handles strings like "2.5".
-            current_value = Fraction(str(start_input_raw))
-            add_value_typed = Fraction(str(add_input_base_scalar))
-            ask_unit = Fraction(1, 1)
+            current_value = Fraction(start_input_raw)
+            add_value_typed = Fraction(add_input_base_scalar)
+            ask_unit = Fraction(1)
             
         elif kececi_type == TYPE_COMPLEX:
-            s_complex = complex(start_input_raw)
-            # If input was a plain number (e.g., "2.5"), interpret it as s+sj.
-            if s_complex.imag == 0 and 'j' not in str(start_input_raw).lower():
-                s_complex = complex(s_complex.real, s_complex.real)
-            current_value = s_complex
+            current_value = _parse_complex(start_input_raw)
             add_value_typed = complex(a_float, a_float)
             ask_unit = 1 + 1j
 
-        elif kececi_type == TYPE_QUATERNION:
-            # Explicitly convert the input string to a float before use.
-            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)
-            
         elif kececi_type == TYPE_NEUTROSOPHIC:
-            s_float = float(start_input_raw)
-            current_value = NeutrosophicNumber(s_float, s_float / 2)
-            add_value_typed = NeutrosophicNumber(a_float, a_float / 2)
+            a, b = _parse_neutrosophic(start_input_raw)
+            current_value = NeutrosophicNumber(a, b)
+            add_value_typed = NeutrosophicNumber(a_float, 0)
             ask_unit = NeutrosophicNumber(1, 1)
-            
-        elif kececi_type == TYPE_NEUTROSOPHIC_COMPLEX:
-            s_float = float(start_input_raw)
-            current_value = NeutrosophicComplexNumber(s_float, s_float / 2, s_float / 3)
-            add_value_typed = NeutrosophicComplexNumber(a_float, a_float / 2, a_float / 3)
+
+        # --- 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:
-            s_float = float(start_input_raw)
-            current_value = HyperrealNumber([s_float / n for n in range(1, 11)])
-            add_value_typed = HyperrealNumber([a_float / n for n in range(1, 11)])
+
+        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:
-            s_complex = complex(start_input_raw)
+
+        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:
+        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)
-            parts = [s_float / (n + 1) for n in range(8)]
-            add_parts = [a_float / (n + 1) for n in range(8)]
-            ask_parts = [1.0 / (n + 1) for n in range(8)]
-            current_value = NeutrosophicBicomplexNumber(*parts)
-            add_value_typed = NeutrosophicBicomplexNumber(*add_parts)
-            ask_unit = NeutrosophicBicomplexNumber(*ask_parts)
-            
+            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"Invalid Keçeci Number Type: {kececi_type}")
+            raise ValueError(f"Geçersiz veya desteklenmeyen Keçeci Sayı Tipi: {kececi_type}")
 
     except (ValueError, TypeError) as e:
-        print(f"Error initializing generator for type {kececi_type} with input '{start_input_raw}': {e}")
+        print(f"HATA: Tip {kececi_type} için '{start_input_raw}' girdisiyle başlatma başarısız: {e}")
         return []
 
-    # --- Step 2: Iteration Loop (This part remains unchanged) ---
+    # --- Adım 2: İterasyon Döngüsü ---
     sequence = [current_value]
     last_divisor_used = None
     ask_counter = 0
     
     for _ in range(iterations):
-        # Rule 1: Add the increment value
         added_value = current_value + add_value_typed
         sequence.append(added_value)
         
         result_value = added_value
         divided_successfully = False
 
-        # Rule 2: Attempt Division
         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
         
@@ -594,16 +575,13 @@ def unified_generator(kececi_type, start_input_raw, add_input_base_scalar, itera
                 divided_successfully = True
                 break
         
-        # Rule 3: Apply ASK Rule if division failed and the number is prime
         if not divided_successfully and is_prime(added_value):
-            # Augment or Shrink the value
             modified_value = (added_value + ask_unit) if ask_counter == 0 else (added_value - ask_unit)
-            ask_counter = 1 - ask_counter  # Flip between 0 and 1
+            ask_counter = 1 - ask_counter
             sequence.append(modified_value)
             
-            result_value = modified_value # Default to modified value if re-division fails
+            result_value = modified_value 
             
-            # Re-attempt division on the 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
@@ -615,6 +593,205 @@ def unified_generator(kececi_type, start_input_raw, add_input_base_scalar, itera
         
     return sequence
 
+def _parse_complex(s: str) -> complex:
+    """
+    Bir string'i kompleks sayıya çevirir. 
+    Eğer 'j' içermiyorsa, "3" girdisini 3+3j olarak yorumlar.
+    """
+    s_clean = s.strip().lower()
+    try:
+        # Doğrudan kompleks çevirmeyi dene (ör: "3+4j")
+        c = complex(s_clean)
+        # Eğer girdi "3" gibi sadece reel bir sayıysa ve 'j' içermiyorsa,
+        # onu s_complex.real + s_complex.real*j yap.
+        if c.imag == 0 and 'j' not in s_clean:
+            return complex(c.real, c.real)
+        return c
+    except ValueError as e:
+        raise ValueError(f"Geçersiz kompleks sayı formatı: '{s}'") from e
+
+def _parse_neutrosophic(s: str) -> (float, float):
+    """
+    Parses a neutrosophic number string of the form 'a+bI' into a tuple (a, b).
+    Handles cases like '5+2I', '3-I', '7', '4I', '-I'.
+    """
+    s = s.strip().replace(" ", "").upper()
+    if not s:
+        return 0.0, 0.0
+
+    # Eğer 'I' yoksa, bu standart bir sayıdır (b=0)
+    if 'I' not in s:
+        try:
+            return float(s), 0.0
+        except ValueError:
+            raise ValueError(f"Invalid number format for non-neutrosophic part: {s}")
+
+    # 'I' varsa, a ve b kısımlarını ayır
+    # 'b' kısmını bul
+    i_pos = s.find('I')
+    a_part_str = s[:i_pos]
+    
+    # Sadece 'I' veya '-I' gibi durumlar
+    if not a_part_str or a_part_str == '+':
+        b = 1.0
+    elif a_part_str == '-':
+        b = -1.0
+    else:
+        # 'a' ve 'b' kısımlarını ayırmak için sondaki işareti bul
+        last_plus = a_part_str.rfind('+')
+        last_minus = a_part_str.rfind('-')
+        
+        # Eğer başta eksi işareti varsa onu ayraç olarak sayma
+        if last_minus == 0 and last_plus == -1:
+             split_pos = -1
+        else:
+             split_pos = max(last_plus, last_minus)
+
+        if split_pos == -1: # Örneğin '3I' durumu
+            a = 0.0
+            b = float(a_part_str)
+        else: # Örneğin '5+3I' veya '-2-4I' durumu
+            a = float(a_part_str[:split_pos])
+            b_str = a_part_str[split_pos:]
+            if b_str == '+':
+                b = 1.0
+            elif b_str == '-':
+                b = -1.0
+            else:
+                b = float(b_str)
+    
+    return a, b
+
+def _parse_hyperreal(s: str) -> (float, float):
+    """
+    'a+be' formatındaki bir hiperreel string'i (a, b) demetine ayrıştırır.
+    '5+3e', '-2-e', '10', '4e', '-e' gibi formatları işler.
+    """
+    s = s.strip().replace(" ", "").lower()
+    if not s:
+        return 0.0, 0.0
+
+    # Eğer 'e' yoksa, bu standart bir sayıdır (b=0)
+    if 'e' not in s:
+        return float(s), 0.0
+
+    # 'a+be' formatını regex ile ayrıştır
+    # Örnekler: 5+3e, -3.1-4.5e, +2e, e, -e
+    match = re.match(r"^(?P<a>[+-]?\d+\.?\d*)?(?P<b>[+-]?\d*\.?\d*)e$", s)
+    if not match:
+        # Sadece +e veya -e durumları için
+        match = re.match(r"^(?P<a>[+-]?\d+\.?\d*)?(?P<b>[+-])e$", s)
+
+    if not match:
+        raise ValueError(f"Geçersiz hiperreel format: {s}")
+
+    parts = match.groupdict()
+    a_part = parts.get('a')
+    b_part = parts.get('b')
+
+    a = float(a_part) if a_part else 0.0
+    
+    if b_part is None or b_part == '' or b_part == '+':
+        b = 1.0
+    elif b_part == '-':
+        b = -1.0
+    else:
+        b = float(b_part)
+        
+    return a, b
+
+
+def get_random_type(num_iterations, fixed_start_raw="0", fixed_add_base_scalar=9.0):
+    """
+    Generates Keçeci Numbers for a randomly selected type using fixed parameters.
+    (Updated with the full list of 11 types and compatible with the new get_with_params signature)
+    """
+    # Rastgele sayı üretme aralığı 11 tipe göre güncellendi.
+    random_type_choice = random.randint(1, 11)
+    
+    # Kullanıcının sağladığı tam liste eklendi.
+    type_names_list = [
+        "Positive Real", "Negative Real", "Complex", "Float", "Rational", 
+        "Quaternion", "Neutrosophic", "Neutro-Complex", "Hyperreal", 
+        "Bicomplex", "Neutro-Bicomplex"
+    ]
+    
+    # Listenin indeksi 0'dan başladığı için random_type_choice-1 kullanılır.
+    print(f"\nRandomly selected Keçeci Number Type: {random_type_choice} ({type_names_list[random_type_choice-1]})")
+    
+    # get_with_params fonksiyonu sadeleştirilmiş haliyle çağrılıyor.
+    # Beklenmeyen 'random_range_factor' veya 'fixed_params' argümanları yok.
+    generated_sequence = get_with_params(
+        kececi_type_choice=random_type_choice, 
+        iterations=num_iterations,
+        start_value_raw=fixed_start_raw,
+        add_value_base_scalar=fixed_add_base_scalar
+    )
+    
+    return generated_sequence
+
+def print_detailed_report(sequence, params):
+    """
+    Generates and prints a detailed report of the Keçeci sequence results.
+    
+    Args:
+        sequence (list): The generated Keçeci sequence.
+        params (dict): A dictionary containing the generation parameters.
+    """
+    if not sequence:
+        print("\n--- REPORT ---")
+        print("Sequence could not be generated. No report to show.")
+        return
+
+    print("\n\n" + "="*50)
+    print("--- DETAILED SEQUENCE REPORT ---")
+    print("="*50)
+
+    # Parametreleri yazdır
+    print("\n[Parameters Used]")
+    print(f"  - Keçeci Type:   {params['type_name']} ({params['type_choice']})")
+    print(f"  - Start Value:   '{params['start_val']}'")
+    print(f"  - Increment:     {params['add_val']}")
+    print(f"  - Keçeci Steps:  {params['steps']}")
+
+    # Dizi Özeti
+    print("\n[Sequence Summary]")
+    print(f"  - Total Numbers Generated: {len(sequence)}")
+    
+    # Keçeci Asal Sayısı (KPN) sonucunu bul ve yazdır
+    kpn = find_kececi_prime_number(sequence)
+    if kpn is not None:
+        print(f"  - Keçeci Prime Number (KPN): {kpn}")
+    else:
+        print("  - Keçeci Prime Number (KPN): Not found in this sequence.")
+
+    # Dizi Önizlemesi
+    print("\n[Sequence Preview]")
+    # Dizinin tamamını yazdırmadan önce bir önizleme sunalım
+    preview_count = min(len(sequence), 5)
+    print(f"  --- First {preview_count} Numbers ---")
+    for i in range(preview_count):
+        print(f"    {i}: {sequence[i]}")
+
+    if len(sequence) > preview_count:
+        print(f"\n  --- Last {preview_count} Numbers ---")
+        for i in range(len(sequence) - preview_count, len(sequence)):
+            print(f"    {i}: {sequence[i]}")
+            
+    print("\n" + "="*50)
+
+    # Kullanıcıya tüm diziyi görmek isteyip istemediğini sor
+    while True:
+        show_all = input("Do you want to print the full sequence? (y/n): ").lower().strip()
+        if show_all in ['y', 'n']:
+            break
+    
+    if show_all == 'y':
+        print("\n--- FULL SEQUENCE ---")
+        for i, num in enumerate(sequence):
+            print(f"{i}: {num}")
+        print("="*50)
+
 # ==============================================================================
 # --- HIGH-LEVEL CONTROL FUNCTIONS ---
 # ==============================================================================
@@ -648,6 +825,7 @@ def get_with_params(kececi_type_choice, iterations, start_value_raw="0", add_val
 def get_interactive():
     """
     Interactively gets parameters from the user and generates Keçeci Numbers.
+    This version only gets data and returns the sequence without plotting.
     """
     print("\n--- Keçeci Number Interactive Generator ---")
     print("  1: Positive Real    2: Negative Real     3: Complex")
@@ -662,18 +840,38 @@ def get_interactive():
             else: print("Invalid type. Please enter a number between 1 and 11.")
         except ValueError: print("Invalid input. Please enter a number.")
         
-    start_prompt = "Enter starting value: "
-    if type_choice == TYPE_COMPLEX: start_prompt = "Enter complex start (e.g., '3+4j' or '3' for 3+3j): "
-    elif type_choice == TYPE_RATIONAL: start_prompt = "Enter rational start (e.g., '7/2' or '5'): "
-    elif type_choice == TYPE_BICOMPLEX: start_prompt = "Enter bicomplex start (complex, e.g., '2+1j'): "
+    # Her tip için özel başlangıç değeri istemleri (prompts)
+    prompts = {
+        1:  "Enter positive integer start (e.g., '10'): ",
+        2:  "Enter negative integer start (e.g., '-5'): ",
+        3:  "Enter complex start (e.g., '3+4j' or '3' for 3+3j): ",
+        4:  "Enter float start (e.g., '3.14' or '-0.5'): ",
+        5:  "Enter rational start (e.g., '7/2' or '5' for 5/1): ",
+        6:  "Enter scalar for quaternion base (e.g., '2.5' for 2.5+2.5i+2.5j+2.5k): ",
+        7:  "Enter neutrosophic start (e.g., '5+2I' or '7'): ",
+        8:  "Enter complex base for neutro-complex (e.g., '1-2j'): ",
+        9:  "Enter hyperreal start (e.g., '5+3e' or '10'): ",
+        10: "Enter complex base for bicomplex (e.g., '2+1j'): ",
+        11: "Enter complex base for neutro-bicomplex (e.g., '1+2j'): "
+    }
+    
+    # Seçilen tipe göre doğru istemi al, yoksa genel bir istem kullan
+    start_prompt = prompts.get(type_choice, "Enter starting value: ")
 
     start_input_val_raw = input(start_prompt)
-    add_base_scalar_val = float(input("Enter base scalar increment (e.g., 9.0): "))
+    add_base_scalar_val = float(input("Enter base scalar increment (e.g., 9.0 for positive, -3.0 for negative): "))
     num_kececi_steps = int(input("Enter number of Keçeci steps (e.g., 15): "))
     
+    # Diziyi oluştur ve çizdir
     sequence = get_with_params(type_choice, num_kececi_steps, start_input_val_raw, add_base_scalar_val)
-    plot_numbers(sequence, f"Keçeci Type {type_choice} Sequence")
-    plt.show()
+    if sequence:
+        # sequence adı altında bir isim çakışması olmaması için başlığı değiştiriyoruz.
+        plot_title = f"Keçeci Type {type_choice} Sequence"
+        #plot_numbers(sequence, plot_title)
+        #plt.show() # Grafiği göstermek için
+        
+    # Fonksiyonun, ana kodun kullanabilmesi için tüm önemli bilgileri döndürmesini sağlıyoruz.
+    return sequence, type_choice, start_input_val_raw, add_base_scalar_val, num_kececi_steps
 
 # ==============================================================================
 # --- ANALYSIS AND PLOTTING ---
@@ -724,8 +922,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')
     
@@ -733,25 +931,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)
@@ -776,17 +968,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)
@@ -802,8 +995,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)
@@ -811,25 +1004,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.2.dist-info → kececinumbers-0.3.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.2.2
+Version: 0.3.0
 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
@@ -128,6 +128,49 @@ https://zenodo.org/records/
 
 ### Example
 
+```python
+import matplotlib.pyplot as plt
+import kececinumbers as kn
+
+print("--- Interactive Test ---")
+
+# Adım 1: get_interactive'ten tüm verileri al
+# Not: Fonksiyon artık birden fazla değer döndürüyor.
+interactive_results = kn.get_interactive()
+
+# Fonksiyon bir dizi döndürdüyse (başarılıysa) devam et
+if interactive_results and interactive_results[0]:
+    # Dönen değerleri değişkenlere ata
+    seq_interactive, type_choice, start_val, add_val, steps = interactive_results
+    
+    # Tip numarasını isme çevirelim
+    type_names = [
+        "Positive Real", "Negative Real", "Complex", "Float", "Rational", 
+        "Quaternion", "Neutrosophic", "Neutro-Complex", "Hyperreal", 
+        "Bicomplex", "Neutro-Bicomplex"
+    ]
+    type_name = type_names[type_choice - 1]
+
+    # Adım 2: Ayrıntılı raporu yazdır
+    params = {
+        'type_choice': type_choice,
+        'type_name': type_name,
+        'start_val': start_val,
+        'add_val': add_val,
+        'steps': steps
+    }
+    kn.print_detailed_report(seq_interactive, params)
+    
+    # Adım 3: Grafiği SADECE BİR KERE çizdir
+    print("\nDisplaying plot...")
+    plot_title = f"Interactive Keçeci Sequence ({type_name})"
+    kn.plot_numbers(seq_interactive, plot_title)
+    plt.show()
+
+else:
+    print("Sequence generation was cancelled or failed.")
+```
+
 ```python
 import matplotlib.pyplot as plt
 import random
@@ -135,9 +178,6 @@ import numpy as np
 import math
 from fractions import Fraction
 import quaternion # pip install numpy numpy-quaternion
-```
-```python
-import matplotlib.pyplot as plt
 import kececinumbers as kn
 
 # Matplotlib grafiklerinin notebook içinde gösterilmesini sağla

kececinumbers-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+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,,

kececinumbers-0.2.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-kececinumbers/__init__.py,sha256=JsyncFH_EvulqHonq8ZwQ0U320Pn6jQGnDQGZIZ9J2k,1427
-kececinumbers/_version.py,sha256=jUYrWHUGa7z5CqDjSpttj3lcGyBCIj6VN42MMCBWxL8,428
-kececinumbers/kececinumbers.py,sha256=HKzpmaTy59CGilyn5Y-fbgyjK4VftNPg_SbQi3EYW9s,37918
-kececinumbers-0.2.2.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
-kececinumbers-0.2.2.dist-info/METADATA,sha256=euR0t75LxU49XvdiKOBoYWxQxYOCPHM2zByoQVMmlqg,14097
-kececinumbers-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kececinumbers-0.2.2.dist-info/top_level.txt,sha256=VvlbQKmTjOlzBbvq54-AaXp_WPRZ5dOhw91lV-ytPRQ,14
-kececinumbers-0.2.2.dist-info/RECORD,,