"""Hazırlık 1 — Python, NumPy ve veriyle çalışmak.

Makine öğrenmesinde her gün kullanılan araçları küçük mühendislik örnekleriyle gösterir:
NumPy dizileri ve şekilleri, indeksleme ve maskeler, vektörleştirme, yayınlama (broadcasting)
ve tipik şekil hatası, eksen boyunca işlemler, rastgelelik, doğrusal sistem çözümü,
pandas ile tablo verisi ve Matplotlib ile grafik.

Veri sentetiktir. Altı küp numunesinin değerleri elle yazıldı (Abrams yasasına yakın, uydurma
sayılar). 200 000 düzlem gerilme durumu ve 300 satırlık beton tablosu sabit tohumlu rastgele
sayılarla üretilir; tablo, kursun ortak beton_verisi fonksiyonundan gelir. Gerçek deney kaydı değildir.

Çalıştır:  python h1_python_numpy.py
Gerekenler: numpy, pandas, matplotlib  (Python 3.12+)
Süre:      birkaç saniye
Çıktılar:  terminale sayılar, aynı klasöre iki PNG grafiği
"""
import io
import math
import time
from pathlib import Path

import numpy as np
import pandas as pd
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt

# --- Grafik stili (kurs genelinde aynı) ---
RENK = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"]
MUREKKEP, IKINCIL, SOLUK = "#0b0b0b", "#52514e", "#898781"
plt.rcParams.update({
    "figure.facecolor": "white", "axes.facecolor": "white", "savefig.facecolor": "white",
    "axes.edgecolor": "#c3c2b7", "axes.labelcolor": IKINCIL, "axes.titlecolor": MUREKKEP,
    "axes.titlesize": 11, "axes.titleweight": "bold", "axes.labelsize": 10,
    "xtick.color": IKINCIL, "ytick.color": IKINCIL, "font.size": 10,
    "axes.grid": True, "grid.color": "#e1e0d9", "grid.linewidth": 0.6,
    "axes.spines.top": False, "axes.spines.right": False,
    "axes.prop_cycle": plt.cycler(color=RENK), "lines.linewidth": 2, "legend.frameon": False,
})
KLASOR = Path(__file__).resolve().parent


def beton_verisi(n, rng, eksik_oran=0.0):
    """Sentetik beton karışımı verisi (eğitim amaçlı; gerçek deney verisi değildir).

    Dayanım, Abrams yasası (f = 96,5 / 7^(s/b) MPa) ve EN 1992-1-1'deki yaş katsayısı
    β_cc(t) = exp(s·(1 − √(28/t))) ile üretilir; s/b oranında cüruf ve uçucu kül, EN 206'daki
    k-değeri kavramına benzer biçimde 0,6 ve 0,4 etkinlikle bağlayıcıya katılır.
    """
    cimento = rng.uniform(250, 500, n)                                   # kg/m³
    curuf = np.where(rng.random(n) < 0.4, rng.uniform(20, 200, n), 0.0)  # kg/m³
    ucucu_kul = np.where(rng.random(n) < 0.3, rng.uniform(20, 150, n), 0.0)
    su = rng.uniform(150, 210, n)                                        # kg/m³
    super_akiskan = np.where(rng.random(n) < 0.6, rng.uniform(2, 12, n), 0.0)
    iri_agrega = rng.uniform(850, 1100, n)
    ince_agrega = rng.uniform(650, 900, n)
    yas_gun = rng.choice([3, 7, 14, 28, 56, 90], n, p=[.12, .2, .13, .3, .13, .12])
    tipler = np.array(["CEM I 42,5 R", "CEM II/A-LL 42,5 N", "CEM III/A 32,5 N"])
    tip_no = rng.choice(3, n, p=[.45, .35, .20])
    s_katsayi = np.array([0.20, 0.25, 0.38])[tip_no]      # EN 1992-1-1, Bağıntı 3.2: R, N, S sınıfı
    sinif_carpani = np.array([1.00, 0.97, 0.88])[tip_no]  # varsayım: dayanım sınıfı etkisi
    kalip_no = rng.integers(1, 21, n)                    # ilgisiz özellik
    ortam_sicakligi = rng.uniform(5, 30, n)              # ilgisiz özellik (bu üreticide)

    sb = su / (cimento + 0.6 * curuf + 0.4 * ucucu_kul)  # su / etkin bağlayıcı
    f28 = 96.5 / 7.0 ** sb * sinif_carpani + 0.25 * super_akiskan
    beta = np.exp(s_katsayi * (1 - np.sqrt(28 / yas_gun)))
    dayanim = f28 * beta * rng.lognormal(0.0, 0.07, n)

    df = pd.DataFrame({
        "cimento": cimento, "curuf": curuf, "ucucu_kul": ucucu_kul, "su": su,
        "super_akiskan": super_akiskan, "iri_agrega": iri_agrega, "ince_agrega": ince_agrega,
        "yas_gun": yas_gun, "cimento_tipi": tipler[tip_no], "kalip_no": kalip_no,
        "ortam_sicakligi": ortam_sicakligi, "dayanim_mpa": dayanim,
    })
    if eksik_oran > 0:
        df.loc[rng.random(n) < eksik_oran, "super_akiskan"] = np.nan
    return df


# %% 1. Diziler: oluşturma, veri tipi ve şekil
f = np.array([32.4, 41.0, 23.6, 47.1, 38.1, 33.2])   # altı küpün basınç dayanımı (MPa)
sb = np.array([0.55, 0.45, 0.60, 0.40, 0.48, 0.50])   # su/bağlayıcı oranı (birimsiz)
yas = np.array([28, 28, 7, 56, 28, 14])               # numune yaşı (gün), tam sayı dizisi
X = np.column_stack([sb, yas])   # özellik matrisi: satır = numune, sütun = özellik
y = f                            # hedef vektörü: her numune için bir sayı
print("=== 1. Diziler ve şekiller ===")
print(f"f = {f} → dtype {f.dtype}, shape {f.shape}, ndim {f.ndim}")
print(f"X.shape = {X.shape} (n_örnek, n_özellik), y.shape = {y.shape}, f.reshape(-1, 1).shape = "
      f"{f.reshape(-1, 1).shape}")
yas2 = yas.copy()
yas2[0] = 7.9                    # tam sayı dizisine ondalık sayı yazılınca sessizce kesilir
print(f"yas.dtype = {yas.dtype}: yas2[0] = 7.9 atandı → yas2[0] = {yas2[0]}")
assert X.shape == (len(f), 2) and y.ndim == 1

# %% 2. İndeksleme, dilimleme ve maskeler
print("\n=== 2. İndeksleme ve maskeler ===")
print(f"f[0] = {f[0]}, f[-1] = {f[-1]}, f[1:4] = {f[1:4]}, X[:, 1] = {X[:, 1]}")
maske = f > 35                              # her eleman için True/False
print(f"f > 35 → {maske} → f[maske] = {f[maske]} ({maske.sum()} küp)")
iki_kosul = (f > 35) & (yas == 28)          # 've' için &, parantezler zorunlu
print(f"(f > 35) & (yas == 28) → {f[iki_kosul]}; bu küplerin s/b ortalaması {sb[iki_kosul].mean():.3f}")
sira = np.argsort(f)[::-1][:3]              # dayanıma göre azalan sıra, ilk üçü
print(f"En yüksek üç dayanım: indeksler {sira} → {f[sira]} MPa")
dilim = f[1:4]                              # dilim bir görünümdür (view), kopya değil
dilim[0] = 0.0
print(f"dilim[0] = 0 yazıldı → f[1] = {f[1]} (dilim ile f aynı belleği paylaşıyor)")
f[1] = 41.0                                 # eski değere döndür
assert maske.sum() == 3 and f[1] == 41.0

# %% 3. Vektörleştirme: 200 000 noktada von Mises eşdeğer gerilmesi
rng = np.random.default_rng(42)
n = 200_000
# sütunlar σx, σy, τxy (MPa); ölçek listesi sütunlara yayınlanır
S = rng.normal(0.0, [90.0, 60.0, 40.0], size=(n, 3))


def von_mises_dongu(S):
    """Her satırı Python döngüsüyle tek tek hesaplar."""
    sonuc = np.empty(len(S))
    for i in range(len(S)):
        sx, sy, txy = S[i]
        sonuc[i] = math.sqrt(sx * sx - sx * sy + sy * sy + 3 * txy * txy)
    return sonuc


def von_mises_vektor(S):
    """Aynı formül, bütün sütunlar üzerinde tek seferde (derlenmiş NumPy kodu)."""
    sx, sy, txy = S[:, 0], S[:, 1], S[:, 2]
    return np.sqrt(sx**2 - sx * sy + sy**2 + 3 * txy**2)


t0 = time.perf_counter()
vm_dongu = von_mises_dongu(S)
sure_dongu = time.perf_counter() - t0
sure_vektor = np.inf
for _ in range(5):                           # en iyi 5 ölçüm: arka plan gürültüsünü azaltır
    t0 = time.perf_counter()
    vm = von_mises_vektor(S)
    sure_vektor = min(sure_vektor, time.perf_counter() - t0)
oran = float(f"{sure_dongu / sure_vektor:.2g}")   # iki anlamlı basamak yeter
asim = vm > 235.0                            # S235 çeliğinin akma dayanımı
print("\n=== 3. Vektörleştirme ===")
print(f"{n} nokta: döngü ve vektör sonucu aynı: {np.allclose(vm_dongu, vm)}; "
      f"σ_vm > 235 MPa: {asim.sum()} nokta (yüzde {100 * asim.mean():.2f})")
print(f"Süre oranı döngü / vektör ≈ {oran:.0f} kat (bu oran bilgisayara göre değişir)")
assert np.allclose(vm_dongu, vm)

# %% 4. Yayınlama (broadcasting) ve tipik şekil hatası
ort = X.mean(axis=0)            # (2,): her sütunun ortalaması
ss = X.std(axis=0)              # (2,): her sütunun standart sapması
Z = (X - ort) / ss              # (6, 2) − (2,) → (6, 2): her satırdan aynı vektör çıkar
print("\n=== 4. Yayınlama ===")
print(f"X.mean(axis=0) = {ort.round(3)} → şekil {ort.shape}; (X − ortalama).shape = {(X - ort).shape}")
print(f"Standartlaştırılmış sütunlar: ortalama {np.abs(Z.mean(axis=0)).round(12)}, std {Z.std(axis=0)}")

# Hedefi (n, 1) biçiminde tutmak: df[["dayanim_mpa"]].to_numpy() de böyle döner
y_sutun = f.reshape(-1, 1)
A = np.column_stack([X, np.ones(len(f))])             # [s/b, yaş, 1]
w, *_ = np.linalg.lstsq(A, y_sutun, rcond=None)       # w.shape = (3, 1)
tahmin = A @ w                                        # (6, 1)
fark = f - tahmin                                     # (6,) − (6, 1) → (6, 6) !
mse_yanlis = np.mean(fark**2)
mse_dogru = np.mean((f - tahmin[:, 0]) ** 2)          # ya da tahmin.ravel()
print(f"f.shape = {f.shape}, tahmin.shape = {tahmin.shape} → (f − tahmin).shape = {fark.shape}")
print(f"Yanlış MSE = {mse_yanlis:.2f} MPa², doğru MSE = {mse_dogru:.2f} MPa² (hata mesajı yok!)")
try:
    assert f.shape == tahmin.shape, f"şekiller farklı: {f.shape} ve {tahmin.shape}"
except AssertionError as hata:
    print(f"assert yakaladı → {hata}")
assert np.allclose(np.diag(fark), f - tahmin[:, 0])

# %% 5. Eksen boyunca işlemler, rastgelelik ve doğrusal sistem
D = np.array([[23.6, 33.2, 35.7],     # satır: karışım, sütun: 7, 28, 56 gün (MPa)
              [29.8, 40.2, 43.3],
              [18.5, 30.0, 32.4]])
print("\n=== 5. Eksenler, rastgelelik, doğrusal sistem ===")
print(f"D.mean(axis=0) = {D.mean(axis=0).round(2)} MPa (yaş başına), "
      f"D.max(axis=1) = {D.max(axis=1)} MPa")
a = np.random.default_rng(42).normal(30.0, 4.0, 3)
b = np.random.default_rng(42).normal(30.0, 4.0, 3)
c = np.random.default_rng(7).normal(30.0, 4.0, 3)
print(f"Tohum 42 iki kez: {a.round(3)} = {b.round(3)} → {np.array_equal(a, b)}; tohum 7: {c.round(3)}")
K = np.array([[35.0, -15.0, 0.0],     # seri bağlı üç yay (20, 15, 10 kN/mm), sol uç ankastre
              [-15.0, 25.0, -10.0],
              [0.0, -10.0, 10.0]])
F = np.array([0.0, 0.0, 6.0])         # serbest uçta 6 kN
u = np.linalg.solve(K, F)             # K u = F, ters matris almadan
print(f"K u = F → u = {u.round(4)} mm; K @ u ile F aynı mı? {np.allclose(K @ u, F)}")
assert np.allclose(u, [0.3, 0.7, 1.3])

# %% 6. pandas: tablo verisi
df = beton_verisi(300, np.random.default_rng(42), eksik_oran=0.05)
df["su_baglayici"] = df["su"] / (df["cimento"] + df["curuf"] + df["ucucu_kul"])
tipler = ", ".join(f"{t}: {k}" for t, k in df.dtypes.astype(str).value_counts().items())
print("\n=== 6. pandas ===")
print(f"df.shape = {df.shape}; sütun tipleri → {tipler}")
print(df[["cimento", "su", "su_baglayici", "yas_gun", "cimento_tipi", "dayanim_mpa"]].head(3).round(2))
print(df[["su_baglayici", "dayanim_mpa"]].describe().T.round(2))
eksik = int(df["super_akiskan"].isna().sum())
medyan = df["super_akiskan"].median()
df["super_akiskan"] = df["super_akiskan"].fillna(medyan)
print(f"Eksik super_akiskan: {eksik} satır → medyan {medyan:.2f} kg/m³ ile dolduruldu; "
      f"kalan eksik: {int(df.isna().sum().sum())}")
print(df.groupby("yas_gun")["dayanim_mpa"].agg(["count", "mean", "std"]).round(1))
guclu = df[df["dayanim_mpa"] > 40]
print(f"Dayanımı 40 MPa'yı aşan {len(guclu)} küp; bunların {int((guclu['yas_gun'] == 28).sum())} tanesi 28 günlük")
X_tablo = df[["cimento", "su", "yas_gun"]].to_numpy()
y_tablo = df["dayanim_mpa"].to_numpy()
print(f"to_numpy: X {X_tablo.shape} {X_tablo.dtype}, y {y_tablo.shape}")
tampon = io.StringIO()                # dosya yerine bellekte bir "dosya"
df.to_csv(tampon, index=False)
tampon.seek(0)
df2 = pd.read_csv(tampon)
sayisal = df.select_dtypes("number").columns
en_buyuk_fark = np.abs(df[sayisal].to_numpy() - df2[sayisal].to_numpy()).max()
print(f"CSV gidiş-dönüş: df.equals(df2) = {df.equals(df2)}, en büyük fark {en_buyuk_fark:.1e}, "
      f"np.allclose = {np.allclose(df[sayisal], df2[sayisal])}")
assert X_tablo.shape == (300, 3) and y_tablo.shape == (300,)

# %% 7. Matplotlib: grafikler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
kutular = np.arange(4 * np.floor(df["dayanim_mpa"].min() / 4), df["dayanim_mpa"].max() + 4, 4)
y28 = df.loc[df["yas_gun"] == 28, "dayanim_mpa"]
ax[0].hist(df["dayanim_mpa"], bins=kutular, color=RENK[0], label=f"Tüm küpler (n = {len(df)})")
ax[0].hist(y28, bins=kutular, color=RENK[1], label=f"İçlerinden 28 günlükler (n = {len(y28)})")
ax[0].set(xlabel="Basınç dayanımı (MPa)", ylabel="Küp sayısı", title="Dayanımın dağılımı")
ax[0].set_ylim(0, 1.3 * np.histogram(df["dayanim_mpa"], bins=kutular)[0].max())   # lejanta yer aç
ax[0].set_axisbelow(True)              # ızgara çizgileri çubukların arkasında kalsın
ax[0].legend(loc="upper left")
diger = ~df["yas_gun"].isin([7, 28, 90])
ax[1].scatter(df.loc[diger, "su_baglayici"], df.loc[diger, "dayanim_mpa"], s=10, color=SOLUK, alpha=0.5,
              label="Diğer yaşlar")
for renk, gun in zip(RENK[:3], [7, 28, 90]):
    sec = df["yas_gun"] == gun
    ax[1].scatter(df.loc[sec, "su_baglayici"], df.loc[sec, "dayanim_mpa"], s=18, color=renk, label=f"{gun} gün")
ax[1].set(xlabel="Su / bağlayıcı oranı (–)", ylabel="Basınç dayanımı (MPa)", title="Dayanım, su/bağlayıcı ve yaş")
ax[1].legend(loc="upper right")
fig.savefig(KLASOR / "h1_python_numpy_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
artik = f - tahmin[:, 0]
ax[0].bar(np.arange(len(f)), artik, color=RENK[0], width=0.6)
ax[0].axhline(0, color=MUREKKEP, lw=1)
ax[0].set_axisbelow(True)
ax[0].set(xlabel="Küp indeksi i", ylabel="Artık f[i] − tahmin[i] (MPa)",
          title=f"Doğru: (6,) − (6,) → (6,), MSE = {mse_dogru:.2f}")
sinir = np.abs(fark).max()
im = ax[1].imshow(fark, cmap="RdBu_r", vmin=-sinir, vmax=sinir)
for i in range(len(f)):
    for j in range(len(f)):
        ax[1].text(j, i, f"{fark[i, j]:.1f}", ha="center", va="center", fontsize=8,
                   color="white" if abs(fark[i, j]) > 0.6 * sinir else MUREKKEP)
    ax[1].add_patch(plt.Rectangle((i - 0.5, i - 0.5), 1, 1, fill=False, ec=MUREKKEP, lw=2))
ax[1].grid(False)
ax[1].set(xlabel="Ölçüm indeksi j", ylabel="Tahmin indeksi i",
          title=f"Hatalı: (6,) − (6, 1) → (6, 6), MSE = {mse_yanlis:.1f}")
fig.colorbar(im, ax=ax[1], label="f[j] − tahmin[i, 0] (MPa)")
fig.savefig(KLASOR / "h1_python_numpy_2.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: h1_python_numpy_1.png, h1_python_numpy_2.png")
