Rehber Python ile kendi hesap makinenizi yapın: OOP ve algoritma mantığı!

class TemelIslemler:
    """Temel matematiksel işlemler"""
    @staticmethod
    def topla(*sayilar: float) -> float:
        if not sayilar:
            raise HesapMakinesiHatasi("En az bir sayı girilmelidir")
        return sum(sayilar)

def __mul__(self, diger):
    # Boyut kontrolü yapıyoruz
    if self.sutun != diger.satir:
        raise HesapMakinesiHatasi("Boyutlar uyuşmuyor aga!")
    # Çarpım işlemi burada dönüyor (3 tane iç içe döngü, biraz beyin yakar)
    sonuc = [
        [ sum(self.veri[i][k] * diger.veri[k][j] for k in range(self.sutun))
          for j in range(diger.sutun) ]
        for i in range(self.satir)
    ]

try:
    sonuc = eval(giris, {...})
except HesapMakinesiHatasi as e:
    print(f" ⚠️ Hata: {e}")
except ZeroDivisionError:
    print(" ⚠️ Hata: Sıfıra bölme yapamazsın!")

"""
Üst Düzey Hesap Makinesi v2.0
Özellikler:
- Temel matematiksel işlemler (+, -, *, /, //, %, **)
- Bilimsel hesaplamalar (trigonometri, logaritma, vb.)
- Matris işlemleri
- İstatistiksel hesaplamalar
- Denklem çözücü
- Birim dönüştürücü
- Geçmiş kayıtları
- Hata yönetimi
"""

import math
import cmath
import statistics
import re
from typing import Union, List, Tuple, Optional
from decimal import Decimal, InvalidOperation, getcontext
from fractions import Fraction
from datetime import datetime

# Yüksek hassasiyet için
getcontext().prec = 50

class HesapMakinesiHatasi(Exception):
    """Özel hata sınıfı"""
    pass

class Gecmis:
    """İşlem geçmişi yönetimi"""
    def __init__(self, maksimum: int = 100):
        self._kayitlar: List[dict] = []
        self._maksimum = maksimum

    def ekle(self, islem: str, sonuc: any, kategori: str = "genel"):
        kayit = {
            "zaman": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "islem": islem,
            "sonuc": sonuc,
            "kategori": kategori
        }
        self._kayitlar.append(kayit)
        if len(self._kayitlar) > self._maksimum:
            self._kayitlar.pop(0)

    def listele(self, adet: int = 10) -> List[dict]:
        return self._kayitlar[-adet:]

    def temizle(self):
        self._kayitlar.clear()

    def son_sonuc(self) -> any:
        if self._kayitlar:
            return self._kayitlar[-1]["sonuc"]
        return None

class TemelIslemler:
    """Temel matematiksel işlemler"""
   
    @staticmethod
    def topla(*sayilar: float) -> float:
        """Sınırsız sayıda sayı toplar"""
        if not sayilar:
            raise HesapMakinesiHatasi("En az bir sayı girilmelidir")
        return sum(sayilar)

    @staticmethod
    def cikar(a: float, b: float) -> float:
        """Çıkarma işlemi"""
        return a - b

    @staticmethod
    def carp(*sayilar: float) -> float:
        """Sınırsız sayıda sayı çarpar"""
        if not sayilar:
            raise HesapMakinesiHatasi("En az bir sayı girilmelidir")
        sonuc = 1
        for sayi in sayilar:
            sonuc *= sayi
        return sonuc

    @staticmethod
    def bol(a: float, b: float) -> float:
        """Bölme işlemi"""
        if b == 0:
            raise HesapMakinesiHatasi("Sıfıra bölme hatası!")
        return a / b

    @staticmethod
    def tam_bolme(a: float, b: float) -> int:
        """Tam sayı bölme"""
        if b == 0:
            raise HesapMakinesiHatasi("Sıfıra bölme hatası!")
        return int(a // b)

    @staticmethod
    def mod(a: float, b: float) -> float:
        """Mod alma (kalan)"""
        if b == 0:
            raise HesapMakinesiHatasi("Sıfıra bölme hatası!")
        return a % b

    @staticmethod
    def us(taban: float, us: float) -> float:
        """Üs alma"""
        try:
            sonuc = taban ** us
            if isinstance(sonuc, complex):
                return sonuc
            return sonuc
        except OverflowError:
            raise HesapMakinesiHatasi("Sonuç çok büyük!")

    @staticmethod
    def kok(sayi: float, derece: int = 2) -> Union[float, complex]:
        """N. dereceden kök"""
        if derece == 0:
            raise HesapMakinesiHatasi("0. dereceden kök alınamaz!")
       
        if sayi < 0 and derece % 2 == 0:
            return cmath.sqrt(sayi) if derece == 2 else sayi ** (1/derece)
       
        return sayi ** (1/derece)

    @staticmethod
    def mutlak_deger(sayi: float) -> float:
        """Mutlak değer"""
        return abs(sayi)

    @staticmethod
    def yuvarla(sayi: float, basamak: int = 0) -> float:
        """Yuvarlama"""
        return round(sayi, basamak)

class BilimselIslemler:
    """Bilimsel hesaplamalar"""
   
    # Trigonometrik fonksiyonlar
    @staticmethod
    def sin(aci: float, birim: str = "derece") -> float:
        """Sinüs"""
        if birim == "derece":
            aci = math.radians(aci)
        return round(math.sin(aci), 15)

    @staticmethod
    def cos(aci: float, birim: str = "derece") -> float:
        """Kosinüs"""
        if birim == "derece":
            aci = math.radians(aci)
        return round(math.cos(aci), 15)

    @staticmethod
    def tan(aci: float, birim: str = "derece") -> float:
        """Tanjant"""
        if birim == "derece":
            aci = math.radians(aci)
       
        cos_val = math.cos(aci)
        if abs(cos_val) < 1e-15:
            raise HesapMakinesiHatasi("Tanjant bu açı için tanımsız!")
           
        return round(math.tan(aci), 15)

    @staticmethod
    def cot(aci: float, birim: str = "derece") -> float:
        """Kotanjant"""
        if birim == "derece":
            aci = math.radians(aci)
           
        sin_val = math.sin(aci)
        if abs(sin_val) < 1e-15:
            raise HesapMakinesiHatasi("Kotanjant bu açı için tanımsız!")
           
        return round(1 / math.tan(aci), 15)

    @staticmethod
    def sec(aci: float, birim: str = "derece") -> float:
        """Sekant"""
        if birim == "derece":
            aci = math.radians(aci)
           
        cos_val = math.cos(aci)
        if abs(cos_val) < 1e-15:
            raise HesapMakinesiHatasi("Sekant bu açı için tanımsız!")
           
        return round(1 / cos_val, 15)

    @staticmethod
    def csc(aci: float, birim: str = "derece") -> float:
        """Kosekant"""
        if birim == "derece":
            aci = math.radians(aci)
           
        sin_val = math.sin(aci)
        if abs(sin_val) < 1e-15:
            raise HesapMakinesiHatasi("Kosekant bu açı için tanımsız!")
           
        return round(1 / sin_val, 15)

    # Ters trigonometrik fonksiyonlar
    @staticmethod
    def arcsin(deger: float, birim: str = "derece") -> float:
        """Ters sinüs"""
        if not -1 <= deger <= 1:
            raise HesapMakinesiHatasi("arcsin için değer -1 ile 1 arasında olmalı!")
       
        sonuc = math.asin(deger)
        if birim == "derece":
            sonuc = math.degrees(sonuc)
        return round(sonuc, 10)

    @staticmethod
    def arccos(deger: float, birim: str = "derece") -> float:
        """Ters kosinüs"""
        if not -1 <= deger <= 1:
            raise HesapMakinesiHatasi("arccos için değer -1 ile 1 arasında olmalı!")
           
        sonuc = math.acos(deger)
        if birim == "derece":
            sonuc = math.degrees(sonuc)
        return round(sonuc, 10)

    @staticmethod
    def arctan(deger: float, birim: str = "derece") -> float:
        """Ters tanjant"""
        sonuc = math.atan(deger)
        if birim == "derece":
            sonuc = math.degrees(sonuc)
        return round(sonuc, 10)

    # Logaritmik fonksiyonlar
    @staticmethod
    def log(sayi: float, taban: float = 10) -> float:
        """Logaritma"""
        if sayi <= 0:
            raise HesapMakinesiHatasi("Logaritma için sayı pozitif olmalı!")
        if taban <= 0 or taban == 1:
            raise HesapMakinesiHatasi("Logaritma tabanı pozitif ve 1'den farklı olmalı!")
           
        return math.log(sayi, taban)

    @staticmethod
    def ln(sayi: float) -> float:
        """Doğal logaritma"""
        if sayi <= 0:
            raise HesapMakinesiHatasi("Logaritma için sayı pozitif olmalı!")
        return math.log(sayi)

    @staticmethod
    def log2(sayi: float) -> float:
        """2 tabanında logaritma"""
        if sayi <= 0:
            raise HesapMakinesiHatasi("Logaritma için sayı pozitif olmalı!")
        return math.log2(sayi)

    @staticmethod
    def log10(sayi: float) -> float:
        """10 tabanında logaritma"""
        if sayi <= 0:
            raise HesapMakinesiHatasi("Logaritma için sayı pozitif olmalı!")
        return math.log10(sayi)

    # Üstel fonksiyonlar
    @staticmethod
    def exp(x: float) -> float:
        """e^x"""
        try:
            return math.exp(x)
        except OverflowError:
            raise HesapMakinesiHatasi("Sonuç çok büyük!")

    # Hiperbolik fonksiyonlar
    @staticmethod
    def sinh(x: float) -> float:
        """Hiperbolik sinüs"""
        return math.sinh(x)

    @staticmethod
    def cosh(x: float) -> float:
        """Hiperbolik kosinüs"""
        return math.cosh(x)

    @staticmethod
    def tanh(x: float) -> float:
        """Hiperbolik tanjant"""
        return math.tanh(x)

    # Özel fonksiyonlar
    @staticmethod
    def faktoriyel(n: int) -> int:
        """Faktöriyel"""
        if not isinstance(n, int) or n < 0:
            raise HesapMakinesiHatasi("Faktöriyel için negatif olmayan tam sayı gerekli!")
        if n > 1000:
            raise HesapMakinesiHatasi("Faktöriyel için sayı çok büyük (max: 1000)!")
        return math.factorial(n)

    @staticmethod
    def permutasyon(n: int, r: int) -> int:
        """Permütasyon P(n,r)"""
        if n < 0 or r < 0:
            raise HesapMakinesiHatasi("Negatif değer girilemez!")
        if r > n:
            raise HesapMakinesiHatasi("r, n'den büyük olamaz!")
        return math.perm(n, r)

    @staticmethod
    def kombinasyon(n: int, r: int) -> int:
        """Kombinasyon C(n,r)"""
        if n < 0 or r < 0:
            raise HesapMakinesiHatasi("Negatif değer girilemez!")
        if r > n:
            raise HesapMakinesiHatasi("r, n'den büyük olamaz!")
        return math.comb(n, r)

    @staticmethod
    def gcd(*sayilar: int) -> int:
        """En büyük ortak bölen (EBOB)"""
        if len(sayilar) < 2:
            raise HesapMakinesiHatasi("En az 2 sayı gerekli!")
        sonuc = sayilar[0]
        for sayi in sayilar[1:]:
            sonuc = math.gcd(sonuc, sayi)
        return sonuc

    @staticmethod
    def lcm(*sayilar: int) -> int:
        """En küçük ortak kat (EKOK)"""
        if len(sayilar) < 2:
            raise HesapMakinesiHatasi("En az 2 sayı gerekli!")
        sonuc = sayilar[0]
        for sayi in sayilar[1:]:
            sonuc = sonuc * sayi // math.gcd(sonuc, sayi)
        return sonuc

class Istatistik:
    """İstatistiksel hesaplamalar"""
   
    @staticmethod
    def _kontrol(veriler: List[float]):
        if not veriler:
            raise HesapMakinesiHatasi("Veri listesi boş olamaz!")

    @staticmethod
    def ortalama(veriler: List[float]) -> float:
        """Aritmetik ortalama"""
        Istatistik._kontrol(veriler)
        return statistics.mean(veriler)

    @staticmethod
    def medyan(veriler: List[float]) -> float:
        """Medyan"""
        Istatistik._kontrol(veriler)
        return statistics.median(veriler)

    @staticmethod
    def mod(veriler: List[float]) -> float:
        """Mod (en sık tekrar eden)"""
        Istatistik._kontrol(veriler)
        try:
            return statistics.mode(veriler)
        except statistics.StatisticsError:
            raise HesapMakinesiHatasi("Benzersiz mod bulunamadı!")

    @staticmethod
    def varyans(veriler: List[float], orneklem: bool = True) -> float:
        """Varyans"""
        Istatistik._kontrol(veriler)
        if len(veriler) < 2:
            raise HesapMakinesiHatasi("Varyans için en az 2 veri gerekli!")
       
        if orneklem:
            return statistics.variance(veriler)
        return statistics.pvariance(veriler)

    @staticmethod
    def standart_sapma(veriler: List[float], orneklem: bool = True) -> float:
        """Standart sapma"""
        Istatistik._kontrol(veriler)
        if len(veriler) < 2:
            raise HesapMakinesiHatasi("Standart sapma için en az 2 veri gerekli!")
           
        if orneklem:
            return statistics.stdev(veriler)
        return statistics.pstdev(veriler)

    @staticmethod
    def minimum(veriler: List[float]) -> float:
        """Minimum değer"""
        Istatistik._kontrol(veriler)
        return min(veriler)

    @staticmethod
    def maksimum(veriler: List[float]) -> float:
        """Maksimum değer"""
        Istatistik._kontrol(veriler)
        return max(veriler)

    @staticmethod
    def aralik(veriler: List[float]) -> float:
        """Aralık (max - min)"""
        Istatistik._kontrol(veriler)
        return max(veriler) - min(veriler)

    @staticmethod
    def toplam(veriler: List[float]) -> float:
        """Toplam"""
        Istatistik._kontrol(veriler)
        return sum(veriler)

    @staticmethod
    def geometrik_ortalama(veriler: List[float]) -> float:
        """Geometrik ortalama"""
        Istatistik._kontrol(veriler)
        if any(v <= 0 for v in veriler):
            raise HesapMakinesiHatasi("Geometrik ortalama için tüm değerler pozitif olmalı!")
        return statistics.geometric_mean(veriler)

    @staticmethod
    def harmonik_ortalama(veriler: List[float]) -> float:
        """Harmonik ortalama"""
        Istatistik._kontrol(veriler)
        if any(v <= 0 for v in veriler):
            raise HesapMakinesiHatasi("Harmonik ortalama için tüm değerler pozitif olmalı!")
        return statistics.harmonic_mean(veriler)

    @staticmethod
    def ceyrekler(veriler: List[float]) -> dict:
        """Çeyrekler (Q1, Q2, Q3)"""
        Istatistik._kontrol(veriler)
        if len(veriler) < 4:
            raise HesapMakinesiHatasi("Çeyrekler için en az 4 veri gerekli!")
           
        sirali = sorted(veriler)
        n = len(sirali)
       
        return {
            "Q1": statistics.median(sirali[:n//2]),
            "Q2": statistics.median(sirali),
            "Q3": statistics.median(sirali[(n+1)//2:])
        }

class Matris:
    """Matris işlemleri"""
    def __init__(self, veri: List[List[float]]):
        self._dogrula(veri)
        self.veri = veri
        self.satir = len(veri)
        self.sutun = len(veri[0]) if veri else 0

    @staticmethod
    def _dogrula(veri: List[List[float]]):
        if not veri:
            raise HesapMakinesiHatasi("Matris boş olamaz!")
        ilk_uzunluk = len(veri[0])
        for satir in veri:
            if len(satir) != ilk_uzunluk:
                raise HesapMakinesiHatasi("Tüm satırlar aynı uzunlukta olmalı!")

    def __repr__(self):
        satirlar = []
        for satir in self.veri:
            satirlar.append("[" + ", ".join(f"{x:8.3f}" for x in satir) + "]")
        return "[\n  " + "\n  ".join(satirlar) + "\n]"

    def __add__(self, diger: 'Matris') -> 'Matris':
        if self.satir != diger.satir or self.sutun != diger.sutun:
            raise HesapMakinesiHatasi("Matris boyutları uyuşmuyor!")
       
        sonuc = [
            [self.veri[i][j] + diger.veri[i][j] for j in range(self.sutun)]
            for i in range(self.satir)
        ]
        return Matris(sonuc)

    def __sub__(self, diger: 'Matris') -> 'Matris':
        if self.satir != diger.satir or self.sutun != diger.sutun:
            raise HesapMakinesiHatasi("Matris boyutları uyuşmuyor!")
       
        sonuc = [
            [self.veri[i][j] - diger.veri[i][j] for j in range(self.sutun)]
            for i in range(self.satir)
        ]
        return Matris(sonuc)

    def __mul__(self, diger: Union['Matris', float]) -> 'Matris':
        if isinstance(diger, (int, float)):
            sonuc = [
                [self.veri[i][j] * diger for j in range(self.sutun)]
                for i in range(self.satir)
            ]
            return Matris(sonuc)
       
        if self.sutun != diger.satir:
            raise HesapMakinesiHatasi(
                f"Matris çarpımı için A'nın sütun sayısı ({self.sutun}) "
                f"B'nin satır sayısına ({diger.satir}) eşit olmalı!"
            )
           
        sonuc = [
            [
                sum(self.veri[i][k] * diger.veri[k][j] for k in range(self.sutun))
                for j in range(diger.sutun)
            ]
            for i in range(self.satir)
        ]
        return Matris(sonuc)

    def transpoz(self) -> 'Matris':
        """Transpoz"""
        sonuc = [
            [self.veri[j][i] for j in range(self.satir)]
            for i in range(self.sutun)
        ]
        return Matris(sonuc)

    def determinant(self) -> float:
        """Determinant (sadece kare matrisler)"""
        if self.satir != self.sutun:
            raise HesapMakinesiHatasi("Determinant için kare matris gerekli!")
           
        n = self.satir
        mat = [satir[:] for satir in self.veri] # Kopya
        det = 1
       
        for i in range(n):
            # Pivot seçimi
            max_row = i
            for k in range(i + 1, n):
                if abs(mat[k][i]) > abs(mat[max_row][i]):
                    max_row = k
           
            if max_row != i:
                mat[i], mat[max_row] = mat[max_row], mat[i]
                det *= -1
               
            if abs(mat[i][i]) < 1e-12:
                return 0
               
            det *= mat[i][i]
           
            for k in range(i + 1, n):
                factor = mat[k][i] / mat[i][i]
                for j in range(i, n):
                    mat[k][j] -= factor * mat[i][j]
                   
        return det

    def iz(self) -> float:
        """İz (trace) - köşegen elemanların toplamı"""
        if self.satir != self.sutun:
            raise HesapMakinesiHatasi("İz için kare matris gerekli!")
        return sum(self.veri[i][i] for i in range(self.satir))

    def ters(self) -> 'Matris':
        """Ters matris"""
        if self.satir != self.sutun:
            raise HesapMakinesiHatasi("Ters matris için kare matris gerekli!")
           
        n = self.satir
        det = self.determinant()
        if abs(det) < 1e-12:
            raise HesapMakinesiHatasi("Matrisin tersi yok (determinant = 0)!")
           
        # Augmented matrix [A|I]
        aug = [self.veri[i][:] + [1 if i == j else 0 for j in range(n)] for i in range(n)]
       
        # Gauss-Jordan eliminasyonu
        for i in range(n):
            max_row = i
            for k in range(i + 1, n):
                if abs(aug[k][i]) > abs(aug[max_row][i]):
                    max_row = k
            aug[i], aug[max_row] = aug[max_row], aug[i]
           
            pivot = aug[i][i]
            for j in range(2 * n):
                aug[i][j] /= pivot
               
            for k in range(n):
                if k != i:
                    factor = aug[k][i]
                    for j in range(2 * n):
                        aug[k][j] -= factor * aug[i][j]
                       
        sonuc = [aug[i][n:] for i in range(n)]
        return Matris(sonuc)

    @staticmethod
    def birim(n: int) -> 'Matris':
        """n x n birim matris"""
        return Matris([[1 if i == j else 0 for j in range(n)] for i in range(n)])

    @staticmethod
    def sifir(satir: int, sutun: int) -> 'Matris':
        """Sıfır matris"""
        return Matris([[0 for _ in range(sutun)] for _ in range(satir)])

class DenklemCozucu:
    """Denklem çözme işlemleri"""
   
    @staticmethod
    def birinci_derece(a: float, b: float) -> float:
        """ax + b = 0 çözümü"""
        if a == 0:
            if b == 0:
                raise HesapMakinesiHatasi("Sonsuz çözüm var!")
            raise HesapMakinesiHatasi("Çözüm yok!")
        return -b / a

    @staticmethod
    def ikinci_derece(a: float, b: float, c: float) -> Tuple[complex, complex]:
        """ax² + bx + c = 0 çözümü"""
        if a == 0:
            if b == 0:
                raise HesapMakinesiHatasi("Bu bir denklem değil!")
            return (DenklemCozucu.birinci_derece(b, c), None)
           
        delta = b**2 - 4*a*c
       
        if delta >= 0:
            x1 = (-b + math.sqrt(delta)) / (2*a)
            x2 = (-b - math.sqrt(delta)) / (2*a)
        else:
            x1 = (-b + cmath.sqrt(delta)) / (2*a)
            x2 = (-b - cmath.sqrt(delta)) / (2*a)
           
        return (x1, x2)

    @staticmethod
    def ucuncu_derece(a: float, b: float, c: float, d: float) -> Tuple[complex, complex, complex]:
        """ax³ + bx² + cx + d = 0 çözümü (Cardano formülü)"""
        if a == 0:
            return DenklemCozucu.ikinci_derece(b, c, d) + (None,)
           
        # Normalize
        b, c, d = b/a, c/a, d/a
       
        # Depressed cubic: t³ + pt + q = 0
        p = c - b**2/3
        q = 2*b**3/27 - b*c/3 + d
       
        delta = (q/2)**2 + (p/3)**3
       
        if abs(delta) < 1e-12:
            delta = 0
           
        if delta > 0:
            u = (-q/2 + cmath.sqrt(delta))**(1/3)
            v = (-q/2 - cmath.sqrt(delta))**(1/3)
        else:
            u = complex(-q/2 + cmath.sqrt(delta))**(1/3)
            v = complex(-q/2 - cmath.sqrt(delta))**(1/3)
           
        omega = complex(-0.5, math.sqrt(3)/2)
       
        t1 = u + v
        t2 = omega * u + omega**2 * v
        t3 = omega**2 * u + omega * v
       
        x1 = t1 - b/3
        x2 = t2 - b/3
        x3 = t3 - b/3
       
        # Gerçek kısımları yuvarla
        def temizle(z):
            if isinstance(z, complex):
                if abs(z.imag) < 1e-10:
                    return round(z.real, 10)
                return complex(round(z.real, 10), round(z.imag, 10))
            return round(z, 10)
           
        return (temizle(x1), temizle(x2), temizle(x3))

    @staticmethod
    def lineer_sistem_2x2(a1: float, b1: float, c1: float, a2: float, b2: float, c2: float) -> Tuple[float, float]:
        """
        2 bilinmeyenli denklem sistemi:
        a1*x + b1*y = c1
        a2*x + b2*y = c2
        """
        det = a1*b2 - a2*b1
        if abs(det) < 1e-12:
            raise HesapMakinesiHatasi("Sistemin tek çözümü yok!")
           
        x = (c1*b2 - c2*b1) / det
        y = (a1*c2 - a2*c1) / det
        return (x, y)

    @staticmethod
    def lineer_sistem_3x3(katsayilar: List[List[float]], sonuclar: List[float]) -> Tuple[float, float, float]:
        """
        3 bilinmeyenli denklem sistemi (Cramer kuralı)
        """
        A = Matris(katsayilar)
        det_A = A.determinant()
       
        if abs(det_A) < 1e-12:
            raise HesapMakinesiHatasi("Sistemin tek çözümü yok!")
           
        cozumler = []
        for i in range(3):
            Ai = [satir[:] for satir in katsayilar]
            for j in range(3):
                Ai[j][i] = sonuclar[j]
            det_Ai = Matris(Ai).determinant()
            cozumler.append(det_Ai / det_A)
           
        return tuple(cozumler)

class BirimDonusturucu:
    """Birim dönüşümleri"""
   
    # Uzunluk birimleri (metre cinsinden)
    UZUNLUK = {
        "m": 1, "km": 1000, "cm": 0.01, "mm": 0.001,
        "mikron": 1e-6, "nm": 1e-9, "mil": 1609.344,
        "yard": 0.9144, "feet": 0.3048, "inc": 0.0254,
        "deniz_mili": 1852
    }
   
    # Kütle birimleri (kilogram cinsinden)
    KUTLE = {
        "kg": 1, "g": 0.001, "mg": 1e-6, "ton": 1000,
        "lb": 0.453592, "oz": 0.0283495
    }
   
    # Zaman birimleri (saniye cinsinden)
    ZAMAN = {
        "s": 1, "ms": 0.001, "dakika": 60, "saat": 3600,
        "gun": 86400, "hafta": 604800, "yil": 31536000
    }
   
    # Alan birimleri (metrekare cinsinden)
    ALAN = {
        "m2": 1, "km2": 1e6, "cm2": 1e-4, "mm2": 1e-6,
        "hektar": 10000, "donum": 1000, "acre": 4046.86
    }
   
    # Hacim birimleri (litre cinsinden)
    HACIM = {
        "L": 1, "mL": 0.001, "m3": 1000, "cm3": 0.001,
        "galon": 3.78541
    }

    @staticmethod
    def donustur(deger: float, kaynak: str, hedef: str, tur: str) -> float:
        """Birim dönüştürme"""
        birimler = {
            "uzunluk": BirimDonusturucu.UZUNLUK,
            "kutle": BirimDonusturucu.KUTLE,
            "zaman": BirimDonusturucu.ZAMAN,
            "alan": BirimDonusturucu.ALAN,
            "hacim": BirimDonusturucu.HACIM
        }
       
        if tur not in birimler:
            raise HesapMakinesiHatasi(f"Bilinmeyen tür: {tur}")
           
        birim_dict = birimler[tur]
        if kaynak not in birim_dict:
            raise HesapMakinesiHatasi(f"Bilinmeyen kaynak birim: {kaynak}")
        if hedef not in birim_dict:
            raise HesapMakinesiHatasi(f"Bilinmeyen hedef birim: {hedef}")
           
        # Önce temel birime çevir, sonra hedef birime
        temel = deger * birim_dict[kaynak]
        sonuc = temel / birim_dict[hedef]
        return sonuc

    @staticmethod
    def sicaklik(deger: float, kaynak: str, hedef: str) -> float:
        """Sıcaklık dönüşümü"""
        birimler = ["C", "F", "K"]
        kaynak, hedef = kaynak.upper(), hedef.upper()
       
        if kaynak not in birimler or hedef not in birimler:
            raise HesapMakinesiHatasi("Geçerli birimler: C, F, K")
           
        # Önce Celsius'a çevir
        if kaynak == "C":
            celsius = deger
        elif kaynak == "F":
            celsius = (deger - 32) * 5/9
        else: # K
            celsius = deger - 273.15
           
        # Hedef birime çevir
        if hedef == "C":
            return celsius
        elif hedef == "F":
            return celsius * 9/5 + 32
        else: # K
            return celsius + 273.15

    @staticmethod
    def aci(deger: float, kaynak: str, hedef: str) -> float:
        """Açı dönüşümü"""
        if kaynak == "derece" and hedef == "radyan":
            return math.radians(deger)
        elif kaynak == "radyan" and hedef == "derece":
            return math.degrees(deger)
        elif kaynak == "derece" and hedef == "grad":
            return deger * 10/9
        elif kaynak == "grad" and hedef == "derece":
            return deger * 9/10
        elif kaynak == "radyan" and hedef == "grad":
            return math.degrees(deger) * 10/9
        elif kaynak == "grad" and hedef == "radyan":
            return math.radians(deger * 9/10)
        elif kaynak == hedef:
            return deger
        else:
            raise HesapMakinesiHatasi("Geçerli birimler: derece, radyan, grad")

class SayiSistemleri:
    """Sayı sistemleri dönüşümleri"""
   
    @staticmethod
    def onluk_to_ikilik(sayi: int) -> str:
        """10'luk -> 2'lik"""
        if sayi < 0:
            return "-" + bin(abs(sayi))[2:]
        return bin(sayi)[2:]

    @staticmethod
    def onluk_to_sekizlik(sayi: int) -> str:
        """10'luk -> 8'lik"""
        if sayi < 0:
            return "-" + oct(abs(sayi))[2:]
        return oct(sayi)[2:]

    @staticmethod
    def onluk_to_onaltilik(sayi: int) -> str:
        """10'luk -> 16'lık"""
        if sayi < 0:
            return "-" + hex(abs(sayi))[2:].upper()
        return hex(sayi)[2:].upper()

    @staticmethod
    def ikilik_to_onluk(sayi: str) -> int:
        """2'lik -> 10'luk"""
        return int(sayi, 2)

    @staticmethod
    def sekizlik_to_onluk(sayi: str) -> int:
        """8'lik -> 10'luk"""
        return int(sayi, 8)

    @staticmethod
    def onaltilik_to_onluk(sayi: str) -> int:
        """16'lık -> 10'luk"""
        return int(sayi, 16)

    @staticmethod
    def donustur(sayi: str, kaynak_taban: int, hedef_taban: int) -> str:
        """Genel taban dönüşümü (2-36 arası)"""
        if not 2 <= kaynak_taban <= 36 or not 2 <= hedef_taban <= 36:
            raise HesapMakinesiHatasi("Taban 2-36 arasında olmalı!")
           
        # Önce 10'luk sisteme çevir
        onluk = int(sayi, kaynak_taban)
        if hedef_taban == 10:
            return str(onluk)
           
        # 10'luktan hedef tabana çevir
        if onluk == 0:
            return "0"
           
        negatif = onluk < 0
        onluk = abs(onluk)
        karakterler = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        sonuc = ""
       
        while onluk > 0:
            sonuc = karakterler[onluk % hedef_taban] + sonuc
            onluk //= hedef_taban
           
        return ("-" if negatif else "") + sonuc

class IfadeHesaplayici:
    """Matematiksel ifade hesaplayıcı"""
    def __init__(self):
        self.fonksiyonlar = {
            'sin': lambda x: math.sin(math.radians(x)),
            'cos': lambda x: math.cos(math.radians(x)),
            'tan': lambda x: math.tan(math.radians(x)),
            'sqrt': math.sqrt,
            'abs': abs,
            'log': math.log10,
            'ln': math.log,
            'exp': math.exp,
            'floor': math.floor,
            'ceil': math.ceil,
            'round': round
        }
        self.sabitler = {
            'pi': math.pi,
            'e': math.e,
            'tau': math.tau,
            'phi': (1 + math.sqrt(5)) / 2
        }

    def hesapla(self, ifade: str) -> float:
        """Matematiksel ifadeyi hesapla"""
        # Sabitleri değiştir
        for sabit, deger in self.sabitler.items():
            ifade = re.sub(rf'\b{sabit}\b', str(deger), ifade, flags=re.IGNORECASE)
           
        # Güvenlik kontrolü
        izinli = set('0123456789+-*/.() ')
        for fonk in self.fonksiyonlar:
            ifade = ifade.replace(fonk, '')
           
        temiz_ifade = ifade
        for c in temiz_ifade:
            if c not in izinli and not c.isalpha():
                raise HesapMakinesiHatasi(f"Geçersiz karakter: {c}")

        try:
            # Fonksiyonları işle
            for fonk_adi, fonk in self.fonksiyonlar.items():
                pattern = rf'{fonk_adi}\(([^)]+)\)'
                while re.search(pattern, ifade, re.IGNORECASE):
                    match = re.search(pattern, ifade, re.IGNORECASE)
                    ic_deger = self.hesapla(match.group(1))
                    sonuc = fonk(ic_deger)
                    ifade = ifade[:match.start()] + str(sonuc) + ifade[match.end():]
           
            # Değerlendir
            sonuc = eval(ifade)
            return sonuc
        except Exception as e:
            raise HesapMakinesiHatasi(f"İfade hesaplanamadı: {e}")

class HesapMakinesi:
    """Ana hesap makinesi sınıfı"""
    def __init__(self):
        self.gecmis = Gecmis()
        self.temel = TemelIslemler()
        self.bilimsel = BilimselIslemler()
        self.istatistik = Istatistik()
        self.denklem = DenklemCozucu()
        self.birim = BirimDonusturucu()
        self.sayi_sistemi = SayiSistemleri()
        self.ifade = IfadeHesaplayici()
       
        # Sabitler
        self.PI = math.pi
        self.E = math.e
        self.TAU = math.tau
        self.PHI = (1 + math.sqrt(5)) / 2 # Altın oran
       
        self.ans = 0 # Son sonuç

    def hesapla(self, ifade: str) -> float:
        """İfade hesapla ve geçmişe kaydet"""
        sonuc = self.ifade.hesapla(ifade)
        self.gecmis.ekle(ifade, sonuc)
        self.ans = sonuc
        return sonuc

    def yardim(self):
        """Yardım menüsünü göster"""
        yardim_metni = """
╔══════════════════════════════════════════════════════════════════════════════╗
║                    ÜST DÜZEY HESAP MAKİNESİ v2.0                             ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  📊 TEMEL İŞLEMLER                                                           ║
║  ─────────────────                                                           ║
║  • topla(*sayilar)   : Toplama                                               ║
║  • cikar(a, b)       : Çıkarma                                               ║
║  • carp(*sayilar)    : Çarpma                                                ║
║  • bol(a, b)         : Bölme                                                 ║
║  • tam_bolme(a, b)   : Tam bölme (//)                                        ║
║  • mod(a, b)         : Mod alma (%)                                          ║
║  • us(taban, us)     : Üs alma                                               ║
║  • kok(sayi, derece) : Kök alma                                              ║
║                                                                              ║
║  🔬 BİLİMSEL İŞLEMLER                                                        ║
║  ────────────────────                                                        ║
║  • sin, cos, tan, cot, sec, csc : Trigonometri                               ║
║  • arcsin, arccos, arctan       : Ters trigonometri                          ║
║  • sinh, cosh, tanh             : Hiperbolik                                 ║
║  • log, ln, log2, log10         : Logaritma                                  ║
║  • exp(x)                       : e^x                                        ║
║  • faktoriyel(n)                : n!                                         ║
║  • permutasyon(n, r)            : P(n,r)                                     ║
║  • kombinasyon(n, r)            : C(n,r)                                     ║
║  • gcd(*sayilar)                : EBOB                                       ║
║  • lcm(*sayilar)                : EKOK                                       ║
║                                                                              ║
║  📈 İSTATİSTİK                                                               ║
║  ─────────────                                                               ║
║  • ortalama, medyan, mod                                                     ║
║  • varyans, standart_sapma                                                   ║
║  • minimum, maksimum, aralik                                                 ║
║  • geometrik_ortalama, harmonik_ortalama                                     ║
║  • ceyrekler                                                                 ║
║                                                                              ║
║  📐 MATRİS İŞLEMLERİ                                                         ║
║  ───────────────────                                                         ║
║  • Matris([[1,2],[3,4]])                                                     ║
║  • +, -, * operatörleri                                                      ║
║  • transpoz(), determinant(), ters(), iz()                                   ║
║                                                                              ║
║  🧮 DENKLEM ÇÖZME                                                            ║
║  ────────────────                                                            ║
║  • birinci_derece(a, b)       : ax + b = 0                                   ║
║  • ikinci_derece(a, b, c)     : ax² + bx + c = 0                             ║
║  • ucuncu_derece(a, b, c, d)  : ax³ + bx² + cx + d = 0                       ║
║  • lineer_sistem_2x2, lineer_sistem_3x3                                      ║
║                                                                              ║
║  🔄 BİRİM DÖNÜŞTÜRME                                                         ║
║  ───────────────────                                                         ║
║  • donustur(deger, kaynak, hedef, tur)                                       ║
║    Türler: uzunluk, kutle, zaman, alan, hacim                                ║
║  • sicaklik(deger, kaynak, hedef) : C, F, K                                  ║
║  • aci(deger, kaynak, hedef)      : derece, radyan, grad                     ║
║                                                                              ║
║  🔢 SAYI SİSTEMLERİ                                                          ║
║  ──────────────────                                                          ║
║  • onluk_to_ikilik, onluk_to_sekizlik, onluk_to_onaltilik                    ║
║  • ikilik_to_onluk, sekizlik_to_onluk, onaltilik_to_onluk                    ║
║  • donustur(sayi, kaynak_taban, hedef_taban)                                 ║
║                                                                              ║
║  📝 SABİTLER                                                                 ║
║  ──────────                                                                  ║
║  • PI = 3.14159...   • E = 2.71828...                                        ║
║  • TAU = 6.28318...  • PHI = 1.61803... (Altın oran)                         ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝
        """
        print(yardim_metni)

def interaktif_mod():
    """İnteraktif hesap makinesi modu"""
    hesap = HesapMakinesi()
    print("\n" + "="*60)
    print(" 🧮 ÜST DÜZEY HESAP MAKİNESİ v2.0")
    print("="*60)
    print(" 'yardim' yazarak komutları görebilirsiniz.")
    print(" 'cikis' yazarak çıkabilirsiniz.")
    print("="*60 + "\n")

    while True:
        try:
            giris = input(">>> ").strip()
           
            if not giris:
                continue
               
            if giris.lower() in ['çıkış', 'cikis', 'exit', 'quit', 'q']:
                print("\n👋 Güle güle!\n")
                break
               
            if giris.lower() in ['yardım', 'yardim', 'help', 'h', '?']:
                hesap.yardim()
                continue
               
            if giris.lower() in ['gecmis', 'geçmiş', 'history']:
                for kayit in hesap.gecmis.listele():
                    print(f" [{kayit['zaman']}] {kayit['islem']} = {kayit['sonuc']}")
                continue
               
            if giris.lower() in ['temizle', 'clear', 'cls']:
                print("\n" * 50)
                continue

            # İfadeyi değerlendir
            sonuc = eval(giris, {
                "__builtins__": {},
                "hesap": hesap,
                "temel": hesap.temel,
                "bilimsel": hesap.bilimsel,
                "istatistik": hesap.istatistik,
                "denklem": hesap.denklem,
                "birim": hesap.birim,
                "sayi": hesap.sayi_sistemi,
                "Matris": Matris,
                "math": math,
                "pi": math.pi,
                "e": math.e,
                "ans": hesap.ans,
                # Temel işlemler
                "topla": hesap.temel.topla,
                "cikar": hesap.temel.cikar,
                "carp": hesap.temel.carp,
                "bol": hesap.temel.bol,
                "tam_bolme": hesap.temel.tam_bolme,
                "mod": hesap.temel.mod,
                "us": hesap.temel.us,
                "kok": hesap.temel.kok,
                "mutlak": hesap.temel.mutlak_deger,
                "yuvarla": hesap.temel.yuvarla,
                # Bilimsel
                "sin": hesap.bilimsel.sin,
                "cos": hesap.bilimsel.cos,
                "tan": hesap.bilimsel.tan,
                "cot": hesap.bilimsel.cot,
                "sec": hesap.bilimsel.sec,
                "csc": hesap.bilimsel.csc,
                "arcsin": hesap.bilimsel.arcsin,
                "arccos": hesap.bilimsel.arccos,
                "arctan": hesap.bilimsel.arctan,
                "sinh": hesap.bilimsel.sinh,
                "cosh": hesap.bilimsel.cosh,
                "tanh": hesap.bilimsel.tanh,
                "log": hesap.bilimsel.log,
                "ln": hesap.bilimsel.ln,
                "log2": hesap.bilimsel.log2,
                "log10": hesap.bilimsel.log10,
                "exp": hesap.bilimsel.exp,
                "fakt": hesap.bilimsel.faktoriyel,
                "perm": hesap.bilimsel.permutasyon,
                "komb": hesap.bilimsel.kombinasyon,
                "ebob": hesap.bilimsel.gcd,
                "ekok": hesap.bilimsel.lcm,
                # İstatistik
                "ort": hesap.istatistik.ortalama,
                "medyan": hesap.istatistik.medyan,
                "varyans": hesap.istatistik.varyans,
                "std": hesap.istatistik.standart_sapma,
            })
           
            if sonuc is not None:
                print(f" = {sonuc}")
                hesap.ans = sonuc
                hesap.gecmis.ekle(giris, sonuc)
               
        except HesapMakinesiHatasi as e:
            print(f" ⚠️ Hata: {e}")
        except ZeroDivisionError:
            print(" ⚠️ Hata: Sıfıra bölme!")
        except ValueError as e:
            print(f" ⚠️ Değer hatası: {e}")
        except SyntaxError:
            print(" ⚠️ Sözdizimi hatası!")
        except NameError as e:
            print(f" ⚠️ Tanımsız: {e}")
        except TypeError as e:
            print(f" ⚠️ Tür hatası: {e}")
        except Exception as e:
            print(f" ⚠️ Beklenmeyen hata: {e}")

def demo():
    """Demo fonksiyonu - tüm özellikleri gösterir"""
    print("\n" + "="*70)
    print(" 🧮 HESAP MAKİNESİ DEMO")
    print("="*70)
   
    hesap = HesapMakinesi()
   
    # Temel İşlemler
    print("\n📊 TEMEL İŞLEMLER")
    print("-"*40)
    print(f" Toplama: 5 + 3 + 2 = {hesap.temel.topla(5, 3, 2)}")
    print(f" Çıkarma: 10 - 4 = {hesap.temel.cikar(10, 4)}")
    print(f" Çarpma: 6 × 7 = {hesap.temel.carp(6, 7)}")
    print(f" Bölme: 15 ÷ 4 = {hesap.temel.bol(15, 4)}")
    print(f" Tam Bölme: 15 // 4 = {hesap.temel.tam_bolme(15, 4)}")
    print(f" Mod: 15 % 4 = {hesap.temel.mod(15, 4)}")
    print(f" Üs: 2^10 = {hesap.temel.us(2, 10)}")
    print(f" Karekök: √16 = {hesap.temel.kok(16)}")
    print(f" Küpkök: ∛27 = {hesap.temel.kok(27, 3)}")
   
    # Bilimsel İşlemler
    print("\n🔬 BİLİMSEL İŞLEMLER")
    print("-"*40)
    print(f" sin(30°) = {hesap.bilimsel.sin(30)}")
    print(f" cos(60°) = {hesap.bilimsel.cos(60)}")
    print(f" tan(45°) = {hesap.bilimsel.tan(45)}")
    print(f" log₁₀(100) = {hesap.bilimsel.log10(100)}")
    print(f" ln(e) = {hesap.bilimsel.ln(math.e)}")
    print(f" 5! = {hesap.bilimsel.faktoriyel(5)}")
    print(f" P(5,3) = {hesap.bilimsel.permutasyon(5, 3)}")
    print(f" C(5,3) = {hesap.bilimsel.kombinasyon(5, 3)}")
    print(f" EBOB(12, 18) = {hesap.bilimsel.gcd(12, 18)}")
    print(f" EKOK(12, 18) = {hesap.bilimsel.lcm(12, 18)}")
   
    # İstatistik
    print("\n📈 İSTATİSTİK")
    print("-"*40)
    veriler = [2, 4, 4, 4, 5, 5, 7, 9]
    print(f" Veri: {veriler}")
    print(f" Ortalama: {hesap.istatistik.ortalama(veriler)}")
    print(f" Medyan: {hesap.istatistik.medyan(veriler)}")
    print(f" Mod: {hesap.istatistik.mod(veriler)}")
    print(f" Varyans: {hesap.istatistik.varyans(veriler):.4f}")
    print(f" Std Sapma: {hesap.istatistik.standart_sapma(veriler):.4f}")
   
    # Matris
    print("\n📐 MATRİS İŞLEMLERİ")
    print("-"*40)
    A = Matris([[1, 2], [3, 4]])
    B = Matris([[5, 6], [7, 8]])
    print(f" A = {A.veri}")
    print(f" B = {B.veri}")
    print(f" A + B = {(A + B).veri}")
    print(f" A × B = {(A * B).veri}")
    print(f" det(A) = {A.determinant()}")
    print(f" A⁻¹ = {A.ters().veri}")
   
    # Denklem Çözme
    print("\n🧮 DENKLEM ÇÖZME")
    print("-"*40)
    print(f" 2x + 6 = 0 → x = {hesap.denklem.birinci_derece(2, 6)}")
    x1, x2 = hesap.denklem.ikinci_derece(1, -5, 6)
    print(f" x² - 5x + 6 = 0 → x₁ = {x1}, x₂ = {x2}")
   
    # Birim Dönüştürme
    print("\n🔄 BİRİM DÖNÜŞTÜRME")
    print("-"*40)
    print(f" 100 km = {hesap.birim.donustur(100, 'km', 'mil', 'uzunluk'):.2f} mil")
    print(f" 0°C = {hesap.birim.sicaklik(0, 'C', 'F'):.1f}°F")
    print(f" 180° = {hesap.birim.aci(180, 'derece', 'radyan'):.4f} rad")
   
    # Sayı Sistemleri
    print("\n🔢 SAYI SİSTEMLERİ")
    print("-"*40)
    print(f" 255 (10) = {hesap.sayi_sistemi.onluk_to_ikilik(255)} (2)")
    print(f" 255 (10) = {hesap.sayi_sistemi.onluk_to_onaltilik(255)} (16)")
    print(f" FF (16) = {hesap.sayi_sistemi.onaltilik_to_onluk('FF')} (10)")
   
    print("\n" + "="*70)
    print(" Demo tamamlandı!")
    print("="*70 + "\n")

if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1:
        if sys.argv[1] in ['--demo', '-d']:
            demo()
        elif sys.argv[1] in ['--help', '-h']:
            HesapMakinesi().yardim()
        else:
            # Komut satırından hesaplama
            hesap = HesapMakinesi()
            ifade = ' '.join(sys.argv[1:])
            try:
                sonuc = hesap.hesapla(ifade)
                print(sonuc)
            except Exception as e:
                print(f"Hata: {e}")
    else:
        # İnteraktif mod
        interaktif_mod()