kececinumbers 0.6.9__py3-none-any.whl → 0.7.1__py3-none-any.whl

kececinumbers/__init__.py

@@ -22,7 +22,7 @@ import warnings
     # importlib.reload(kececinumbers) # F821 undefined name 'kececinumbers'
 
 # Paket sürüm numarası
-__version__ = "0.6.9"
+__version__ = "0.7.1"
 __author__ = "Mehmet Keçeci"
 __email__ = "mkececi@yaani.com"
 
@@ -82,6 +82,7 @@ __all__ = [
     '_is_complex_like',
     'is_prime_like',
     'is_near_integer',
+    '_plot_component_distribution',
     
 
     # --- Core Generation and Analysis ---
@@ -180,6 +181,7 @@ try:
         _is_complex_like,
         is_prime_like,
         is_near_integer,
+        _plot_component_distribution,
          
     
         # Constants

kececinumbers/_version.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # _version.py
 
-__version__ = "0.6.9"
+__version__ = "0.7.1"
 __license__ = "MIT"
 __description__ = "Keçeci Numbers: An Exploration of a Dynamic Sequence Across Diverse Number Sets."
 __author__ = "Mehmet Keçeci"

kececinumbers/kececinumbers.py

@@ -33,7 +33,7 @@ import collections
 from dataclasses import dataclass
 from fractions import Fraction
 import math
-from matplotlib.gridspec import GridSpec
+#from matplotlib.gridspec import GridSpec
 import matplotlib.pyplot as plt
 import numbers
 #from numbers import Real
@@ -49,6 +49,13 @@ from typing import Any, Dict, List, Optional, Tuple
 
 # numpy ve diğer Keçeci tipleri için gerekli importlar
 # Eğer bu kütüphaneler yüklü değilse, pip install numpy gibi komutlarla yüklemeniz gerekebilir.
+try:
+    from matplotlib.gridspec import GridSpec
+except ModuleNotFoundError:
+    import matplotlib
+    print(f"Matplotlib path: {matplotlib.__file__}")
+    from matplotlib.gridspec import GridSpec
+
 try:
     import numpy as np
     # numpy.quaternion'ın eski adı np.quaternion. Yeni versiyonlarda quaternion modülü ayrı olabilir.
@@ -634,18 +641,124 @@ class SedenionNumber:
         return f"({', '.join(map(str, self.coeffs))})"
 
 @dataclass
+class CliffordNumber:
+    def __init__(self, basis_dict: Dict[str, float]):
+        """CliffordNumber constructor."""
+        # Sadece sıfır olmayan değerleri sakla
+        self.basis = {k: float(v) for k, v in basis_dict.items() if abs(float(v)) > 1e-10}
+    
+    @property
+    def dimension(self) -> int:
+        """Vector space dimension'ını otomatik hesaplar."""
+        max_index = 0
+        for key in self.basis.keys():
+            if key:  # scalar değilse
+                # '12', '123' gibi string'lerden maksimum rakamı bul
+                if key.isdigit():
+                    max_index = max(max_index, max(int(c) for c in key))
+        return max_index
+
+    def __add__(self, other):
+        if isinstance(other, CliffordNumber):
+            new_basis = self.basis.copy()
+            for k, v in other.basis.items():
+                new_basis[k] = new_basis.get(k, 0.0) + v
+                # Sıfıra yakın değerleri temizle
+                if abs(new_basis[k]) < 1e-10:
+                    del new_basis[k]
+            return CliffordNumber(new_basis)
+        elif isinstance(other, (int, float)):
+            new_basis = self.basis.copy()
+            new_basis[''] = new_basis.get('', 0.0) + other
+            return CliffordNumber(new_basis)
+        return NotImplemented
+
+    def __sub__(self, other):
+        if isinstance(other, CliffordNumber):
+            new_basis = self.basis.copy()
+            for k, v in other.basis.items():
+                new_basis[k] = new_basis.get(k, 0.0) - v
+                if abs(new_basis[k]) < 1e-10:
+                    del new_basis[k]
+            return CliffordNumber(new_basis)
+        elif isinstance(other, (int, float)):
+            new_basis = self.basis.copy()
+            new_basis[''] = new_basis.get('', 0.0) - other
+            return CliffordNumber(new_basis)
+        return NotImplemented
+
+    def __mul__(self, other):
+        if isinstance(other, (int, float)):
+            return CliffordNumber({k: v * other for k, v in self.basis.items()})
+        elif isinstance(other, CliffordNumber):
+            # Basit Clifford çarpımı (e_i^2 = +1 varsayımıyla)
+            new_basis = {}
+            
+            for k1, v1 in self.basis.items():
+                for k2, v2 in other.basis.items():
+                    # Skaler çarpım
+                    if k1 == '':
+                        product_key = k2
+                        sign = 1.0
+                    elif k2 == '':
+                        product_key = k1
+                        sign = 1.0
+                    else:
+                        # Vektör çarpımı: e_i * e_j
+                        combined = sorted(k1 + k2)
+                        product_key = ''.join(combined)
+                        
+                        # Basitleştirilmiş: e_i^2 = +1, anti-commutative
+                        sign = 1.0
+                        # Burada gerçek Clifford cebir kuralları uygulanmalı
+                    
+                    new_basis[product_key] = new_basis.get(product_key, 0.0) + sign * v1 * v2
+            
+            return CliffordNumber(new_basis)
+        return NotImplemented
+
+    def __truediv__(self, other):
+        if isinstance(other, (int, float)):
+            if other == 0:
+                raise ZeroDivisionError("Division by zero")
+            return CliffordNumber({k: v / other for k, v in self.basis.items()})
+        return NotImplemented
+
+    def __str__(self):
+        parts = []
+        if '' in self.basis and abs(self.basis['']) > 1e-10:
+            parts.append(f"{self.basis['']:.2f}")
+        
+        sorted_keys = sorted([k for k in self.basis if k != ''], key=lambda x: (len(x), x))
+        for k in sorted_keys:
+            v = self.basis[k]
+            if abs(v) > 1e-10:
+                sign = '+' if v > 0 and parts else ''
+                parts.append(f"{sign}{v:.2f}e{k}")
+        
+        result = "".join(parts).replace("+-", "-")
+        return result if result else "0.0"
+
+    @classmethod
+    def parse(cls, s) -> 'CliffordNumber':
+        """Class method olarak parse metodu"""
+        return _parse_clifford(s)
+
+    def __repr__(self):
+        return self.__str__()
+"""
 class CliffordNumber:
 
     def __init__(self, basis_dict):
-        """
-        CliffordNumber constructor - sadece basis_dict alır.
-        Dimension property olarak hesaplanabilir.
-        """
+
+        #CliffordNumber constructor - sadece basis_dict alır.
+        #Dimension property olarak hesaplanabilir.
+
         self.basis = {k: float(v) for k, v in basis_dict.items()}
     
     @property
     def dimension(self):
-        """Vector space dimension'ını otomatik hesaplar."""
+        #Vector space dimension'ını otomatik hesaplar.
         if not self.basis:
             return 0
         max_index = 0
@@ -727,6 +840,7 @@ class CliffordNumber:
         if not parts:
             return "0.0"
         return "".join(parts).replace("+-", "-")
+"""
 
 
 @dataclass
@@ -863,10 +977,56 @@ def _extract_numeric_part(s: str) -> str:
     # Hiç sayı bulunamazsa orijinal string'i döndür
     return s
 
-def _parse_complex(s: str) -> complex:
-    """Bir string'i complex sayıya dönüştürür.
+def _parse_complex(s) -> complex:
+    """Bir string'i veya sayıyı complex sayıya dönüştürür.
     "real,imag", "real+imag(i/j)", "real", "imag(i/j)" formatlarını destekler.
+    Float ve int tiplerini de doğrudan kabul eder.
     """
+    # Eğer zaten complex sayıysa doğrudan döndür
+    if isinstance(s, complex):
+        return s
+    
+    # Eğer float veya int ise doğrudan complex'e dönüştür
+    if isinstance(s, (float, int)):
+        return complex(s)
+    
+    # String işlemleri için önce string'e dönüştür
+    if isinstance(s, str):
+        s = s.strip().replace('J', 'j').replace('i', 'j') # Hem J hem i yerine j kullan
+    else:
+        s = str(s).strip().replace('J', 'j').replace('i', 'j')
+    
+    # 1. Eğer "real,imag" formatındaysa
+    if ',' in s:
+        parts = s.split(',')
+        if len(parts) == 2:
+            try:
+                return complex(float(parts[0]), float(parts[1]))
+            except ValueError:
+                pass # Devam et
+
+    # 2. Python'ın kendi complex() dönüştürücüsünü kullanmayı dene (örn: "1+2j", "3j", "-5")
+    try:
+        return complex(s)
+    except ValueError:
+        # 3. Sadece real kısmı varsa (örn: "5")
+        try:
+            return complex(float(s), 0)
+        except ValueError:
+            # 4. Sadece sanal kısmı varsa (örn: "2j", "j")
+            if s.endswith('j'):
+                try:
+                    imag_val = float(s[:-1]) if s[:-1] else 1.0 # "j" -> 1.0j
+                    return complex(0, imag_val)
+                except ValueError:
+                    pass
+            
+            raise ValueError(f"Geçersiz kompleks sayı formatı: '{s}'")
+"""
+def _parse_complex(s: str) -> complex:
+    #Bir string'i complex sayıya dönüştürür.
+    # "real,imag", "real+imag(i/j)", "real", "imag(i/j)" formatlarını destekler.
+    
     s = s.strip().replace('J', 'j').replace('i', 'j') # Hem J hem i yerine j kullan
 
     # 1. Eğer "real,imag" formatındaysa
@@ -895,6 +1055,7 @@ def _parse_complex(s: str) -> complex:
                     pass
             
             raise ValueError(f"Geçersiz kompleks sayı formatı: '{s}'")
+"""
 
 def convert_to_float(value):
     """Convert various Keçeci number types to a float or raise an error if not possible."""
@@ -959,8 +1120,20 @@ def safe_add(added_value, ask_unit, direction):
         raise TypeError(f"{msg} → {type(e).__name__}: {e}") from e
 
 
-def _parse_neutrosophic(s: str) -> Tuple[float, float, float]:
+def _parse_neutrosophic(s) -> Tuple[float, float, float]:
     """Parses neutrosophic string into (t, i, f) tuple."""
+    # Eğer zaten tuple ise doğrudan döndür
+    if isinstance(s, (tuple, list)) and len(s) >= 3:
+        return float(s[0]), float(s[1]), float(s[2])
+    
+    # Sayısal tipse sadece t değeri olarak işle
+    if isinstance(s, (float, int, complex)):
+        return float(s), 0.0, 0.0
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
     s_clean = s.strip().replace(" ", "").upper()
     
     # VİRGÜL formatı: t,i,f (3 parametre)
@@ -1002,8 +1175,20 @@ def _parse_neutrosophic(s: str) -> Tuple[float, float, float]:
     except ValueError:
         return 0.0, 0.0, 0.0  # Default
 
-def _parse_hyperreal(s: str) -> Tuple[float, float]:
+def _parse_hyperreal(s) -> Tuple[float, float]:
     """Parses hyperreal string into (finite, infinitesimal) tuple."""
+    # Eğer zaten tuple ise doğrudan döndür
+    if isinstance(s, (tuple, list)) and len(s) >= 2:
+        return float(s[0]), float(s[1])
+    
+    # Sayısal tipse sadece finite değeri olarak işle
+    if isinstance(s, (float, int, complex)):
+        return float(s), 0.0
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
     s_clean = s.strip().replace(" ", "")
     
     # VİRGÜL formatı: finite,infinitesimal
@@ -1036,10 +1221,20 @@ def _parse_hyperreal(s: str) -> Tuple[float, float]:
     except ValueError:
         return 0.0, 0.0  # Default
 
-def _parse_quaternion_from_csv(s: str) -> np.quaternion:
-    """Virgülle ayrılmış string'i Quaternion'a dönüştürür.
-    "w,x,y,z" veya sadece "w" (skaler) formatlarını destekler.
-    """
+def _parse_quaternion_from_csv(s) -> np.quaternion:
+    """Virgülle ayrılmış string'i veya sayıyı Quaternion'a dönüştürür."""
+    # Eğer zaten quaternion ise doğrudan döndür
+    if isinstance(s, np.quaternion):
+        return s
+    
+    # Sayısal tipse skaler quaternion olarak işle
+    if isinstance(s, (float, int, complex)):
+        return np.quaternion(float(s), 0, 0, 0)
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
     s = s.strip()
     parts_str = s.split(',')
     
@@ -1056,15 +1251,29 @@ def _parse_quaternion_from_csv(s: str) -> np.quaternion:
     else:
         raise ValueError(f"Geçersiz quaternion formatı. 1 veya 4 bileşen bekleniyor: '{s}'")
 
-
-def _has_comma_format(s: str) -> bool:
+def _has_comma_format(s) -> bool:
     """String'in virgül içerip içermediğini kontrol eder."""
+    if not isinstance(s, str):
+        s = str(s)
     return ',' in s
 
-def _parse_neutrosophic_bicomplex(s: str) -> NeutrosophicBicomplexNumber:
+def _parse_neutrosophic_bicomplex(s) -> NeutrosophicBicomplexNumber:
     """
-    Parses string like "a,b,c,d,e,f,g,h" into 8 components.
+    Parses string or numbers into NeutrosophicBicomplexNumber.
     """
+    # Eğer zaten NeutrosophicBicomplexNumber ise doğrudan döndür
+    if isinstance(s, NeutrosophicBicomplexNumber):
+        return s
+    
+    # Sayısal tipse tüm bileşenler 0, sadece ilk bileşen değerli
+    if isinstance(s, (float, int, complex)):
+        values = [float(s)] + [0.0] * 7
+        return NeutrosophicBicomplexNumber(*values)
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
     try:
         parts = s.split(',')
         if len(parts) != 8:
@@ -1073,9 +1282,167 @@ def _parse_neutrosophic_bicomplex(s: str) -> NeutrosophicBicomplexNumber:
         return NeutrosophicBicomplexNumber(*values)
     except Exception as e:
         raise ValueError(f"Invalid NeutrosophicBicomplex format: '{s}' → {e}")
+"""
+def _parse_neutrosophic(s: str) -> Tuple[float, float, float]:
+    #Parses neutrosophic string into (t, i, f) tuple.
+    s_clean = s.strip().replace(" ", "").upper()
+    
+    # VİRGÜL formatı: t,i,f (3 parametre)
+    if ',' in s_clean:
+        parts = s_clean.split(',')
+        try:
+            if len(parts) >= 3:
+                return float(parts[0]), float(parts[1]), float(parts[2])
+            elif len(parts) == 2:
+                return float(parts[0]), float(parts[1]), 0.0
+            elif len(parts) == 1:
+                return float(parts[0]), 0.0, 0.0
+        except ValueError:
+            pass
 
+    # Eski formatları destekle
+    try:
+        if 'I' in s_clean or 'F' in s_clean:
+            # Basit parsing
+            t_part = s_clean
+            i_val, f_val = 0.0, 0.0
+            
+            if 'I' in s_clean:
+                parts = s_clean.split('I')
+                t_part = parts[0]
+                i_val = float(parts[1]) if parts[1] and parts[1] not in ['', '+', '-'] else 1.0
+            
+            if 'F' in t_part:
+                parts = t_part.split('F')
+                t_val = float(parts[0]) if parts[0] and parts[0] not in ['', '+', '-'] else 0.0
+                f_val = float(parts[1]) if len(parts) > 1 and parts[1] not in ['', '+', '-'] else 1.0
+            else:
+                t_val = float(t_part) if t_part not in ['', '+', '-'] else 0.0
+            
+            return t_val, i_val, f_val
+        else:
+            # Sadece sayısal değer
+            return float(s_clean), 0.0, 0.0
+    except ValueError:
+        return 0.0, 0.0, 0.0  # Default
+"""
+"""
+def _parse_hyperreal(s: str) -> Tuple[float, float]:
+    #Parses hyperreal string into (finite, infinitesimal) tuple.
+    s_clean = s.strip().replace(" ", "")
+    
+    # VİRGÜL formatı: finite,infinitesimal
+    if ',' in s_clean:
+        parts = s_clean.split(',')
+        if len(parts) >= 2:
+            try:
+                return float(parts[0]), float(parts[1])
+            except ValueError:
+                pass
+        elif len(parts) == 1:
+            try:
+                return float(parts[0]), 0.0
+            except ValueError:
+                pass
+
+    # Eski 'a+be' formatını destekle
+    if 'e' in s_clean:
+        try:
+            parts = s_clean.split('e')
+            finite = float(parts[0]) if parts[0] not in ['', '+', '-'] else 0.0
+            infinitesimal = float(parts[1]) if len(parts) > 1 and parts[1] not in ['', '+', '-'] else 1.0
+            return finite, infinitesimal
+        except ValueError:
+            pass
+    
+    # Sadece sayısal değer
+    try:
+        return float(s_clean), 0.0
+    except ValueError:
+        return 0.0, 0.0  # Default
+"""
+"""
+def _parse_quaternion_from_csv(s: str) -> np.quaternion:
+    #Virgülle ayrılmış string'i Quaternion'a dönüştürür.
+    #"w,x,y,z" veya sadece "w" (skaler) formatlarını destekler.
+
+    s = s.strip()
+    parts_str = s.split(',')
+    
+    # Tüm parçaları float'a dönüştürmeyi dene
+    try:
+        parts_float = [float(p.strip()) for p in parts_str]
+    except ValueError:
+        raise ValueError(f"Quaternion bileşenleri sayı olmalı: '{s}'")
+
+    if len(parts_float) == 4:
+        return np.quaternion(*parts_float)
+    elif len(parts_float) == 1: # Sadece skaler değer
+        return np.quaternion(parts_float[0], 0, 0, 0)
+    else:
+        raise ValueError(f"Geçersiz quaternion formatı. 1 veya 4 bileşen bekleniyor: '{s}'")
+"""
+"""
+def _has_comma_format(s: str) -> bool:
+    #String'in virgül içerip içermediğini kontrol eder.
+    return ',' in s
+"""
+"""
+def _parse_neutrosophic_bicomplex(s: str) -> NeutrosophicBicomplexNumber:
+
+    #Parses string like "a,b,c,d,e,f,g,h" into 8 components.
+
+    try:
+        parts = s.split(',')
+        if len(parts) != 8:
+            raise ValueError(f"Expected 8 components, got {len(parts)}")
+        values = [float(part.strip()) for part in parts]
+        return NeutrosophicBicomplexNumber(*values)
+    except Exception as e:
+        raise ValueError(f"Invalid NeutrosophicBicomplex format: '{s}' → {e}")
+"""
+
+def _parse_octonion(s) -> OctonionNumber:
+    """String'i veya sayıyı OctonionNumber'a dönüştürür.
+    w,x,y,z,e,f,g,h:e0,e1,e2,e3,e4,e5,e6,e7
+    """
+    # Eğer zaten OctonionNumber ise doğrudan döndür
+    if isinstance(s, OctonionNumber):
+        return s
+    
+    # Eğer sayısal tipse (float, int, complex) skaler olarak işle
+    if isinstance(s, (float, int, complex)):
+        scalar = float(s)
+        return OctonionNumber(scalar, 0, 0, 0, 0, 0, 0, 0)
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
+    s_clean = s.strip()
+    
+    # Eğer virgül içermiyorsa, skaler olarak kabul et
+    if ',' not in s_clean:
+        try:
+            scalar = float(s_clean)
+            return OctonionNumber(scalar, 0, 0, 0, 0, 0, 0, 0)
+        except ValueError:
+            raise ValueError(f"Invalid octonion format: '{s}'")
+    
+    # Virgülle ayrılmışsa
+    try:
+        parts = [float(p.strip()) for p in s_clean.split(',')]
+        if len(parts) == 8:
+            return OctonionNumber(*parts)  # 8 parametre olarak gönder
+        else:
+            # Eksik veya fazla bileşen için default
+            scalar = parts[0] if parts else 0.0
+            return OctonionNumber(scalar, 0, 0, 0, 0, 0, 0, 0)
+    except ValueError as e:
+        raise ValueError(f"Invalid octonion format: '{s}'") from e
+"""
 def _parse_octonion(s: str) -> OctonionNumber:
-    """'w,x,y,z,e,f,g,h' formatındaki stringi OctonionNumber'a çevirir."""
+    #'w,x,y,z,e,f,g,h' formatındaki stringi OctonionNumber'a çevirir.
     s_clean = s.strip()
     
     # Eğer virgül içermiyorsa, skaler olarak kabul et
@@ -1097,10 +1464,42 @@ def _parse_octonion(s: str) -> OctonionNumber:
             return OctonionNumber(scalar, 0, 0, 0, 0, 0, 0, 0)
     except ValueError as e:
         raise ValueError(f"Invalid octonion format: '{s}'") from e
+"""
 
+def _parse_sedenion(s) -> SedenionNumber:
+    """String'i veya sayıyı SedenionNumber'a dönüştürür."""
+    # Eğer zaten SedenionNumber ise doğrudan döndür
+    if isinstance(s, SedenionNumber):
+        return s
+    
+    # Eğer sayısal tipse (float, int, complex) skaler olarak işle
+    if isinstance(s, (float, int, complex)):
+        scalar_val = float(s)
+        return SedenionNumber([scalar_val] + [0.0] * 15)
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
+    s = s.strip()
+    parts = [p.strip() for p in s.split(',')]
 
+    if len(parts) == 16:
+        try:
+            return SedenionNumber(list(map(float, parts)))
+        except ValueError as e:
+            raise ValueError(f"Geçersiz sedenion bileşen değeri: '{s}' -> {e}") from e
+    elif len(parts) == 1: # Sadece skaler değer girildiğinde
+        try:
+            scalar_val = float(parts[0])
+            return SedenionNumber([scalar_val] + [0.0] * 15)
+        except ValueError as e:
+            raise ValueError(f"Geçersiz skaler sedenion değeri: '{s}' -> {e}") from e
+            
+    raise ValueError(f"Sedenion için 16 bileşen veya tek skaler bileşen gerekir. Verilen: '{s}' ({len(parts)} bileşen)")
+"""
 def _parse_sedenion(s: str) -> SedenionNumber:
-    """String'i SedenionNumber'a dönüştürür."""
+    #String'i SedenionNumber'a dönüştürür.
     s = s.strip()
     parts = [p.strip() for p in s.split(',')]
 
@@ -1117,9 +1516,109 @@ def _parse_sedenion(s: str) -> SedenionNumber:
             raise ValueError(f"Geçersiz skaler sedenion değeri: '{s}' -> {e}") from e
             
     raise ValueError(f"Sedenion için 16 bileşen veya tek skaler bileşen gerekir. Verilen: '{s}' ({len(parts)} bileşen)")
+"""
 
-def _parse_clifford(s: str) -> CliffordNumber:
+def _parse_clifford(s) -> CliffordNumber:
     """Algebraik string'i CliffordNumber'a dönüştürür (ör: '1.0+2.0e1')."""
+    if isinstance(s, CliffordNumber):
+        return s
+    
+    if isinstance(s, (float, int, complex)):
+        return CliffordNumber({'': float(s)})
+    
+    if not isinstance(s, str):
+        s = str(s)
+    
+    s = s.strip().replace(' ', '').replace('^', '')  # ^ işaretini kaldır
+    basis_dict = {}
+    
+    # Daha iyi regex pattern: +-1.23e12 formatını yakala
+    pattern = r'([+-]?)(\d*\.?\d+)(?:e(\d+))?|([+-]?)(?:e(\d+))'
+    matches = re.findall(pattern, s)
+    
+    for match in matches:
+        sign_str, coeff_str, basis1, sign_str2, basis2 = match
+        
+        # Hangi grup match oldu?
+        if coeff_str or basis1:
+            sign = -1.0 if sign_str == '-' else 1.0
+            coeff = float(coeff_str) if coeff_str else 1.0
+            basis_key = basis1 if basis1 else ''
+        else:
+            sign = -1.0 if sign_str2 == '-' else 1.0
+            coeff = 1.0
+            basis_key = basis2
+        
+        value = sign * coeff
+        basis_dict[basis_key] = basis_dict.get(basis_key, 0.0) + value
+    
+    # Ayrıca +e1, -e2 gibi ifadeleri yakala
+    pattern2 = r'([+-])e(\d+)'
+    matches2 = re.findall(pattern2, s)
+    
+    for sign_str, basis_key in matches2:
+        sign = -1.0 if sign_str == '-' else 1.0
+        basis_dict[basis_key] = basis_dict.get(basis_key, 0.0) + sign
+    
+    return CliffordNumber(basis_dict)
+"""
+
+def _parse_clifford(s) -> CliffordNumber:
+    #Algebraik string'i veya sayıyı CliffordNumber'a dönüştürür (ör: '1.0+2.0e1').
+    # Eğer zaten CliffordNumber ise doğrudan döndür
+    if isinstance(s, CliffordNumber):
+        return s
+    
+    # Eğer sayısal tipse (float, int, complex) skaler olarak işle
+    if isinstance(s, (float, int, complex)):
+        return CliffordNumber({'': float(s)})
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
+    s = s.strip().replace(' ', '')
+    basis_dict = {'': 0.0}  # Skaler kısım
+    
+    terms_pattern = re.compile(r"([+-]?)(\d*\.?\d+(?:[eE][+-]?\d+)?)?(e\d*)?")
+    remaining_s = s
+    
+    while remaining_s:
+        match = terms_pattern.match(remaining_s)
+        if not match or (match.group(2) is None and match.group(3) is None):
+            if remaining_s.startswith('+') or remaining_s.startswith('-'):
+                current_sign = remaining_s[0]
+                remaining_s = remaining_s[1:]
+                if not remaining_s:
+                    coeff = 1.0 if current_sign == '+' else -1.0
+                    basis_dict[''] = basis_dict.get('', 0.0) + coeff
+                continue
+            raise ValueError(f"Geçersiz Clifford terim formatı: '{remaining_s}'")
+
+        sign_str, coeff_str, basis_str_with_e = match.groups()
+        current_sign = 1.0
+        if sign_str == '-': current_sign = -1.0
+        
+        coeff = 1.0
+        if coeff_str: coeff = float(coeff_str)
+        elif not sign_str: coeff = 1.0
+        elif sign_str and not coeff_str: coeff = 1.0
+
+        coeff *= current_sign
+
+        if basis_str_with_e:
+            basis_key = basis_str_with_e.lstrip('e')
+            basis_dict[basis_key] = basis_dict.get(basis_key, 0.0) + coeff
+        else:
+            basis_dict[''] = basis_dict.get('', 0.0) + coeff
+        
+        remaining_s = remaining_s[match.end():]
+
+    return CliffordNumber(basis_dict)
+"""
+"""
+def _parse_clifford(s: str) -> CliffordNumber:
+    #Algebraik string'i CliffordNumber'a dönüştürür (ör: '1.0+2.0e1').
     s = s.strip().replace(' ', '')
     basis_dict = {'': 0.0}  # Skaler kısım
     
@@ -1158,9 +1657,41 @@ def _parse_clifford(s: str) -> CliffordNumber:
         remaining_s = remaining_s[match.end():]
 
     return CliffordNumber(basis_dict)
+"""
 
+def _parse_dual(s) -> DualNumber:
+    """String'i veya sayıyı DualNumber'a dönüştürür."""
+    # Eğer zaten DualNumber ise doğrudan döndür
+    if isinstance(s, DualNumber):
+        return s
+    
+    # Eğer sayısal tipse (float, int, complex) real kısım olarak işle
+    if isinstance(s, (float, int, complex)):
+        return DualNumber(float(s), 0.0)
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
+    s = s.strip()
+    parts = [p.strip() for p in s.split(',')]
+    
+    # Sadece ilk iki bileşeni al
+    if len(parts) >= 2:
+        try:
+            return DualNumber(float(parts[0]), float(parts[1]))
+        except ValueError:
+            pass
+    elif len(parts) == 1: # Sadece real kısım verilmiş
+        try:
+            return DualNumber(float(parts[0]), 0.0)
+        except ValueError:
+            pass
+            
+    raise ValueError(f"Geçersiz Dual sayı formatı: '{s}' (Real, Dual veya sadece Real bekleniyor)")
+"""
 def _parse_dual(s: str) -> DualNumber:
-    """Virgülle ayrılmış string'i DualNumber'a dönüştürür."""
+    #Virgülle ayrılmış string'i DualNumber'a dönüştürür.
     s = s.strip()
     parts = [p.strip() for p in s.split(',')]
     
@@ -1177,9 +1708,22 @@ def _parse_dual(s: str) -> DualNumber:
             pass
             
     raise ValueError(f"Geçersiz Dual sayı formatı: '{s}' (Real, Dual veya sadece Real bekleniyor)")
+"""
 
-def _parse_splitcomplex(s: str) -> SplitcomplexNumber:
-    """Virgülle ayrılmış string'i SplitcomplexNumber'a dönüştürür."""
+def _parse_splitcomplex(s) -> SplitcomplexNumber:
+    """String'i veya sayıyı SplitcomplexNumber'a dönüştürür."""
+    # Eğer zaten SplitcomplexNumber ise doğrudan döndür
+    if isinstance(s, SplitcomplexNumber):
+        return s
+    
+    # Eğer sayısal tipse (float, int, complex) real kısım olarak işle
+    if isinstance(s, (float, int, complex)):
+        return SplitcomplexNumber(float(s), 0.0)
+    
+    # String işlemleri için önce string'e dönüştür
+    if not isinstance(s, str):
+        s = str(s)
+    
     s = s.strip()
     parts = [p.strip() for p in s.split(',')]
 
@@ -1195,7 +1739,25 @@ def _parse_splitcomplex(s: str) -> SplitcomplexNumber:
             pass
             
     raise ValueError(f"Geçersiz Split-Complex sayı formatı: '{s}' (Real, Split veya sadece Real bekleniyor)")
+"""
+def _parse_splitcomplex(s: str) -> SplitcomplexNumber:
+    #Virgülle ayrılmış string'i SplitcomplexNumber'a dönüştürür.
+    s = s.strip()
+    parts = [p.strip() for p in s.split(',')]
 
+    if len(parts) == 2:
+        try:
+            return SplitcomplexNumber(float(parts[0]), float(parts[1]))
+        except ValueError:
+            pass
+    elif len(parts) == 1: # Sadece real kısım verilmiş
+        try:
+            return SplitcomplexNumber(float(parts[0]), 0.0)
+        except ValueError:
+            pass
+            
+    raise ValueError(f"Geçersiz Split-Complex sayı formatı: '{s}' (Real, Split veya sadece Real bekleniyor)")
+"""
 
 class Constants:
     """Oktonyon sabitleri."""
@@ -2485,8 +3047,8 @@ def get_interactive() -> Tuple[List[Any], Dict[str, Any]]:
         9: "Enter Hyperreal start (in 'finite,infinitesimal' format, e.g., '0.0,0.0001'): ",
         10: "Enter Bicomplex start (in 'z1_real,z1_imag,z2_real,z2_imag' format, e.g., '1.0,2.0,3.0,4.0', '1.0,2.0', '3.0', '1.0+1.0j'): ",
         11: "Enter Neutro-Bicomplex start (in 'r,i,nr,ni,jr,ji,jnr,jni' format, e.g., '1,2,0.1,0.2,0.3,0.4,0.5,0.6', '0.1'): ",
-        12: "Enter Octonion start (in 'e0,e1,e2,e3,e4,e5,e6,e7' format, e.g., '1.0,0.5,-0.2,0.3,0.1,-0.4,0.2,0.0'): ",
-        13: "Enter Sedenion start (in 'e0,e1,...,e15' format, e.g., '1.0', '0.0'): ",
+        12: "Enter Octonion start (in 'w,x,y,z,e,f,g,h':'e0,e1,e2,e3,e4,e5,e6,e7' format, e.g., '1.0,0.5,-0.2,0.3,0.1,-0.4,0.2,0.0'): ",
+        13: "Enter Sedenion start (in 'e0,e1,...,e15' format, e.g., '1.0,2.0,3.0,0,0,0,0,0,0,0,0,0,0,0,0,0', '0.0'): ",
         14: "Enter Clifford start (in 'scalar,e1,e2,e12,...' format, e.g., '0.1+0.2e1', '1.0+2.0e1+3.0e12'): ",
         15: "Enter Dual start (in 'real,dual' format, e.g., '2.0,0.5'): ",
         16: "Enter Split-Complex start (in 'real,split' format, e.g., '1.0,0.8'): ",
@@ -2505,8 +3067,8 @@ def get_interactive() -> Tuple[List[Any], Dict[str, Any]]:
         9: "Enter Hyperreal increment (in 'finite,infinitesimal' format, e.g., '0.0,0.0001'): ",
         10: "Enter Bicomplex increment (in 'z1_real,z1_imag,z2_real,z2_imag' format, e.g., '1.0,2.0,3.0,4.0', '1.0,2.0', '3.0', '1.0+1.0j'): ",
         11: "Enter Neutro-Bicomplex increment (in 'r,i,nr,ni,jr,ji,jnr,jni' format, e.g., '1,2,0.1,0.2,0.3,0.4,0.5,0.6', '0.1')): ",
-        12: "Enter Octonion increment (in 'e0,e1,e2,e3,e4,e5,e6,e7' format, e.g., '0.1', '0.0'): ",
-        13: "Enter Sedenion increment (in 'e0,e1,...,e15' format, e.g., '0.1', '0.0'): ",
+        12: "Enter Octonion increment (in 'w,x,y,z,e,f,g,h':'e0,e1,e2,e3,e4,e5,e6,e7' format, e.g., '1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0', '0.0'): ",
+        13: "Enter Sedenion increment (in 'e0,e1,...,e15' format, e.g., '1.0,2.0,3.0,0,0,0,0,0,0,0,0,0,0,0,0,0', '0.0'): ",
         14: "Enter Clifford increment (in 'scalar,e1,e2,e12,...' format, e.g., '0.1+0.2e1', '1.0+2.0e1+3.0e12'): ",
         15: "Enter Dual increment (in 'real,dual' format, e.g., 1.0, '0.1,0.0'): ",
         16: "Enter Split-Complex increment (in 'real,split' format, e.g., '0.1,0.0'): ",
@@ -2610,6 +3172,36 @@ def is_neutrosophic_like(obj):
            (hasattr(obj, 'value') and hasattr(obj, 'indeterminacy')) or \
            (hasattr(obj, 'determinate') and hasattr(obj, 'indeterminate'))
 
+# Yardımcı fonksiyon: Bileşen dağılımı grafiği
+def _plot_component_distribution(ax, elem, all_keys, seq_length=1):
+    """Bileşen dağılımını gösterir"""
+    if seq_length == 1:
+        # Tek veri noktası için bileşen değerleri
+        components = []
+        values = []
+        
+        for key in all_keys:
+            if key == '':
+                components.append('Scalar')
+            else:
+                components.append(f'e{key}')
+            values.append(elem.basis.get(key, 0.0))
+        
+        bars = ax.bar(components, values, alpha=0.7, color='tab:blue')
+        ax.set_title("Component Values")
+        ax.tick_params(axis='x', rotation=45)
+        
+        for bar in bars:
+            height = bar.get_height()
+            if height != 0:
+                ax.text(bar.get_x() + bar.get_width()/2., height,
+                       f'{height:.2f}', ha='center', va='bottom')
+    else:
+        # Çoklu veri ama PCA yapılamıyor
+        ax.text(0.5, 0.5, f"Need ≥2 data points and ≥2 features\n(Current: {seq_length} points, {len(all_keys)} features)", 
+               ha='center', va='center', transform=ax.transAxes, fontsize=11)
+        ax.set_title("Insufficient for PCA")
+
 def plot_numbers(sequence: List[Any], title: str = "Keçeci Number Sequence Analysis"):
     """
     Tüm 16 Keçeci Sayı türü için detaylı görselleştirme sağlar.
@@ -2618,6 +3210,13 @@ def plot_numbers(sequence: List[Any], title: str = "Keçeci Number Sequence Anal
         print("Sequence is empty. Nothing to plot.")
         return
 
+    try:
+        from sklearn.decomposition import PCA
+        use_pca = True
+    except ImportError:
+        use_pca = False
+        print("scikit-learn kurulu değil. PCA olmadan çizim yapılıyor...")
+
     fig = plt.figure(figsize=(18, 14), constrained_layout=True)
     fig.suptitle(title, fontsize=18, fontweight='bold')
 
@@ -2790,33 +3389,100 @@ def plot_numbers(sequence: List[Any], title: str = "Keçeci Number Sequence Anal
         values = {k: [elem.basis.get(k, 0.0) for elem in sequence] for k in all_keys}
         scalar = values.get('', [0]*len(sequence))
         vector_keys = [k for k in all_keys if len(k) == 1]
+        
+        # numpy import et
+        try:
+            import numpy as np
+            numpy_available = True
+        except ImportError:
+            numpy_available = False
+        
+        # GERÇEK özellik sayısını hesapla (sıfır olmayan bileşenler)
+        non_zero_features = 0
+        for key in all_keys:
+            if any(abs(elem.basis.get(key, 0.0)) > 1e-10 for elem in sequence):
+                non_zero_features += 1
+        
+        print(f"Debug: Total keys: {len(all_keys)}, Non-zero features: {non_zero_features}")
+        
+        # Her zaman 2x2 grid kullan
+        fig = plt.figure(figsize=(12, 10))
         gs = GridSpec(2, 2, figure=fig)
-
         ax1 = fig.add_subplot(gs[0, 0])
-        ax1.plot(scalar, 'o-', label='Scalar', color='black')
-        for k in vector_keys[:3]:
-            ax1.plot(values[k], label=f'Vec {k}', alpha=0.7)
-        ax1.set_title("Scalar & Vectors")
+        ax2 = fig.add_subplot(gs[0, 1])
+        ax3 = fig.add_subplot(gs[1, :])
+
+        # 1. Grafik: Skaler ve Vektör Bileşenleri
+        ax1.plot(scalar, 'o-', label='Scalar', color='black', linewidth=2)
+        
+        # Sadece sıfır olmayan vektör bileşenlerini göster
+        visible_vectors = 0
+        for k in vector_keys:
+            if any(abs(v) > 1e-10 for v in values[k]):
+                ax1.plot(values[k], 'o-', label=f'Vec {k}', alpha=0.7, linewidth=1.5)
+                visible_vectors += 1
+            if visible_vectors >= 3:
+                break
+        
+        ax1.set_title("Scalar & Vector Components Over Time")
         ax1.legend()
+        ax1.grid(True, alpha=0.3)
 
-        ax2 = fig.add_subplot(gs[0, 1])
+        # 2. Grafik: Bivector Magnitude
         bivector_mags = [sum(v**2 for k, v in elem.basis.items() if len(k) == 2)**0.5 for elem in sequence]
-        ax2.plot(bivector_mags, 'o-', color='tab:green')
-        ax2.set_title("Bivector Magnitude")
+        ax2.plot(bivector_mags, 'o-', color='tab:green', linewidth=2, label='Bivector Magnitude')
+        ax2.set_title("Bivector Magnitude Over Time")
+        ax2.legend()
+        ax2.grid(True, alpha=0.3)
 
-        try:
-            from sklearn.decomposition import PCA
-            matrix = np.array([list(v.values()) for v in values.values()]).T
-            pca = PCA(n_components=2)
-            if len(sequence) > 1:
+        # 3. Grafik: PCA - ARTIK PCA GÖSTERİYORUZ
+        if len(sequence) >= 2 and non_zero_features >= 2:
+            # PCA yapılabilir durumda
+            try:
+                from sklearn.decomposition import PCA
+                
+                # Tüm bileşenleri içeren matris oluştur
+                matrix_data = []
+                for elem in sequence:
+                    row = []
+                    for key in all_keys:
+                        row.append(elem.basis.get(key, 0.0))
+                    matrix_data.append(row)
+                
+                if numpy_available:
+                    matrix = np.array(matrix_data)
+                else:
+                    import numpy as np
+                    matrix = np.array(matrix_data)
+                
+                # PCA uygula
+                pca = PCA(n_components=min(2, matrix.shape[1]))
                 proj = pca.fit_transform(matrix)
-                ax3 = fig.add_subplot(gs[1, :])
-                sc = ax3.scatter(proj[:, 0], proj[:, 1], c=range(len(proj)), cmap='plasma')
-                ax3.set_title("Clifford PCA")
-                plt.colorbar(sc, ax=ax3, label="Component")
-        except:
-            ax3 = fig.add_subplot(gs[1, :])
-            ax3.text(0.5, 0.5, "Install sklearn for PCA", ha='center')
+                
+                sc = ax3.scatter(proj[:, 0], proj[:, 1], c=range(len(proj)), 
+                               cmap='plasma', s=50, alpha=0.8)
+                ax3.set_title(f"PCA Projection ({non_zero_features} features)\nVariance: {pca.explained_variance_ratio_[0]:.3f}, {pca.explained_variance_ratio_[1]:.3f}")
+                
+                cbar = plt.colorbar(sc, ax=ax3)
+                cbar.set_label("Time Step")
+                
+                ax3.plot(proj[:, 0], proj[:, 1], 'gray', linestyle='--', alpha=0.5)
+                ax3.grid(True, alpha=0.3)
+                    
+            except ImportError:
+                ax3.text(0.5, 0.5, "Install sklearn for PCA", 
+                        ha='center', va='center', transform=ax3.transAxes)
+            except Exception as e:
+                ax3.text(0.5, 0.5, f"PCA Error: {str(e)[:30]}", 
+                        ha='center', va='center', transform=ax3.transAxes)
+        else:
+            # PCA yapılamazsa bilgi göster
+            ax3.text(0.5, 0.5, f"Need ≥2 data points and ≥2 features\n(Current: {len(sequence)} points, {non_zero_features} features)", 
+                   ha='center', va='center', transform=ax3.transAxes)
+            ax3.set_title("Insufficient for PCA")
+
+        #plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
+
 
     # --- 8. DualNumber
     elif hasattr(first_elem, 'real') and hasattr(first_elem, 'dual'):

{kececinumbers-0.6.9.dist-info → kececinumbers-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.6.9
+Version: 0.7.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
@@ -141,7 +141,7 @@ This library provides a unified algorithm that operates on 16 different number t
 <details>
 <summary>🇹🇷 Türkçe Açıklama (Click to expand)</summary>
 
-**Keçeci Sayıları**, Collatz Varsayımı'ndan esinlenen ve farklı sayı sistemlerinde dinamik diziler üreten, analiz eden ve görselleştiren bir Python kütüphanesidir. Bu kütüphane, tamsayılardan karmaşık sayılara, kuaterniyonlardan nötrosofik sayılara kadar 11 farklı sayı türü üzerinde çalışan birleşik bir algoritma sunar. Akademik araştırmalar ve sayı teorisindeki keşifler için bir araç olarak tasarlanmıştır.
+**Keçeci Sayıları**, Collatz Varsayımı'ndan esinlenen ve farklı sayı sistemlerinde dinamik diziler üreten, analiz eden ve görselleştiren bir Python kütüphanesidir. Bu kütüphane, tamsayılardan karmaşık sayılara, kuaterniyonlardan nötrosofik sayılara kadar 16 farklı sayı türü üzerinde çalışan birleşik bir algoritma sunar. Akademik araştırmalar ve sayı teorisindeki keşifler için bir araç olarak tasarlanmıştır.
 
 </details>
 
@@ -165,7 +165,7 @@ This flexible mechanism provides a rich framework for studying the behavior of n
 *   **Advanced Visualization:** Provides a multi-dimensional `plot_numbers` function tailored to the nature of each number system.
 *   **Keçeci Prime Number (KPN) Analysis:** Identifies the most recurring prime representation in sequences to analyze their convergence behavior.
 *   **Interactive and Programmatic Usage:** Supports both interactive parameter input (`get_interactive`) and direct use in scripts (`get_with_params`).
-*   0.6.9: 16 Nubers
+*   0.7.1: 16 Numbers
 *   0.6.7: 11 Numbers
 
 ---
@@ -367,7 +367,8 @@ if seq_interactive:
     type_names = [
         "Positive Real", "Negative Real", "Complex", "Float", "Rational", 
         "Quaternion", "Neutrosophic", "Neutro-Complex", "Hyperreal", 
-        "Bicomplex", "Neutro-Bicomplex"
+        "Bicomplex", "Neutro-Bicomplex", "Octonion", "Sedenion", "Clifford",
+        "Dual", "Split-Complex"
     ]
     # type_name'i params sözlüğüne ekleyerek raporu zenginleştirelim
     params['type_name'] = type_names[type_choice - 1]

kececinumbers-0.7.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+docs/conf.py,sha256=jkpH_TchRJcC_EspKeY1E_rml2ODmIWhWoqvyCPu_ok,1116
+kececinumbers/__init__.py,sha256=xu86m_9hyxJEAJzn0rNqD2fee1KHv68S_lH-C2tgWj4,8473
+kececinumbers/_version.py,sha256=UKtHtm7N84E6BrPGq2nQkqcNcflKksJqe_V-1gJwHb0,453
+kececinumbers/kececinumbers.py,sha256=eak738SZHtoO9lwHi_DbNGNhSKoIHrYdmWR7RY0E9WA,149453
+kececinumbers-0.7.1.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
+tests/test_sample.py,sha256=vwGbEZ6gcEFq60P5Sqrnc_DVw2QFXOSU1vm3GyzQMnc,9628
+kececinumbers-0.7.1.dist-info/METADATA,sha256=Us-mqQxpWZBP6CqiDL0CDXyGCeQroeELkZ9twGkT-QA,34956
+kececinumbers-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kececinumbers-0.7.1.dist-info/top_level.txt,sha256=ABQEKRH9iYb4sWnFdx7gIx7Hg899YktRkQpbRlSSqwU,25
+kececinumbers-0.7.1.dist-info/RECORD,,

kececinumbers-0.6.9.dist-info/RECORD

@@ -1,10 +0,0 @@
-docs/conf.py,sha256=jkpH_TchRJcC_EspKeY1E_rml2ODmIWhWoqvyCPu_ok,1116
-kececinumbers/__init__.py,sha256=hcp5N1niet4RTCVLHFER1Trne3N4rkr7FuTOYmW5CF8,8399
-kececinumbers/_version.py,sha256=99vsIW2hk-mcMeKtSlgQTxyLR5WE8y25YIUWf5X9jjA,453
-kececinumbers/kececinumbers.py,sha256=dtGfkAwjoJRC0j06XV2P2JF0F78k1bZ7UbfJ8xb5wU0,125125
-kececinumbers-0.6.9.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
-tests/test_sample.py,sha256=vwGbEZ6gcEFq60P5Sqrnc_DVw2QFXOSU1vm3GyzQMnc,9628
-kececinumbers-0.6.9.dist-info/METADATA,sha256=WTf4gVAJKivHi6eN-bRZaOxyb1JctKarq_DfaZIBSV8,34886
-kececinumbers-0.6.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kececinumbers-0.6.9.dist-info/top_level.txt,sha256=ABQEKRH9iYb4sWnFdx7gIx7Hg899YktRkQpbRlSSqwU,25
-kececinumbers-0.6.9.dist-info/RECORD,,