``

Önce teori: Dedektör aslında ne ölçer?

Webb’in dedektörleri, poz boyunca biriken sinyali birden fazla kez okur. Bu okumalar, rampa denilen bir zaman dizisi oluşturur. İdeal, doğrusal bölgedeki bir pikseli şöyle düşünebiliriz:

Burada $b$ başlangıç seviyesi, $r$ sinyalin birikme hızı, $\epsilon(t)$ ise gürültüdür. Amaç yalnızca son okumaya bakmak değil, geçerli okumaların eğiminden güvenilir bir hız ölçmektir. Doygunluk ve kozmik ışın sıçramaları, bu hesabı sıradan bir doğru uydurmaktan daha zor hâle getirir.

Gürültünün iki önemli bileşeni fotonların istatistiksel değişkenliği ve elektronik okuma gürültüsüdür. Kalibrasyon, bunları sihirli biçimde yok etmez; etkilerini modeller ve belirsizlikleri sonraki aşamalara taşır.

1. Dedektör düzeltmeleri: Elektroniğin izlerini temizlemek

İlk aşamada veri kalite bayrakları hazırlanır; doygun pikseller belirlenir ve dedektöre uygun düzeltmeler uygulanır. Referans piksel düzeltmesi, doğrusal olmayan tepkinin giderilmesi ve karanlık akım düzeltmesi bunlar arasındadır. MIRI ile yakın kızılötesi dedektörlerinin ihtiyaçları aynı olmadığından, adımlar cihaz ve gözlem moduna göre değişir.

Kozmik ışınlar rampada ani sıçramalar bırakabilir. İşlem hattı bu sıçramaları işaretleyerek geçerli rampa parçalarını değerlendirebilir. Böylece tek bir darbe yüzünden bütün poz çöpe gitmez. Rampa uydurması sonucunda, görüntüleme için genellikle DN/s cinsinden bir hız görüntüsü elde edilir.

2. Fiziksel kalibrasyon: Pikselden gökyüzüne

İkinci aşama, ölçümü gökyüzüyle ilişkilendirir. WCS, piksel koordinatlarını göksel koordinatlara dönüştüren modeli taşır; optik bozulmalar da bu modelin parçasıdır. Düz alan düzeltmesi, piksellerin farklı duyarlılıklarını dengeler. Fotometrik kalibrasyon ise sayısal sinyali fiziksel birimlere çevirir; görüntüleme ürünlerinde yaygın birim MJy/sr’dir.

Basitleştirilmiş bir ilişki şöyle yazılabilir:

$R$ hız ölçümü, $B$ arka plan, $F$ göreli duyarlılık ve $C$ dönüşüm katsayısıdır. Bu denklem kavramsaldır; gerçek hattın bütün adımlarını veya kesin işlem sırasını temsil etmez. Özellikle arka planın nerede çıkarılacağı gözleme bağlıdır.

3. Birleştirme: Kozmik yapbozu tamamlamak

Webb aynı alanı küçük konum kaymalarıyla, yani dither uygulayarak gözlemleyebilir. Üçüncü aşamada uygun pozlar hizalanır, gerektiğinde arka plan seviyeleri eşleştirilir, aykırı örnekler belirlenir ve ortak bir koordinat ızgarasına yeniden örneklenir.

Drizzle yaklaşımı, bu birleştirmede örneklemeyi ve kapsama alanını iyileştirebilir. Ancak yeni fiziksel ayrıntılar yaratmaz; yeniden örnekleme komşu pikseller arasında gürültü korelasyonu oluşturabilir. Bu nedenle mozaikteki belirsizlikleri bağımsız piksel varsayımıyla yorumlamak her zaman doğru değildir.

Python ile hattı çalıştırmak

STScI’nin jwst paketini pip install jwst ile kurabilirsiniz. Aşağıdaki örnek, iki görüntüleme pozunu işler. Dosya adları temsilidir; son çağrı, oluşan cal dosyalarını üye olarak tanımlayan geçerli bir goruntu_asn.json ilişkilendirme dosyası gerektirir.

import os

os.environ.setdefault("CRDS_PATH", os.path.abspath("crds_cache"))
os.environ.setdefault("CRDS_SERVER_URL", "https://jwst-crds.stsci.edu")

from jwst.pipeline import Detector1Pipeline, Image2Pipeline, Image3Pipeline

os.makedirs("urunler", exist_ok=True)

for raw in ["jw_ornek01_uncal.fits", "jw_ornek02_uncal.fits"]:
    root = raw.removesuffix("_uncal.fits")
    Detector1Pipeline.call(
        raw, save_results=True, output_dir="urunler"
    )
    Image2Pipeline.call(
        f"urunler/{root}_rate.fits",
        save_results=True, output_dir="urunler"
    )

Image3Pipeline.call(
    "goruntu_asn.json", save_results=True, output_dir="urunler"
)

CRDS, gözleme uygun kalibrasyon referanslarını seçer. Tekrarlanabilirlik için paket sürümünü, işlem parametrelerini ve kullanılan CRDS_CONTEXT değerini kaydedin. Spektroskopide ikinci ve üçüncü aşamalar için Spec2Pipeline ve Spec3Pipeline kullanılır; dalga boyu kalibrasyonu ve tayf çıkarımı gibi işlemler devreye girer.

Son kontrol: Güzel görünmek yetmez

Bilimsel analizden önce çıktıların SCI, ERR ve DQ uzantılarını birlikte inceleyin: Bunlar sırasıyla ölçümü, belirsizliği ve kalite bayraklarını taşır. Hizalama hatalarını, arka plan kalıntılarını ve maskelenmiş bölgeleri kontrol edin. Birleşik ürünlerin kapsama ve ağırlık haritaları da hangi bölgelerin daha güvenilir olduğunu gösterir.

Son olarak, renkli sunum görüntülerindeki kontrast ayarlarını bilimsel kalibrasyonla karıştırmayın. İyi bir Webb görüntüsü yalnızca etkileyici görünmez; birimleri, belirsizlikleri ve işlem geçmişiyle savunulabilir bir ölçüm sunar.

``

Kalabalık, tek bir büyük karakter değildir

Ajan tabanlı modellerde her yaya bağımsız bir hesaplama birimidir. Konumu, hızı, hedefi ve tercihleri bulunur. Kalabalığın genel davranışı, bu küçük birimlerin etkileşiminden doğar. Karşılıklı yürüyen insanların kendiliğinden şerit oluşturması, bunun güzel örneklerinden biridir.

Yaygın yaklaşımlardan sosyal kuvvet modeli, hareketi hedefe ilerleme isteği ve çevreden gelen etkilerle açıklar:

Burada $v_i^0$ istenen sürat, $e_i$ hedef yönü, $\tau_i$ tepki süresidir. Diğer terimler, yayaların ve duvarların etkisini temsil eder. Bunlar psikolojik davranışın birebir fizik yasaları değil, ölçümlerle ayarlanması gereken model bileşenleridir.

Geniş kapı neden her zaman çözüm değildir?

Akış yalnızca kapının genişliğine bağlı değildir. Yoğunluk arttığında insanlar daha yavaş ilerleyebilir. Birim genişlik başına akış için temel ilişki şöyledir:

Burada $\rho$ kişi/metrekare, $v$ metre/saniye, $w$ geçiş genişliğidir; $Q$ kişi/saniye olarak ölçülür. Bu ilişki muhasebe açısından yararlıdır, ancak hızın yoğunlukla nasıl değiştiğini ayrıca modellemek gerekir. Geniş kapının arkasındaki dar koridor, darboğazı sadece birkaç metre ileri taşıyabilir. Kalabalık, tasarım hatasını sihirli biçimde buharlaştırmaz!

Python ile küçük bir hareket çekirdeği

Aşağıdaki NumPy kodu, hedefe yönelme ve yayalar arasında uzaklaşma eğilimini hesaplar. pos, vel ve goals, her satırı bir yayaya karşılık gelen (N, 2) dizileridir.

import numpy as np


def step(pos, vel, goals, dt=0.05):
    target = goals - pos
    distance = np.linalg.norm(target, axis=1)
    direction = target / (distance[:, None] + 1e-9)
    desired_speed = np.minimum(1.3, distance / 0.5)
    desired = direction * desired_speed[:, None]

    delta = pos[:, None, :] - pos[None, :, :]
    gap = np.linalg.norm(delta, axis=2)
    normal = delta / (gap[:, :, None] + 1e-9)
    strength = 2.0 * np.exp(
        np.clip((0.5 - gap) / 0.3, -30, 10)
    )
    np.fill_diagonal(strength, 0.0)
    repulsion = (strength[:, :, None] * normal).sum(axis=1)

    acceleration = (desired - vel) / 0.5 + repulsion
    new_vel = vel + acceleration * dt
    speed = np.linalg.norm(new_vel, axis=1)
    new_vel *= np.minimum(1.0, 2.0 / (speed + 1e-9))[:, None]
    return pos + new_vel * dt, new_vel

İlk bölüm hedef yakınında yavaşlamayı sağlar. İkinci bölüm, yakın komşuların uzaklaşma etkisini toplar; son bölüm hareketi günceller. Sabitler örnek parametrelerdir, güvenlik sınırları değildir. Kod duvarları, fiziksel teması ve rota planlamasını içermez; çarpışmasız hareket garantilemez. Ayrıca tüm çiftleri karşılaştırdığı için maliyeti $O(N^2)$ olur. Büyük kalabalıklarda uzamsal indeksleme gerekir.

Tasarımı karşılaştırmalı bir deneye dönüştürmek

Meydan veya stadyum geometrisini modele aktardıktan sonra tek bir animasyona bakıp karar vermeyin. Aynı koşullarda farklı tasarımları karşılaştırın:

1. Başlangıcı tanımlayın: Giriş hızlarını, hedef dağılımını ve yürüme hızlarındaki çeşitliliği belirleyin. Arkadaş gruplarını ve erişilebilir güzergâhları unutmayın.
2. Alternatifler üretin: Kapı genişliği, bariyer yerleşimi ve büfe konumu gibi değişkenleri ayrı ayrı değiştirin.
3. Ölçün: Tahliye süresini, yerel yoğunluğu, bekleme sürelerini ve çıkış çizgisini geçen kişi sayısını kaydedin.
4. Tekrarlayın: Farklı başlangıç dağılımlarıyla çoklu koşular yapın; yalnızca ortalamayı değil, sonuçların değişkenliğini de raporlayın.

Rota seçimi için en kısa yol her zaman en hızlı yol değildir. Algoritma, mesafeyle birlikte beklenen sıkışıklığı değerlendirebilir. Ancak çok sık rota değiştirmek kararsızlığa yol açabilir; karar güncellemelerini yumuşatmak faydalıdır.

Animasyon güzel, doğrulama daha güzel

Modeli gerçek sayımlar, anonimleştirilmiş hareket ölçümleri ve geçiş süreleriyle kalibre edin. Parametre duyarlılığını ve zaman adımı küçültüldüğünde sonuçların değişip değişmediğini inceleyin. Simülasyon, tasarımlar arasındaki farkları görünür kılan güçlü bir deney aracıdır; mevzuatın, saha incelemesinin veya uzman güvenlik değerlendirmesinin yerine geçmez.

``

Vatandaş fikrinden çalıştırılabilir senaryoya

Yazılım, “Daha yaşanabilir bir sokak istiyoruz” cümlesini doğrudan hesaplayamaz. Önce önerinin konumu, kapsamı ve beklenen davranış değişikliği tanımlanmalıdır. Örneğin bir bisiklet yolu önerisi; yol kapasitesi, bisiklete geçiş oranı, kavşak düzeni ve yatırım maliyeti gibi parametrelere ayrılır.

Burada vatandaş yalnızca fikir veren kişi değildir: Senaryonun varsayımlarını doğrulayan bir ortak tasarımcıdır. “Bu güzergâh okul saatinde kalabalıklaşıyor” bilgisi, günlük ortalamaların gizlediği önemli bir ayrıntıyı ortaya çıkarabilir.

Simülasyonun teorik motoru

Bir simülasyon; sistemin durumunu, aktörlerini ve zaman içindeki değişimini temsil eder. Ajan tabanlı modellerde insanlar farklı tercihlerle hareket ederken, trafik modelleri araç akışını ve kuyruk oluşumunu hesaplayabilir. SUMO ulaşım simülasyonu, Mesa ise ajan tabanlı deneyler için değerlendirilebilecek araçlardır.

Basitleştirilmiş bir yol bağlantısında seyahat süresi, BPR fonksiyonuyla modellenebilir:

Burada $t_0$ serbest akış süresi, $v$ araç akışı, $c$ kapasitedir. $\alpha$ ve $\beta$ yerel ölçümlerle kalibre edilmelidir. Temel fikir şudur: Kapasiteye yaklaşırken gecikme doğrusal artmak zorunda değildir. Ancak bu formül tek başına kavşakları, kuyruk taşmasını veya bütün ulaşım ağını açıklamaz.

Veriden deney düzenine

Önce mevcut durum modeli kurulur; yol ağı, nüfus, seferler ve anonimleştirilmiş sayımlar birleştirilir. Model, ayrı tutulan gözlemlerle doğrulanır. Ardından her öneri aynı başlangıç koşullarıyla karşılaştırılır. Aksi hâlde yağmurlu pazartesi ile güneşli pazar gününü yarıştırmış oluruz!

Talep belirsizliğini incelemek için Monte Carlo yaklaşımıyla çok sayıda olası gün üretilebilir. Aynı rastgele talepleri bütün senaryolarda kullanmak, karşılaştırmadaki gereksiz gürültüyü azaltır.

Python ile küçük bir senaryo laboratuvarı

Aşağıdaki örnek, bisiklet yatırımı sonrasında otomobil tercihinin azalabileceği varsayımını test eder. Tam bir şehir modeli değildir; yalnızca tek bağlantının gecikmesini hesaplayan öğretici bir prototiptir.

from dataclasses import dataclass
import numpy as np

@dataclass(frozen=True)
class Scenario:
    capacity: float  # araç/saat
    car_share: float

rng = np.random.default_rng(42)
demand = np.clip(rng.normal(1800, 180, 1000), 0, None)
scenarios = {
    "mevcut": Scenario(1200, 0.70),
    "bisiklet": Scenario(1000, 0.55),
}

def travel_time(scenario: Scenario) -> np.ndarray:
    # Talep kişi/saat; doluluk 1.2 kişi/araç varsayılıyor.
    flow = demand * scenario.car_share / 1.2
    return 12 * (1 + 0.15 * (flow / scenario.capacity) ** 4)

baseline = travel_time(scenarios["mevcut"])
for name, scenario in scenarios.items():
    times = travel_time(scenario)
    delta = times - baseline
    print(name, {
        "ortalama_dakika": round(float(times.mean()), 2),
        "p95_dakika": round(float(np.percentile(times, 95)), 2),
        "iyilesme_orani": round(float(np.mean(delta < 0)), 3),
    })

Kod, bin talep örneğinde ortalama süreyi, yüzde 95’lik dilimi ve mevcut duruma göre iyileşme oranını raporlar. Buradaki yüzde 95’lik dilim bir güven aralığı değildir. Otomobil payları, doluluk ve kapasite değerleri varsayımsaldır; sonuçlar gerçek bir yatırımın başarısını kanıtlamaz. Özellikle otomobilden bisiklete geçiş oranı farklı değerlerle tekrar denenmelidir. Ayrıca hesaplanan süre yalnızca otomobillerin bu bağlantıdaki süresidir.

Tek puan mı, şeffaf karşılaştırma mı?

Karar desteği trafik hızından ibaret olmamalıdır. Çevresel fayda, erişilebilirlik, dağıtımsal adalet ve bütçeye uygunluk birlikte değerlendirilebilir:

Burada bütün göstergeler $[0,1]$ aralığına dönüştürülür ve yüksek değer daha iyi durumu gösterir. Ağırlıklar teknik gerçek değil, toplumsal tercihtir. Bu yüzden katılımcılar ağırlıkları değiştirebilmeli; uygulama toplam puanın yanında ham ölçümleri, mahalle bazındaki etkileri ve hangi seçeneğin hangi ölçütte üstün olduğunu göstermelidir.

Güvenilir katılımın kontrol listesi

Çevrim içi öneriler bütün nüfusu temsil etmeyebilir. Yüz yüze toplantılar, erişilebilir arayüzler ve farklı mahallelerden katılım bu açığı azaltır. Sonuçlar gelir, yaş ve engellilik açısından dağıtımsal etkilerle incelenmeli; hassas bilgiler korunmalıdır. Varsayımlar, veri tarihleri ve model sürümleri kaydedilmelidir. Ayrıca inşaat dönemi gibi geçici etkiler unutulmamalıdır.

Sonuçta iyi bir karar destek aracı belediye başkanı rolüne soyunmaz. Alternatifleri görünür kılar, belirsizliği açıklar ve vatandaşların gerekçeli tartışmasını güçlendirir. En değerli çıktı, tek bir kazanan değil; birlikte anlaşılmış bir karar sürecidir.

``

Isı adasının fiziksel mantığı

Kentsel ısı adası, kentlerin çevresindeki kırsal alanlardan daha sıcak olmasıdır. Beton ve asfalt güneş enerjisini depolar; azalan bitki örtüsü, buharlaşma ve terleme yoluyla soğutmayı sınırlar. Binalar hava akışını değiştirirken trafik ve klimalar ek ısı üretir. Gece olduğunda depolanan enerji yavaşça salınır. Yani şehir, gündüz şarj olan dev bir termal batarya gibi davranabilir.

Hava sıcaklığına dayalı etkiyi şöyle tanımlayabiliriz:

Burada karşılaştırılan ölçümler aynı zaman aralığına ait olmalıdır. Referans alanın rakımı, denize uzaklığı ve arazi kullanımı da sonucu etkiler. Rastgele seçilen tek bir kırsal sensör, bütün karşılaştırmayı yanıltabilir.

Uydu ve sensör aynı şeyi ölçmez

Termal uydu ürünleri yüzey sıcaklığını, uygun yerleştirilmiş meteorolojik sensörler ise hava sıcaklığını temsil eder. Güneşteki asfalt yüzeyiyle iki metre yükseklikteki hava arasında ciddi fark olabilir. Bu nedenle ikisini tek sıcaklık sütununda karıştırmak, elmayla tost makinesini karşılaştırmaya benzer.

Landsat termal bantlarının doğal çözünürlüğü yaklaşık 100 metredir; 30 metrelik ürün pikseli, bağımsız 30 metrelik termal ayrıntı anlamına gelmez.

Bitki örtüsünü incelemek için Sentinel-2 üzerinden şu gösterge hesaplanabilir:

Yüksek NDVI genellikle daha yoğun bitki örtüsünü gösterir. Ancak düşük sıcaklığın tek açıklaması değildir; gölge, nem ve rüzgâr da önemlidir.

Analiz hattını hazırlayalım

1. Veriyi temizleyin: Uydu kalite bantlarıyla bulutları maskeleyin. Ürünün ölçek ve ofset bilgilerini uygulayıp sıcaklığı Celsius’a dönüştürün. Sensörlerde hatalı kayıtları ve kalibrasyon sorunlarını kontrol edin.
2. Zamanı eşleyin: Sensörleri gerçek uydu geçişinin çevresindeki dar bir zaman penceresinde özetleyin. Günlük ortalamayla anlık uydu görüntüsünü karşılaştırmayın.
3. Mekânı eşleyin: Verileri aynı, metre birimli yerel koordinat sistemine taşıyın. Örneğin 250 metrelik hücreler oluşturun; bu seçim yeni ayrıntı üretmez.
4. Referansı belirleyin: Birden fazla uygun kırsal istasyonu değerlendirin. Kent ve kırsal sensörlerin benzer koşullarda kurulmasına dikkat edin.

Python ile iki ayrı sıcaklık haritası

Aşağıdaki örnek, hazırlanmış Celsius rasterini hücrelerde özetler ve sensörlerin kırsal referansa göre hava sıcaklığı farkını hesaplar. geopandas, pandas, rasterstats ve matplotlib gerekir. Grid ile raster aynı koordinat sisteminde olmalıdır.

import geopandas as gpd
import pandas as pd
import matplotlib.pyplot as plt
from rasterstats import zonal_stats

grid = gpd.read_file('grid_250m.gpkg')
obs = pd.read_csv('sensorler.csv')
obs['zaman'] = pd.to_datetime(obs['zaman'], utc=True)

# Gerçek uydu geçiş zamanıyla değiştirin.
t = pd.Timestamp('2026-07-15T08:00:00Z')
obs = obs[(obs['zaman'] - t).abs() <= pd.Timedelta('15min')]
obs = obs.groupby(
    ['sensor_id', 'lon', 'lat', 'tur'], as_index=False
).agg(t_air=('sicaklik_c', 'mean'))

ref = obs.loc[obs['tur'] == 'kirsal', 't_air'].mean()
if pd.isna(ref):
    raise ValueError('Zaman penceresinde kırsal referans yok.')

points = gpd.GeoDataFrame(
    obs, geometry=gpd.points_from_xy(obs.lon, obs.lat),
    crs='EPSG:4326'
).to_crs(grid.crs)

stats = zonal_stats(grid, 'lst_celsius.tif',
                    stats=['mean'], nodata=-9999)
grid['lst_c'] = [s['mean'] for s in stats]
joined = gpd.sjoin(points, grid[['geometry']],
                   how='inner', predicate='within')
means = joined.groupby('index_right')['t_air'].mean()
grid['delta_air'] = grid.index.map(means) - ref

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
for ax, column in zip(axes, ['lst_c', 'delta_air']):
    grid.plot(column=column, ax=ax, legend=True,
              missing_kwds={'color': 'lightgrey'})
    ax.set_title(column + ' (°C)')
plt.show()

Önce her sensörün zaman ortalaması alınır; böylece sık kayıt yapan cihaz referansı gereksizce domine etmez. Mekânsal birleştirme sensörleri hücrelere atar. Sensör bulunmayan hücreler gri kalır: veri yokluğu, serinlik değildir.

Haritayı doğru yorumlamak

Sıcak yüzeylerle düşük NDVI birlikte görülüyorsa yeşil altyapı için aday bölgeler belirlenebilir. Yine de korelasyon, nedensellik kanıtı değildir. Rakım, yapı yoğunluğu ve kıyı etkisini ayrıca değerlendirin.

Tek görüntü yerine farklı günleri ve mümkünse gece ölçümlerini karşılaştırın. İnterpolasyon veya tahmin modeli kullanıyorsanız yakın noktaları rastgele bölmek yerine mekânsal doğrulama yapın; aksi hâlde başarı olduğundan yüksek görünebilir. Son haritaya tarih, birim, bulut boşlukları ve belirsizlik bilgisi ekleyin. Amaç yalnızca kırmızı bölgeler çizmek değil, nerede gölgeye ve serinlemeye ihtiyaç olduğunu güvenilir biçimde göstermektir.

Bir uyduyu uzaya göndermek heyecanlıdır; fakat birkaç dakika sonra nerede olacağını bilmek de oldukça önemlidir! Haberleşme antenleri, gözlem planları ve uzay simülasyonları aynı soruya dayanır: Zaman ilerlediğinde cismin konumu nasıl değişir? Bu yazıda Kepler denklemini sayısal olarak çözüp eliptik bir yörüngenin konumunu Python ile hesaplayacağız. ``

Önce fizik: İki cisimlik evren

Modelimizde uydu ve merkezî gök cismi dışında kimse yok. Atmosfer, diğer gezegenler ve Dünya’nın basıklığı şimdilik sahne arkasında. Bu iki cisim yaklaşımında, bağlı bir yörünge elipstir ve merkezî cisim elipsin odaklarından birinde bulunur.

Yörüngeyi tanımlayan temel büyüklükler, yarı büyük eksen $a$ ve dışmerkezlik $e$ değerleridir. Dairesel yörüngede $e=0$, eliptik yörüngede $0<e<1$ olur. Kütleçekim parametresi $\mu=G(m_1+m_2)$ biçimindedir; küçük bir uydu için Dünya’nın değeri yaklaşık $398600.4418\;\mathrm{km^3/s^2}$ alınabilir.

Ortalama açısal hareket ve yörünge periyodu şöyle hesaplanır:

Kilometre kullanıyorsanız bütün uzunlukları kilometre tutmalısınız. Birim karışıklığı, uydunuzu matematiksel olarak başka bir galaksiye göndermenin hızlı yoludur.

Zaman neden doğrudan açı değildir?

Kepler’in ikinci yasası nedeniyle uydu, merkezî cisme yakınken daha hızlı hareket eder. Dolayısıyla elips üzerinde sabit açısal hız varsayamayız. Bunun yerine zamanı, düzgün artan ortalama anomaliye dönüştürürüz:

Buradaki $M_0$, başlangıç anındaki ortalama anomalidir. Gerçek konuma geçmek için yardımcı bir açı olan eksantrik anomaliyi, yani $E$ değerini bulmalıyız:

Bu, meşhur Kepler denklemidir. Genel eliptik durumda $E$ için basit bir kapalı çözüm bulunmadığından sayısal yöntemlere başvururuz. Ortalama anomaliyi doğrudan geometrik açı sanmak, özellikle uzamış elipslerde belirgin konum hataları üretir.

Sayısal yöntem seçimi

Çözmek istediğimiz fonksiyon $f(E)=E-e\sin E-M$, türevi ise $f’(E)=1-e\cos E$ olur. Eliptik yörüngelerde türev pozitiftir; böylece seçtiğimiz aralıkta kök tektir.

Newton güncellemesi $E_{k+1}=E_k-f(E_k)/f’(E_k)$ şeklindedir. Aşağıdaki kod, Newton adımı güvenli aralığın dışına çıkarsa ikiye bölmeye geçer. Böylece yüksek dışmerkezliklerde de daha dayanıklı davranır.

Python ile konumu hesaplayalım

import math


def kepler(M, e, tol=1e-13):
    M = (M + math.pi) % (2 * math.pi) - math.pi
    lo, hi = -math.pi, math.pi
    E = M if e < 0.8 else math.copysign(math.pi, M)

    for _ in range(80):
        f = E - e * math.sin(E) - M
        if abs(f) < tol:
            return E

        if f > 0:
            hi = E
        else:
            lo = E

        candidate = E - f / (1 - e * math.cos(E))
        E = candidate if lo < candidate < hi else (lo + hi) / 2

    raise RuntimeError('Kepler çözümü yakınsamadı')


def position(dt, a, e, M0=0.0, mu=398600.4418):
    if not (a > 0 and mu > 0 and 0 <= e < 1):
        raise ValueError('Eliptik yörünge parametrelerini kontrol edin')

    n = math.sqrt(mu / a**3)
    E = kepler(M0 + n * dt, e)
    x = a * (math.cos(E) - e)
    y = a * math.sqrt(1 - e**2) * math.sin(E)
    return x, y


print(position(dt=1200, a=7200, e=0.05))

dt, başlangıçtan itibaren geçen saniyedir; M0 radyan cinsindendir. Fonksiyon kilometre cinsinden iki koordinat döndürür. Açı normalizasyonu, çözümü tek tur üzerinde tutar. Döngü sınırıysa olası yakınsama sorunlarının sessizce gizlenmesini engeller.

Koordinatların başlangıcı elipsin merkezi değil, kütleçekim odağıdır. Pozitif x ekseni en yakın yaklaşım yönünü gösterir. Kullanılan dönüşüm doğrudan elips geometrisinden gelir:

Sonuçları nasıl sınarız?

Önce $e=0$ seçin: Yarıçap sürekli $a$ olmalıdır. Ardından bir periyot sonraki konumun başlangıçla yaklaşık aynı olduğunu doğrulayın. $M_0=0$ için başlangıç uzaklığı $a(1-e)$, yarım periyot sonraki uzaklık $a(1+e)$ çıkmalıdır. Bunlar hem açı hesabını hem koordinat dönüşümünü sınayan küçük ama güçlü testlerdir.

Örnekteki yörüngenin periyodu yaklaşık 101 dakikadır. Çözüm toleransı denklem artığını sınırlar; özellikle $e$ bire yaklaşırken aynı artık, aynı konum doğruluğunu garanti etmez.

Gerçek uzaya bir adım daha

Ürettiğimiz koordinatlar yörünge düzlemindedir, henüz Dünya merkezli üç boyutlu konum değildir. Bunun için eğim, çıkış düğümü boylamı ve periapsis argümanıyla dönme dönüşümleri uygulanmalıdır. Dünya’ya bağlı koordinatlar için ayrıca Dünya’nın dönüşü hesaba katılır.

Atmosferik sürükleme ve basıklık etkileri uzun vadede önem kazanır. Buradaki model eğitim ve basit simülasyonlar için harikadır; hassas operasyonel takipte daha kapsamlı modeller gerekir. İlk geliştirme olarak konumları zaman boyunca örnekleyip çizin: Kodunuz artık küçük bir yörünge laboratuvarı!

``

Önce problemi doğru tarif edelim

Kaynak optimizasyonunun temelinde yöneylem araştırması bulunur. Sistem; karar değişkenlerini, kısıtları ve hedefleri matematiksel bir modele dönüştürür. Örneğin karar, uygun bir elektif yatışın belirli bir güne planlanıp planlanmayacağı olabilir. Kısıtlar ise kullanılabilir yatakları, bakım saatlerini ve cihaz kapasitesini temsil eder.

Ancak kaynaklar birbirinin yerine geçmez. Boş bir servis yatağı, yoğun bakım yatağının alternatifi değildir; müsait bir çalışan da her uzmanlık görevini üstlenemez. Bu nedenle toplam kapasiteden önce klinik uygunluk ve yetkinlik kontrol edilir.

Matematik: Kapasiteyi aşmadan değer üretmek

Basitleştirilmiş bir günlük modelde $x_i$, aday yatış planlanırsa $1$, aksi durumda $0$ olsun. $u_i$ klinik ekipçe belirlenen öncelik puanını, $a_{ir}$ adayın kaynak tüketimini, $C_r$ ise kapasiteyi göstersin:

Bu yapı, çok boyutlu sırt çantası problemine benzer: Çantamız hastane, bölmeleri ise kaynaklardır. Gerçek modeller ayrıca bekleme süresi, fazla mesai ve iş yükü dengesizliğini ele alır. Bu hedeflerin ağırlıkları gelişigüzel seçilmemeli; klinik yönetişimle belirlenmelidir. Güvenlik şartları, birkaç puan uğruna esnetilen tercihler değil, zorunlu kısıtlardır.

Hangi algoritma, hangi iş için?

Önceliği en yüksek hastayı sırayla yerleştirmek caziptir. Fakat bu hasta kıt bir cihazın çoğunu kullanıyorsa, başka uygun kombinasyonlar toplamda daha iyi sonuç verebilir. Optimizasyonun farkı, kararları tek tek değil, birbirleriyle etkileşimleri içinde değerlendirmesidir.

Python ile küçük bir planlama modeli

Aşağıdaki örnek, OR-Tools üzerinden günlük elektif yatış adaylarını seçer. Kurulum için pip install ortools kullanılabilir. Her satır sırasıyla yatak, hemşirelik saati, cihaz saati ve öncelik puanı içerir; değerler tamamen örnektir.

from ortools.sat.python import cp_model

adaylar = [(1, 8, 6, 9), (1, 10, 8, 8),
           (1, 6, 4, 6), (1, 4, 0, 4)]
kapasiteler = [3, 24, 16]

model = cp_model.CpModel()
x = [model.new_bool_var(f"aday_{i}")
     for i in range(len(adaylar))]

for r, kapasite in enumerate(kapasiteler):
    model.add(sum(adaylar[i][r] * x[i]
                  for i in range(len(adaylar))) <= kapasite)

model.maximize(sum(adaylar[i][3] * x[i]
                   for i in range(len(adaylar))))

solver = cp_model.CpSolver()
solver.parameters.max_time_in_seconds = 2.0
sonuc = solver.solve(model)

if sonuc in (cp_model.OPTIMAL, cp_model.FEASIBLE):
    print([i for i in range(len(adaylar)) if solver.value(x[i])])
else:
    print("Süre içinde uygulanabilir plan bulunamadı.")

Bu veride en iyi seçim, sıfırdan başlayan indekslerle [0, 1, 3] olur. Toplam tüketim üç yatak, 22 hemşirelik saati ve 14 cihaz saatidir. FEASIBLE, uygulanabilir çözüm bulunduğunu söyler; OPTIMAL ise en iyiliğin kanıtlandığını belirtir.

Önemli ayrıntı: Günlük saat toplamı, aynı anda yeterli personel veya cihaz bulunduğunu garanti etmez. Gerçek çizelgelemede zaman aralıkları tanımlanır; NoOverlap tek cihazdaki çakışmaları, Cumulative eşzamanlı kapasite kullanımını sınırlar. Personel yetkinliği ve hasta bakım oranları ayrıca modellenir.

Planı yaşayan bir sisteme dönüştürmek

Acil başvurular, geciken taburculuklar ve cihaz arızaları planı değiştirir. Bu yüzden tahminler senaryolarla sınanmalı, beklenmedik talep için kapasite tamponu bırakılmalı ve plan düzenli güncellenmelidir. Her değişimde tüm vardiyayı dağıtmak yerine, mevcut plana sadakati gözeten cezalar kullanılabilir.

Başarıyı yalnızca yatak doluluğuyla ölçmeyin: Bekleme süresi, fazla mesai, iptaller, bakım güvenliği ve çalışan yükü birlikte izlenmelidir. Sistem karar desteğidir; acil bakımın reddini otomatikleştirmez. Klinik onay, insan müdahalesi, erişim kontrolü ve denetlenebilir karar kayıtları korunmalıdır. İyi algoritma, hastaneyi bir elektronik tabloya değil, daha uyumlu çalışan bir ekibe dönüştürür.

Battle Royale oyunlarında asıl rakibiniz bazen karşınızdaki oyuncu değil, arkanızdan yaklaşan çemberdir. Daralan harita, devasa bir oyun alanını giderek küçülen bir karar kutusuna dönüştürür. Oyuncuya görünmez bir yönetmen gibi seslenir: “Eşyalarını topladın mı? Güzel, şimdi biraz hareket zamanı!” Peki bu basit geometrik fikir, davranışları nasıl bu kadar güçlü biçimde şekillendiriyor?

``

Büyük Haritadan Ortak Finale

PUBG ve Fortnite gibi oyunların popülerleşmesini yalnızca daralan haritaya bağlamak eksik olur. Erişilebilirlik, sosyal oyun deneyimi ve yayın kültürü de önemli etkenlerdir. Ancak güvenli bölge, bu türün seyir zevkini ve maç ritmini taşıyan temel mekaniklerden biridir.

Başlangıçta oyuncular farklı noktalara dağılır; keşif, ekipman toplama ve çatışmadan kaçınma mümkündür. Bölge daraldıkça bu özgürlük azalır. Böylece birbirinden bağımsız küçük hikâyeler, ortak bir final sahnesinde birleşir. Tasarımcı her karşılaşmayı senaryolaştırmadan gerilimi artırabilir.

Teorik Temel: Alan Azalınca Ne Değişir?

Dairesel güvenli bölgenin alanı $A(t)=πr(t)^2$ olarak ifade edilir. Burada $r(t)$, zamana bağlı yarıçaptır. Yarıçap yarıya indiğinde alan dörtte bire düşer. Yani harita küçülmesi, oyuncunun gözünde göründüğünden daha sert bir alan kaybı yaratabilir.

Yaşayan oyuncu sayısını $N(t)$ ile gösterirsek ortalama yoğunluk $ρ(t)=N(t)/A(t)$ olur. Oyuncu sayısı azalmasına rağmen alan daha hızlı küçülüyorsa yoğunluk artabilir. Bunun karşılaşma ihtimalini yükseltmesi beklenir; fakat oyuncular eşit dağılmadığından bu, kesin bir çatışma formülü değildir. Binalar, görüş çizgileri ve yüksek araziler sonucu değiştirir.

Çemberin Davranışsal Etkisi

Daralan bölge, hareketsiz kalmanın maliyetini yükseltir. Normalde güvenli görünen bir bina, birkaç dakika sonra tehlikeli bir tuzağa dönüşebilir. Böylece oyun, oyuncuyu zorunlu hareket ile taktiksel bekleme arasında seçim yapmaya iter.

Erken hareket eden oyuncu uygun siper bulabilir; fakat merkezde daha fazla yönden tehdit alabilir. Kenarda kalan oyuncu arkasını daha kolay kontrol edebilir, ancak sonraki bölgeye uzun yol katetmek zorunda kalabilir. Dolayısıyla “merkeze koşmak” her durumda en iyi strateji değildir.

Bu yapı karar teorisiyle okunabilir: Oyuncu beklenen kazancı, hasar riskini ve zaman maliyetini birlikte değerlendirir. Çember bu maliyetleri sürekli değiştirerek aynı taktiğin bütün maç boyunca işe yaramasını engeller.

Küçük Bir Python Davranış Modeli

Aşağıdaki örnek, botun olası hedef noktalarını yolculuk süresi, bölge dışında kalma ve görünürlük riski üzerinden puanlar. Düşük puanlı hedef tercih edilir:

import math


def radius_at(t, start=1000, end=250, delay=60, duration=120):
    progress = min(1.0, max(0.0, (t - delay) / duration))
    return start + (end - start) * progress


def choose_target(position, candidates, center, radius, speed=6):
    def cost(point):
        travel_time = math.dist(position, point) / speed
        outside = max(0.0, math.dist(point, center) - radius)
        exposure = candidates[point]
        return travel_time + 0.4 * outside + 12 * exposure

    return min(candidates, key=cost)


candidates = {(100, 100): 0.8, (300, 50): 0.2, (600, 0): 0.1}
future_radius = radius_at(120)
target = choose_target((500, 100), candidates, (0, 0), future_radius)
print(target)

radius_at, bekleme süresinden sonra yarıçapı doğrusal küçültür. choose_target ise adayların görünürlük değerlerini kullanır; bu değerler burada elle verilmiştir. Katsayılar farklı maliyetleri ortak bir tercih puanına dönüştüren tasarım ağırlıklarıdır, fiziksel hasar hesabı değildir.

Bu model engelleri ve hareket sırasında değişen çemberi hesaba katmaz. Gerçek bir oyunda yol bulma, takım bilgisi ve bölge hasarı da değerlendirmeye eklenmelidir.

İyi Baskı, Kötü Sürprizden Nasıl Ayrılır?

Başarılı bir çember sistemi oyuncuyu sıkıştırırken karar verecek zaman bırakır. Belirsizlik heyecan yaratır; okunamayan veya ulaşılması aşırı zor bölgeler ise sonucu beceriden çok şansa bağlayabilir.

Geliştiriciler daralma hızını, uyarı süresini ve dışarıda alınan hasarı birlikte ayarlamalıdır. Çok yavaş çember temposuzluk, çok hızlı çember ise sürekli koşu üretir. Telemetride bölge kaynaklı ölümler, hareketin başlama zamanı ve çatışmaların konumu izlenebilir; ancak bu ölçümler oyuncu deneyimiyle birlikte yorumlanmalıdır.

Sonuçta daralan harita yalnızca oyuncuları yaklaştırmaz: Kaynakların değerini, risk algısını ve zamanın önemini değiştirir. Battle Royale’ın güçlü numarası budur; basit bir geometrik kural, her maçta farklı bir stratejik hikâye üretir.

``

Önce mantık: Başlık dosyası ne sağlar?

#include, ilgili başlık dosyasını programa dahil eder. Başlıklar, fonksiyon bildirimlerini, türleri ve gerekli makroları sunar; fonksiyonların gerçek uygulamaları ise kütüphanelerdedir. Derleyici çağrının türlerini denetler, bağlayıcı gerekli uygulamaları birleştirir. Kısacası başlık dosyası menüdür; yemeği hazırlayan mutfak, kütüphanenin uygulamasıdır. Bu ayrım, derleme hatasıyla bağlama hatasını birbirinden ayırmayı kolaylaştırır.

Matematik: Formülü yeniden icat etmeyin

<math.h>, kayan noktalı hesaplamalar için temel araç kutusudur. sqrt(x) karekök, pow(x, y) üs, fabs(x) mutlak değer hesaplar. Tamsayılar için kullanılan abs ise <stdlib.h> içindedir. floor, ceil ve round farklı yuvarlama kurallarına sahiptir; özellikle negatif sayılarda birbirlerinin yerine kullanılmamalıdır.

İki noktanın uzaklığı şu bağıntıyla bulunur:

Bu hesap için hypot(dx, dy), ara işlemlerde taşma ve aşırı küçülme riskini azaltabilir. Trigonometrik fonksiyonlar radyan bekler. Ayrıca kayan nokta sonuçları yaklaşık olabilir; matematikteki eşitlik, bilgisayarda her zaman birebir eşitlik değildir. Negatif bir değerin karekökü gibi tanım dışı girdilerin hata davranışı da kontrol edilmelidir.

Metin işleme: Sonlandırıcı karakteri unutmayın

C dizeleri, \0 karakteriyle biten karakter dizileridir. strlen, bu sonlandırıcıdan önceki baytların sayısını verir; UTF-8 metindeki görünen harf sayısını garanti etmez. strcmp eşitlik durumunda sıfır döndürür, diğer durumlarda işaretine bakılır; yalnızca -1 veya 1 döneceğini varsaymayın.

memcpy, belirtilen sayıda baytı kopyalar ve bölgeler örtüşmemelidir. Örtüşme ihtimali varsa memmove kullanılır. strncpy ise her durumda sonlandırıcı eklemez; adı güvenlik garantisi değildir. Dize fonksiyonları sonlandırıcıya, bellek fonksiyonları verilen uzunluğa güvenir.

<ctype.h> fonksiyonlarına sıradan bir char verirken (unsigned char) dönüşümü yapmak önemlidir; negatif karakter değerleri tanımsız davranışa neden olabilir.

Bellek yönetimi: Alanın sahibi sizsiniz

Dinamik bellek, boyutu çalışma sırasında belirlenen verileri saklamaya yarar. Ayırdığınız alanın kapasitesi ile içine koyduğunuz verinin uzunluğu farklı kavramlardır. Dize için gereken kapasite genellikle $uzunluk + 1$ bayttır; fazladan bayt sonlandırıcı içindir. Ayırma işleminin başarısız olabileceğini de unutmamak gerekir.

Birlikte çalışan küçük bir örnek

Aşağıdaki program bir metni dinamik belleğe kopyalar, kapasitesini artırır ve matematik fonksiyonlarıyla sonuç üretir. Böylece üç araç kutusunu aynı yerde görürüz.

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    const char *kaynak = "Merhaba C";
    size_t kapasite = strlen(kaynak) + 1;
    char *metin = malloc(kapasite);
    if (metin == NULL) {
        return EXIT_FAILURE;
    }

    memcpy(metin, kaynak, kapasite);
    char *yeni = realloc(metin, kapasite + 16);
    if (yeni == NULL) {
        free(metin);
        return EXIT_FAILURE;
    }
    metin = yeni;
    strcat(metin, "!");

    printf("%s | Uzunluk: %zu | Kok: %.2f | Us: %.2f\n",
           metin, strlen(metin), sqrt(9.0), pow(2.0, 3.0));
    free(metin);
    return EXIT_SUCCESS;
}

memcpy, sonlandırıcı dahil bütün diziyi kopyalar. Eklenen kapasite, ünlem ve sonlandırıcı için yeterlidir. realloc sonucu geçici işaretçide tutulur: Sıfırdan büyük boyutla yapılan çağrı başarısız olursa eski alan geçerliliğini korur. Sonucu doğrudan metin üzerine yazmak, eski adresi kaybettirebilir.

Birçok Unix benzeri ortamda matematik kütüphanesini ayrıca bağlamak gerekir:

cc -std=c11 -Wall -Wextra main.c -o uygulama -lm

Son kontrol listesi basittir: Kapasiteleri doğrulayın, dönüş değerlerini inceleyin ve ayırdığınız belleği bırakın. Genel boyut hesaplarında n * sizeof(eleman) çarpımının taşmasını önceden denetleyin. Serbest bırakılmış belleğe erişmeyin. Hazır fonksiyonlar işi hızlandırır; güvenli kullanım ise hâlâ programcının sorumluluğudur.

``

Önce mantık: Nesne mi, kaynak mı kopyalanıyor?

Kopyalama kurucusu yeni bir nesneyi mevcut nesneden oluşturur: Buffer b = a;. Kopyalama atama operatörü ise zaten yaşayan bir nesnenin değerini değiştirir: b = a;. İkinci durumda hedefin önceki kaynakları da hesaba katılmalıdır.

Derleyicinin ürettiği işlemler, taban sınıfları ve üyeleri kendi kopyalama davranışlarıyla kopyalar. Bu nedenle otomatik kopyalama, her zaman “sığ kopyalama” demek değildir: std::vector kendi elemanlarını kopyalar. Fakat ham işaretçi üyesinde yalnızca adres kopyalanır:

İki farklı nesne artık aynı kaynağa bakmaktadır. Bunun doğru olup olmadığı, sınıfın sahiplik sözleşmesine bağlıdır.

Tehlikenin klasik hali: İki sahip, tek bellek

Aşağıdaki sınıf belleği kendisi ayırıyor ve yok edilirken serbest bırakıyor. Dolayısıyla işaretçinin sahibi olduğunu varsayıyor:

struct BadBuffer {
    char* data = new char[16];

    ~BadBuffer() {
        delete[] data;
    }
};

void example() {
    BadBuffer a;
    BadBuffer b = a; // Yalnızca adres kopyalanır.

    BadBuffer c;
    c = a;          // c'nin eski belleği kaybolur.
}

Kopyalama kurucusu burada iki nesneye aynı adresi verir. Nesneler yok edildiğinde aynı bellek tekrar serbest bırakılmaya çalışılır: tanımsız davranış ortaya çıkar. Program çökebilir, sessizce bozulabilir veya şimdilik çalışıyor gibi görünebilir.

Atama daha da sinsidir: c kendi eski adresini kaybettiği için bellek sızıntısı oluşturur; ardından ortak adres nedeniyle aynı serbest bırakma sorununa katılır. Derleyici fotokopi çekmiştir, ama herkes belgenin tek sahibi olduğunu sanmaktadır!

Benzer riskler dosya tanıtıcıları ve işletim sistemi tutamaçlarında da vardır. Ayrıca başka bir üyeye işaret eden iç işaretçiler kopyalandığında, yeni nesne yanlışlıkla eski nesnenin içine bakabilir. Sorun yalnızca delete değildir; sınıfın değişmezlerinin bozulmasıdır.

Elle çözüm: Derin kopyalama ve güvenli atama

Bağımsız sahiplik istiyorsak, yeni bellek ayırıp içeriği kopyalamalıyız. Atamada ise mevcut kaynağı koruyarak ilerlemek önemlidir. Aşağıdaki copy-and-swap yaklaşımı, önce kopyayı hazırlar; başarılı olursa kaynakları değiş tokuş eder:

#include <algorithm>
#include <cstddef>
#include <utility>

class Buffer {
    std::size_t size_;
    char* data_;

public:
    explicit Buffer(std::size_t size)
        : size_(size), data_(new char[size]{}) {}

    Buffer(const Buffer& other)
        : Buffer(other.size_) {
        std::copy_n(other.data_, size_, data_);
    }

    ~Buffer() {
        delete[] data_;
    }

    void swap(Buffer& other) noexcept {
        std::swap(size_, other.size_);
        std::swap(data_, other.data_);
    }

    Buffer& operator=(Buffer other) {
        swap(other);
        return *this;
    }
};

Değerle alınan other, bağımsız kopyadır. Bellek ayırma başarısız olursa hedef nesne değişmez. Takastan sonra hedefin eski belleğini other temizler. Bu yaklaşım kendine atamayı da güvenle karşılar; ancak gereksiz bir kopyalama yapabilir.

$n$ baytlık veri için derin kopyalamanın zaman ve ek bellek maliyeti yaklaşık $O(n)$ düzeyindedir. Doğruluk bedava değildir, fakat tanımsız davranış çok daha pahalıdır.

Daha iyi seçenek: Rule of Zero

Rule of Three, yıkıcı, kopyalama kurucusu veya kopyalama atamasını özelleştiriyorsanız diğerlerini de değerlendirin der. Modern C++’ta taşıma işlemleriyle birlikte Rule of Five gündeme gelir. Yukarıdaki sınıf güvenli kopyalanır, fakat özel taşıma işlemleri sağlamaz; taşıma beklenen bazı durumlarda kopyalama yapılabilir.

Çoğu uygulamada en temiz çözüm, kaynak yönetimini hazır türlere devretmektir:

#include <vector>

struct Buffer {
    std::vector<char> data;
};

Bu tasarımda Rule of Zero uygulanır: özel yıkıcı veya kopyalama işlemleri yazmanız gerekmez. std::unique_ptr ise tek sahipliği ifade eder; onu içeren sınıfın otomatik kopyalama işlemleri genellikle silinir.

Son kontrol sorusu şudur: Bu nesneyi kopyaladığımda kaynak paylaşılmalı mı, çoğaltılmalı mı, yoksa kopyalama yasaklanmalı mı? Cevap açık değilse, otomatik üretilen işlemlere güvenmeden önce sahiplik modelini netleştirin.

Bir tarlada binlerce bitki yetiştirip en başarılı olanları seçmek yerine, önce bilgisayarda küçük bir “dijital sera” kurabiliriz. Genetik algoritmalar, aday genetik kombinasyonları nesiller boyunca değerlendirerek verim, su ihtiyacı ve hastalık direnci arasında iyi dengeler arar. Amaç sihirli tohumu bulmak değil, gerçek ıslah deneylerinde sınanabilecek umut verici adayları daraltmaktır.

``

Genotipten fenotipe: Modelin kalbi

Her aday bitki, kalıtsal özelliklerini temsil eden bir genotip taşır. Ancak gözlediğimiz özellikler, yani fenotip, yalnızca genotipten doğmaz; çevre ve genotip–çevre etkileşimi de sonucu değiştirir. Aynı çeşit sulanan tarlada yıldızlaşırken kurak arazide sıradan kalabilir. Dolayısıyla simülasyon, genetik bilgiyi özelliklere dönüştüren açık bir modele ihtiyaç duyar.

Örneğimizde bitkiyi, aynı kromozomun iki kopyasında bulunan altı lokusla temsil edeceğiz. Her lokusta iki olası alel vardır: 0 ve 1. Bu, gerçek bir türün ayrıntılı genetik haritası değil, kalıtım mantığını öğrenmek için sadeleştirilmiş bir oyuncak modeldir.

İyi bitkiyi nasıl puanlarız?

Üç normalize özellik kullanalım: potansiyel verim $Y$, su tüketimi $W$ ve hastalık direnci $R$. Her özellik, lokuslardaki alel dozlarının ağırlıklı toplamından hesaplanır. Ağırlıklar örnekte keyfîdir; gerçek uygulamada kontrollü deneylerden veya genomik tahmin modellerinden öğrenilmelidir.

Kuraklık şiddeti $s$ arttıkça yüksek su tüketiminin verimi daha fazla düşürdüğünü varsayalım:

Burada $E$, sınanan çevreler kümesidir. Büyük $F$ daha iyi aday demektir. Katsayılar yetiştiricinin önceliklerini yansıtır; evrensel biyoloji yasaları değildir. Özellikleri normalize etmek, farklı ölçüm birimlerinin puanı kazara ele geçirmesini önler. Kod eklemeli gen etkileri kullanır; dominans ve epistaz sonraki geliştirmelerdir.

Evrim döngüsünü Python ile kurmak

Algoritma rastgele bir popülasyonla başlar. Turnuva seçimi güçlü adaylara üreme avantajı sağlar. Ebeveynlerin kromozomlarından tek kesim noktalı rekombinasyonla gametler üretilir; iki gamet yavruyu oluşturur. Düşük oranlı mutasyon çeşitliliği destekler. Elitizm ise en iyi iki adayın sonraki nesilde korunmasını sağlar.

Aşağıdaki NumPy kodu, bu döngüyü üç kuraklık seviyesinde çalıştırır ve son popülasyonun en iyi adayını yazdırır:

import numpy as np

rng = np.random.default_rng(42)
L, N = 6, 80
E = np.array([0.0, 0.3, 0.6])
A = np.array([[3, 2, 4, 1, 2, 3],
              [2, 3, 1, 4, 2, 1],
              [1, 4, 2, 1, 3, 2]])
pop = rng.integers(0, 2, size=(N, 2, L))

def fitness(g):
    d = g.mean(axis=0)
    y, w, r = (A @ d) / A.sum(axis=1)
    return float(np.mean(0.55*y*(1-E*w)+0.25*r-0.20*w))

def select(scores):
    ids = rng.choice(N, 3, replace=False)
    return pop[ids[np.argmax(scores[ids])]]

def gamete(g):
    cut = rng.integers(1, L)
    h = rng.integers(2)
    c = np.r_[g[h, :cut], g[1-h, cut:]].copy()
    c ^= (rng.random(L) < 0.01).astype(int)
    return c

for _ in range(60):
    scores = np.array([fitness(g) for g in pop])
    new = [g.copy() for g in pop[np.argsort(scores)[-2:]]]
    while len(new) < N:
        new.append(np.stack([gamete(select(scores)),
                             gamete(select(scores))]))
    pop = np.array(new)

best = max(pop, key=fitness)
print(round(fitness(best), 4), best.tolist())

g.mean(axis=0), iki kromozomdaki alel dozunu sıfır ile bir arasına taşır. A matrisinin satırları özellik etkilerini belirler. Mutasyon burada aleli diğer ikili duruma çevirir. Sabit rastgelelik tohumu sonucu yeniden üretmeyi kolaylaştırır; tek koşunun güvenilir olduğunu göstermez.

Sonucu gerçekten test etmek

Sadece son puana bakmayın. Nesiller boyunca en iyi ve ortalama uygunluğu, ayrıca genetik çeşitliliği kaydedin. Ortalama yükselirken çeşitlilik hızla çöküyorsa popülasyon erken yakınsamış olabilir. Farklı rastgelelik tohumlarıyla tekrarlar yapın; aynı değerlendirme bütçesi altında rastgele aramayı da karşılaştırmaya ekleyin.

Seçimde kullanılan çevrelerden ayrı test çevreleri ayırmak, modele aşırı uyumu yakalamaya yardımcı olur. Gerçek veride eğitim ve değerlendirme ayrımı da korunmalıdır. Son olarak, hiçbir simülasyon tohumu doğrudan şampiyon ilan edemez: dijital sera aday önerir, tarla karar verir. En iyi başlangıç, varsayımları görünür olan küçük bir modeldir.