Erişilebilir Grafik

Yedi ders boyunca ölçülen şey kanalın taşıdığı sayıydı ve her seferinde okuyucunun kanalı okuyabildiği varsayıldı. Bu ders o varsayımı ölçer. Bir gösterimde birden çok seri varsa ilk soru serilerin değerlerinin doğru okunup okunmadığı değildir; ilk soru hangi serinin hangisi olduğudur. Bir seri komşusundan ayırt edilemiyorsa değeri de raporlanmamış sayılır.

Karşıtlık oranı hesabı, renk sistemleri ve erişilebilirlik ölçütleri Arayüz Temelleri kursunda ve erişilebilirlik kurslarında kuruldu; bunların hiçbiri burada tekrarlanmaz ve hiçbir renk sistemi adı yazılmaz. Buradaki soru veriye özgüdür ve tek bir sayıyla ölçülür: ayırt edilebilir seri sayısı. Renk tek kodlama kanalıyken bu sayı kaç, ve yedekli kodlama onu kaça çıkarıyor.

• GT43. Renk bir ad değil iki sayıdır. Modelde renk, ton ailesi ile aydınlık basamağından oluşur. Kodlayıcı seriye bir çift atar; hiçbir renk adı ya da sistemi anılmaz.
• GT44. Okuma çözünürlüğü iki basamaktır. İki aydınlık basamağı en az iki basamak farklı olmadan ayırt edilemez, çünkü gösterimde seriler ince çizgilerdir ve birbirinden uzakta durur; yan yana konmuş iki geniş yüzeyin ayrımı bu değildir.
• GT45. İki çözücü koşar. Tam çözücü ton ailesini de aydınlık basamağını da okur. Daralmış çözücü ton ayrımını okumaz ve yalnız aydınlık basamağını görür; ikisi de aynı kodlamaya uygulanır.
• GT46. Ayırt edilebilir seri sayısı küme sayısıdır. Birbirinden ayırt edilemeyen seriler tek bir kümede toplanır; geri okunan seri sayısı küme sayısıdır ve serilerin toplamından küçük olur.
• GT47. Yedekli kodlamanın yeri sonucu belirler. İkinci bir kanal eklemek tek başına yetmez; kanalın, rengin çakıştığı eksende değişmesi gerekir.
• GT48. Tek gösterimin bir tavanı vardır. Tavan, ayırt edilebilir basamak sayısı ile şekil sayısının çarpımıdır; üzerinde gösterim parçalanmadan seri sayısı geri okunamaz.

Renk Tek Kanalken

# seri.py — MODELDIR: K03-K05'in kurgu olcum agi ayni tohumla uretilir.
# Sekiz seri ayni 3.199 okumanin alt kumeleridir: bes bolge ve uc tarife
# basamagi. Renk bir ad degil, iki sayidir: ton ailesi ve aydinlik basamagi.
import math

TOHUM, HAM, M32 = 20260218, 1400, 0xFFFFFFFF
DONEM = ["2026-01", "2026-02", "2026-03"]
TARIFE = [10, 25, 40]
BOLGE = [("kuzey", 0.28, 21), ("guney", 0.22, 17), ("dogu", 0.18, 26),
         ("bati", 0.14, 14), ("merkez", 0.18, 23)]


def uretec(t):
    x = ((t ^ (t >> 16)) * 2246822507) & M32
    x = ((x ^ (x >> 13)) * 3266489909) & M32
    s = [(x ^ (x >> 16)) & M32]

    def sonraki():
        s[0] = (s[0] * 1664525 + 1013904223) & M32
        return s[0] / 4294967296
    return sonraki


def ayrik(u, w):
    t = 0.0
    for i, x in enumerate(w):
        t += x
        if u < t:
            return i
    return len(w) - 1


_k, _e = [], []
for i in range(HAM):
    r = uretec(TOHUM + i)
    b = BOLGE[ayrik(r(), [x[1] for x in BOLGE])]
    ayrik(r(), [0.06, 0.24, 0.30, 0.24, 0.11, 0.05])
    ayrik(r(), [0.08, 0.14, 0.27, 0.34, 0.17])
    (_e if r() < 0.046 else _k).append(
        {"abone_no": 10001 + i, "bolge": b[0], "taban": b[2]})
GECERLI = {a["abone_no"] for a in _k}

OKUMA = []
for a in _k + _e:
    r = uretec(TOHUM + 7000 + a["abone_no"])
    for d in range(ayrik(r(), [0.05, 0.12, 0.21, 0.62])):
        t = 0.0 if r() < 0.038 else math.floor(
            a["taban"] * math.exp((r() + r() + r() - 1.5) * 0.62)
            * (1 - d * 0.05) * 100 + 0.5) / 100
        if a["abone_no"] not in GECERLI:
            r()
            continue
        OKUMA.append({"abone_no": a["abone_no"], "bolge": a["bolge"],
                      "donem": DONEM[d], "tuketim_m3": t})
        r()


def basamak(v):
    return 1 + sum(1 for t in TARIFE if v >= t)


def ortala(f):
    v = [o["tuketim_m3"] for o in OKUMA if f(o)]
    return sum(v) / len(v), len(v)


SERI = []
for ad, _, _ in BOLGE:
    d, n = ortala(lambda o, x=ad: o["bolge"] == x)
    SERI.append((ad, d, n))
for bs in (2, 3, 4):
    d, n = ortala(lambda o, x=bs: basamak(o["tuketim_m3"]) == x)
    SERI.append((f"basamak{bs}", d, n))

# Renk kanali: ton ailesi (0/1) ve aydinlik basamagi (0-8). Palet iki aileden
# dorder basamak seciyor; bu, sekiz seri icin dogal bir varsayilan dagilimdir.
BASAMAK_SAYISI, AYIRMA, SEKIL_SAYISI = 9, 2, 4
PALET = [(i // 4, [1, 3, 5, 7][i % 4]) for i in range(len(SERI))]


def tam_cozucu(x, y):
    """Iki seri ayirt edilir mi: ton farkli ya da basamak farki AYIRMA kadar."""
    return x[0] != y[0] or abs(x[1] - y[1]) >= AYIRMA


def daralmis_cozucu(x, y):
    """Ton ayrimini okumayan cozucu yalniz aydinlik basamagini gorur."""
    return abs(x[1] - y[1]) >= AYIRMA


def ayirt_edilebilir(kod, cozucu):
    """Ayirt edilemeyen seriler tek kume olur; kume sayisi geri okunan seridir."""
    kok = list(range(len(kod)))

    def bul(i):
        while kok[i] != i:
            kok[i] = kok[kok[i]]
            i = kok[i]
        return i
    for i in range(len(kod)):
        for j in range(i + 1, len(kod)):
            if not cozucu(kod[i], kod[j]):
                kok[bul(i)] = bul(j)
    return len({bul(i) for i in range(len(kod))})


print(f"{len(SERI)} seri, hepsi ayni {len(OKUMA)} okumanin alt kumesi")
print("seri        gozlem  ortalama  ton  basamak")
for (ad, d, n), (t, bsm) in zip(SERI, PALET):
    print(f"{ad:11s} {n:6d} {d:9.3f} {t:4d} {bsm:8d}")
print(f"okuma cozunurlugu: iki aydinlik basamagi en az {AYIRMA} basamak "
      f"farkli olmadan ayirt edilemez")
print(f"tam cozucuyle ayirt edilebilir seri: "
      f"{ayirt_edilebilir(PALET, tam_cozucu)}/{len(SERI)}")
print(f"ton ayrimini okumayan cozucuyle: "
      f"{ayirt_edilebilir(PALET, daralmis_cozucu)}/{len(SERI)}")

8 seri, hepsi ayni 3199 okumanin alt kumesi
seri        gozlem  ortalama  ton  basamak
kuzey          921    20.210    0        1
guney          645    16.602    0        3
dogu           557    24.674    0        5
bati           476    13.778    0        7
merkez         600    22.396    1        1
basamak2      2209    17.506    1        3
basamak3       692    30.009    1        5
basamak4        58    44.171    1        7
okuma cozunurlugu: iki aydinlik basamagi en az 2 basamak farkli olmadan ayirt edilemez
tam cozucuyle ayirt edilebilir seri: 8/8
ton ayrimini okumayan cozucuyle: 4/8

Palet kusursuz görünüyor. Sekiz serinin sekizi de ayrı bir renk çifti almış, hiçbir çift tekrarlanmamış ve tam çözücü sekizini de ayırt ediyor. Bu, paleti seçen kişinin gördüğü sonuçtur.

Alt satır aynı paletin ikinci çözücü altında ne olduğunu söylüyor: 8 seriden 4’ü kalıyor. Kuzey ile merkez aynı aydınlık basamağını taşıyor, güney ile ikinci tarife basamağı aynı, doğu ile üçüncüsü aynı, batı ile dördüncüsü aynı. Dört seri çifti tek bir seriye iniyor ve her çiftin hangi üyesinin okunduğu belirsiz kalıyor. Rapor, 3.199 okumanın sekiz alt kümesini gösterdiğini sanıyorken dördünü gösteriyor.

Bu bir palet kusuru değil, bir yapı kusurudur. Palet iki ton ailesini dört aydınlık basamağıyla çaprazlamış ve sekiz gözü doldurmuş; ton ailesi okunamadığında çapraz tabloda sütun kalıyor, satır kalmıyor. Renk tek kodlama kanalıysa bu sonuç kaçınılmazdır ve paletteki renk sayısını artırmak işe yaramaz.

Yedekli Kodlama Nereye Eklenir

# yedek.py — sekil kanali eklenir. Nereye eklendigi sonucu belirler.
SIRAYLA = [(p[0], p[1], i % SEKIL_SAYISI) for i, p in enumerate(PALET)]
CAKISMAYA = [(p[0], p[1], i // SEKIL_SAYISI) for i, p in enumerate(PALET)]


def sekilli(x, y):
    return daralmis_cozucu(x, y) or x[2] != y[2]


print("katman                        tam cozucu  daralmis cozucu")
for ad, kod, coz in (("yalniz renk", PALET, daralmis_cozucu),
                     ("renk + sekil (sirayla)", SIRAYLA, sekilli),
                     ("renk + sekil (cakismaya)", CAKISMAYA, sekilli)):
    tam = ayirt_edilebilir([k[:2] for k in kod], tam_cozucu)
    print(f"{ad:28s} {tam:11d} {ayirt_edilebilir(kod, coz):16d}")
print(f"sirayla dagitilan sekil {SEKIL_SAYISI} tanedir ve {SEKIL_SAYISI}. seride "
      f"bastan basliyor; renk cakismasi da {SEKIL_SAYISI} seri arayla oldugu "
      f"icin iki cakisma ust uste geliyor")

katman                        tam cozucu  daralmis cozucu
yalniz renk                            8                4
renk + sekil (sirayla)                 8                4
renk + sekil (cakismaya)               8                8
sirayla dagitilan sekil 4 tanedir ve 4. seride bastan basliyor; renk cakismasi da 4 seri arayla oldugu icin iki cakisma ust uste geliyor

Orta satır bu dersin en pahalı bulgusudur. Şekil kanalı eklendi, dört ayrı şekil serilere sırayla dağıtıldı ve daralmış çözücünün okuduğu sayı dörtte kaldı. Yedekli kodlama eklendi ama hiçbir şey düzelmedi.

Nedeni son satırdadır. Şekiller dört tanedir ve beşinci seride başa döner; paletin renk çakışması da tam dört seri arayladır. İki dönüş üst üste gelince aynı çakışan çiftler bu kez hem aynı basamağı hem aynı şekli paylaşır. İkinci kanal, birincinin çakıştığı yerde birlikte çakışıyor.

Üçüncü satır düzeltmeyi veriyor: şekil, sıraya göre değil çakışmaya göre dağıtıldığında — yani ilk dört seri bir şekil, sonraki dört seri başka bir şekil aldığında — daralmış çözücü de sekizini ayırt ediyor. Kullanılan şekil sayısı dörtten ikiye indi ve sonuç iyileşti. Yedekli kodlamanın ölçüsü kanal sayısı değil, kanalın nerede değiştiğidir.

Gösterge Kutusu ve Geçiş Sayısı

# gecis.py — gosterge kutusu okuyucuyu gosterimle kutu arasinda gidip
# getirir. Sag kenar konumu ucuncu bir kanaldir ve sirayi tasir.
SATIR = 12
enaz, encok = min(d for _, d, _ in SERI), max(d for _, d, _ in SERI)
konum = [round((d - enaz) / (encok - enaz) * (SATIR - 1)) for _, d, _ in SERI]
cakisan = sum(1 for i in range(len(SERI)) for j in range(i + 1, len(SERI))
              if konum[i] == konum[j])
tekil = [i for i in range(len(SERI))
         if all(konum[i] != konum[j] for j in range(len(SERI)) if j != i)]
print(f"sag kenar konumlari ({SATIR} satir): {konum}")
print(f"{len(SERI)} serinin {len(tekil)} tanesinin konumu tekil, "
      f"{cakisan} cift ayni satira dusuyor")
kutu = 2 * len(SERI)
sirali = 2 + 2 * (len(SERI) - len(tekil))
print("duzen                      gecis sayisi  ayirt edilebilir seri")
for ad, g, s in (("gosterge kutusu", kutu, ayirt_edilebilir(CAKISMAYA, sekilli)),
                 ("sirali gosterge kutusu", sirali,
                  ayirt_edilebilir(CAKISMAYA, sekilli)),
                 ("dogrudan etiketleme", 0, len(SERI))):
    print(f"{ad:26s} {g:13d} {s:22d}")

sag kenar konumlari (12 satir): [2, 1, 4, 0, 3, 1, 6, 11]
8 serinin 6 tanesinin konumu tekil, 1 cift ayni satira dusuyor
duzen                      gecis sayisi  ayirt edilebilir seri
gosterge kutusu                       16                      8
sirali gosterge kutusu                 6                      8
dogrudan etiketleme                    0                      8

Ayırt edilebilirlik gerekli koşuldur, yeterli değildir. Sekiz seri birbirinden ayrılıyor olabilir ve okuyucu yine de hangisinin hangi bölge olduğunu bilmez; bunu ancak gösterge kutusuna bakarak öğrenir. Ölçü burada geçiş sayısıdır: bakışın gösterimle gösterge kutusu arasında kaç kez gidip geldiği.

Sıradan bir gösterge kutusu her seri için bir gidiş bir geliş ister; sekiz seri 16 geçiş eder. Gösterge kutusundaki sıra serilerin sağ kenardaki sırasıyla aynı yapıldığında okuyucu tek bir eşlemeyle bütün listeyi çözer ve geçiş 6’ya iner. Kalan dördü, sağ kenarda aynı satıra düşen tek çiftten gelir: 12 satırın çözünürlüğünde güney ile ikinci tarife basamağı ayrılamıyor ve o iki seri tek tek eşleştirilmek zorunda.

Doğrudan etiketleme geçiş sayısını sıfıra indirir, çünkü ad serinin bittiği yere yazılır ve eşleme diye bir iş kalmaz. Sıralama ve doğrudan etiketleme de birer yedekli kodlama katmanıdır; farkları, ayırt edilebilirliği değil tanımayı taşımalarıdır. Üç düzen de aynı sekiz seriyi ayırt ediyor, ama okuyucudan istedikleri iş 16, 6 ve 0.

Tek Gösterimin Tavanı

# tavan.py — kac seri tek gosterimde tasinabilir.
AYRIK_BASAMAK = len(range(0, BASAMAK_SAYISI, AYIRMA))
TAVAN = AYRIK_BASAMAK * SEKIL_SAYISI
print(f"{BASAMAK_SAYISI} aydinlik basamagindan {AYIRMA} aralikla "
      f"{AYRIK_BASAMAK} tanesi ayirt edilebilir; {SEKIL_SAYISI} sekille "
      f"tavan {TAVAN} seri")
print("seri  ayirt edilebilir  parca")
for n in (8, 12, 16, 20, 24, 30, 40):
    kod = [(0, (i % AYRIK_BASAMAK) * AYIRMA,
            (i // AYRIK_BASAMAK) % SEKIL_SAYISI) for i in range(n)]
    e = ayirt_edilebilir(kod, sekilli)
    print(f"{n:4d} {e:17d} {max(1, -(-n // TAVAN)):6d}")
print(f"tek gosterimde en cok {TAVAN} seri ayirt edilebiliyor; uzerinde "
      f"gosterim parcalanmadan seri sayisi geri okunamiyor")

9 aydinlik basamagindan 2 aralikla 5 tanesi ayirt edilebilir; 4 sekille tavan 20 seri
seri  ayirt edilebilir  parca
   8                 8      1
  12                12      1
  16                16      1
  20                20      1
  24                20      2
  30                20      2
  40                20      2
tek gosterimde en cok 20 seri ayirt edilebiliyor; uzerinde gosterim parcalanmadan seri sayisi geri okunamiyor

Tavan iki sayıdan çıkar. Dokuz aydınlık basamağından iki basamaklık çözünürlükle beşi ayırt edilebilir; dört şekille çarpımı 20‘dir. Yirmiye kadar her seri ayırt ediliyor, 24 seride sayı 20’de kalıyor ve dördü okunamaz oluyor; 40 seride hâlâ 20.

Bu, gösterimin en sert sınırıdır ve tasarımla aşılamaz. Yirmiden çok seri taşınacaksa gösterim parçalanır: seriler tavanı geçmeyen gruplara bölünür ve her grup kendi gösteriminde çizilir. Bedeli, gruplar arası karşılaştırmanın artık aynı gösterimden okunamamasıdır. Konunun kuralı buradan çıkar — bir gösterim, ayırt edilebilir seri sayısı kadar seri taşır; fazlası çizilmiş ama raporlanmamış sayılır.

Özet

• Renk bir ad değil iki sayıdır ve modelde ton ailesi ile aydınlık basamağından oluşur; okuma çözünürlüğü iki basamaktır.
• İki ton ailesini dört aydınlık basamağıyla çaprazlayan varsayılan palet tam çözücüyle sekiz seriyi ayırt ediyor, ton ayrımını okumayan çözücüyle dördünü.
• Şekil kanalı sırayla dağıtıldığında sayı dörtte kalıyor, çünkü şekil dört seride başa dönüyor ve renk çakışmasıyla üst üste geliyor; çakışmaya göre dağıtıldığında iki şekille sekize çıkıyor.
• Ayırt edilebilirlik tanımayı vermez: aynı sekiz seri gösterge kutusuyla 16, sıralı göstergeyle 6, doğrudan etiketlemeyle 0 geçiş istiyor.
• Tek gösterimin tavanı ayırt edilebilir basamak sayısı ile şekil sayısının çarpımıdır; beş basamak ve dört şekille 20 seri, üzerinde gösterim parçalanmak zorundadır.

Sonraki Adım

Sekiz derste tek bir gösterim doğru kuruldu. Soru türüyle kanal eşleştirildi, dağılımın biçimi sayıya indi, taban çizgisi olmayan dilim ölçüldü, ilişkinin okunamaz olduğu nokta bulundu, zaman ekseninde eğim ve mevsim ayrıldı, alan kanalının ağırlığı sayıldı, dört çarpıtma tek tek basıldı ve son olarak kaç serinin ayırt edildiği ölçüldü. Hepsinde ölçü aynıydı: gösterim, okuyucunun geri okuyabildiği sayı kadar doğrudur.

Bir rapor ise tek gösterimden oluşmaz. Okuyucu bir bakışta birden çok sayıyla karşılaşır ve bunlar farklı kanallarla kodlanmış, farklı çözünürlüklerde durur. Sonraki konu ölçüyü buraya taşır: bir bakışta kaç ölçüt geri okunabiliyor, aynı ölçüt kaç yoldan ölçtüğünü oynatmadan oynatılabiliyor ve bir rapor ikinci kez üretildiğinde aynı sayıyı veriyor mu. Okuyucu artık bir sayıyı geri okuyan kişi değil, o sayıyla bir karar veren kişidir.