Ayrık aralık kümeleri üzerinde hesap yapan hesap makinesi

 (victorpoughon.github.io)
2 puan yazan GN⁺ 12 일 전 | 1 yorum | WhatsApp'ta paylaş
  • Girdi olarak ayrık aralıkların birleşimini alıp dört işlem, fonksiyon çağrıları ve üs alma dahil işlemleri gerçekleştiriyor; interval union arithmetic hesaplamalarını doğrudan tarayıcıda yapabiliyor
  • Sonuç aralıkları, girdi birleşimlerinden seçilen değerlerle aynı ifade reel sayılar üzerinde hesaplandığında ortaya çıkacak değeri mutlaka içeriyor; ayrıca 0 içeren bir aralığa bölme işlemi de ayrık birleşim biçiminde ele alınabiliyor
  • 1 / [-2, 1] için [-∞, -0.5] U [1, +∞], tan([pi/3, 2*pi/3]) için [-∞, -1.732] U [1.732, +∞] üretiyor; yani süreksiz aralık sonuçları ve sonsuz sınırlar gösterilebiliyor
  • [a, b], [a, b] U [c, d], iç içe aralık sözdizimi, lo, hi, hull, log10, cos, min, max gibi çeşitli gösterim ve fonksiyonları destekliyor
  • Tam hassasiyet modunda IEEE 754 çift duyarlıklı sayı temelli dışa doğru yuvarlama ile gerçek değeri saran aralıklar döndürüyor; 0.1 + 0.2 sonucunu [0.29999999999999993, 0.3000000000000001] olarak göstermesi öne çıkıyor

Genel bakış

  • Ayrık aralıkların birleşimi üzerinde hesap yapan bir hesap makinesi; sıradan reel sayılarla birlikte interval union arithmetic uygulamasını da destekliyor
    • [a, b] aralığı, a ile b arasındaki tüm sayıları ifade eder; [a, b] U [c, d] ise birbirinden ayrı aralıkların birleşimidir
    • Klasik aralık aritmetiğinin genişletilmiş bir biçimidir ve 0 içeren bir aralığa bölme işlemini de kapalılık özelliğini koruyarak hesaplayabilir
  • Kapsama özelliği garantisi
    • Girdi birleşimlerinin her birinden keyfi bir reel sayı seçilip aynı ifade reel sayılar üzerinde hesaplandığında, çıkan sonuç mutlaka çıktı birleşiminin içinde yer alır
  • Belirsizliği ifade edebilme
    • 50 * (10 + [-1, 1]) hesabı için [450, 550] örneği veriliyor
  • Karmaşık aralık ifadelerini hesaplama desteği
    • U operatörüyle ( [5, 10] U [15, 16] ) / [10, 100] gibi ifadeler girilebiliyor
    • Sonuç için [0.05, 1.6] örneği veriliyor
  • İşlem sonucu ayrık bir birleşim olabilir
    • 1 / [-2, 1] sonucu [-∞, -0.5] U [1, +∞]
    • tan([pi/3, 2*pi/3]) sonucu [-∞, -1.732] U [1.732, +∞]
  • Tam hassasiyet modunda, normal bir hesap makinesi gibi kullanılabilirken aynı zamanda kayan nokta hassasiyet sorunlarını da içeren gerçek değeri saran aralık sonuçları sunuyor
    • 0.1 + 0.2 sonucu için [0.29999999999999993, 0.3000000000000001] örneği veriliyor

Sözdizimi

  • Temel gösterim desteği
    • [a, b] aralık gösterimi destekleniyor
    • Örnek: [0.5, 0.6]
  • Birleşim gösterimi desteği
    • [a, b] U [c, d] biçimi destekleniyor
    • Örnek: [0, 1] U [5, 6]
  • Dört işlem ve üs alma desteği
    • Toplama A + B örneği ➤ [90, 100] + [-2, 2] sonucu [88, 102]
    • Çıkarma A - B örneği ➤ [14, 16] - [8, 12] sonucu [2, 8]
    • Çarpma A * B örneği ➤ [-5, 10] * [2, 4] sonucu [-20, 40]
    • Bölme A / B örneği ➤ [2, 4] / [-1, 2] sonucu [-∞, -2] U [1, +∞]
    • Üs alma A ^ B örneği ➤ [2, 3] ^ [-2, 3] sonucu [0.1111, 27]
  • Fonksiyon ve sabit desteği
    • function(...) biçiminde fonksiyon çağrıları destekleniyor
    • log10([1, 10000]) sonucu [0, 4]
    • Sabit adları girilebiliyor
    • pi sonucu [3.1415926535897927, 3.1415926535897936]
  • Sayı ve aralıkları birlikte kullanabilme
    • [1, 2] gibi köşeli parantez sözdizimiyle aralık girilebiliyor
    • 3.14 gibi bir sayı, genişliği 0 olan dar bir aralık [3.14, 3.14] olarak yorumlanıyor
    • Tam hassasiyet modunda bununla ilgili bazı ayrıntılı farklar bulunuyor
    • 1.55 + [-0.002, 0.002] sonucu [1.548, 1.552]
  • İç içe aralık sözdizimi desteği
    • [0, [0, 100]] girişi yapılabiliyor ve sonuç [0, 100] oluyor
    • Aralık sınırlarını tanımlayan içteki sayılar da aralık olarak yorumlanıyor
    • İç içe aralıklarda sınır konumuna gelen aralık için o aralığın üst sınırı alınıyor
    • Bu tasarım sayesinde sınırların kendisine de aritmetik uygulanabiliyor
    • [0, cos(2*pi)] sonucu [0, 1]

Desteklenen fonksiyonlar

  • Sabit desteği
    • inf, ∞, pi, e destekleniyor
    • [-inf, 0] * [-inf, 0] sonucu [0, +∞]
  • Sınır çıkarma fonksiyonları
    • lo(A) alt sınırı döndürür
      • lo([1, 2]) sonucu [1, 1]
    • hi(A) üst sınırı döndürür
      • hi([1, 2]) sonucu [2, 2]
  • Aralık dış zarfı hesaplama desteği
    • hull(A), birleşimi tek bir aralık içinde sarar
    • hull([1, 2] U [99, 100]) sonucu [1, 100]
  • Temel matematik fonksiyonları
    • abs(A) örneği abs([-10, 5]) sonucu [0, 10]
    • sqrt(A) örneği sqrt([9, 49]) sonucu [3, 7]
    • sqinv(A) örneği sqinv([4, 64]) sonucu [-8, -2] U [2, 8]
  • Logaritma ve üstel fonksiyonlar
    • log(A) örneği log([0, 1]) sonucu [-∞, 0]
    • log2(A) örneği log2([64, 1024]) sonucu [6, 10]
    • log10(A) örneği log10([0.0001, 1]) sonucu [-4, 0]
    • exp(A) örneği exp([-∞, 0] U [1, 2]) sonucu [0, 1] U [2.718, 7.389]
  • Trigonometrik ve ters trigonometrik fonksiyonlar
    • cos(A) örneği cos([pi/3, pi]) sonucu [-1, 0.5]
    • sin(A) örneği sin([pi/6, 5*pi/6]) sonucu [0.5, 1]
    • tan(A) örneği tan([pi/3, 2*pi/3]) sonucu [-∞, -1.732] U [1.732, +∞]
    • acos(A) örneği acos([-1/2, 1/2]) sonucu [1.047, 2.094]
    • asin(A) örneği asin([0, 1]) sonucu [0, 1.571]
    • atan(A) örneği atan([-10, 2]) sonucu [-1.471, 1.107]
  • Minimum ve maksimum fonksiyonları
    • min(A, B) örneği min([1, 2], [0, 6]) sonucu [0, 2]
    • max(A, B) örneği max([0, 10], [5, 6]) sonucu [5, 10]

Tam hassasiyet modu

  • IEEE 754 çift duyarlıklı kayan nokta üzerinde dışa doğru yuvarlama uygulanıyor
    • JavaScript number tipi kullanılıyor
    • Aynı ifade reel sayılarla ve sonsuz hassasiyetle hesaplandığında elde edilecek gerçek değerin sonuç aralığında mutlaka yer alması garanti ediliyor
  • 0.1 + 0.2 örneği
    • 0.3, çift duyarlıklı kayan nokta olarak tam biçimde temsil edilemiyor
    • interval arithmetic, 0.3 değerini içeren bir aralık hesabı yapıyor
  • Tam hassasiyet modu etkin olduğunda
    • Kullanıcının girdiği sayılar, yazılan ondalık gösterime en yakın IEEE 754 değeri içerecek ama iki sınırı da bu değere eşit olmayacak en küçük aralık olarak yorumlanıyor
    • Çıktı sayıları kullanılabilen tüm ondalık basamaklarla gösteriliyor
    • Number.toString() kullanılıyor
  • Tam hassasiyet modu kapalı olduğunda
    • Kullanıcının girdiği sayılar, yazılan ondalık gösterime en yakın IEEE 754 değeriyle iki sınırı da aynı olan dejenere aralık olarak yorumlanıyor
    • Çıktı sayıları en fazla 4 ondalık basamakla gösteriliyor
    • Number.toPrecision() kullanılıyor

Hatalar

  • Hesap makinesinde hâlâ hatalar bulunabileceği belirtiliyor
  • Sorun bildirimi için GitHub issue bağlantısı veriliyor

Açık kaynak

  • Hem Interval Calculator hem de hesap makinesi motoru not-so-float açık kaynak olarak sunuluyor
  • GitHub Sponsors destek bağlantısı da yer alıyor

Gelecek çalışmalar

  • Tam hassasiyet modu iki ayrı denetime bölünecek
    • Girdi yorumlama
    • Gösterim hassasiyeti
  • ans değişkeni eklenecek
    • Bir önceki girişin sonucunu saklayan değişken
  • Kesişim operatörü veya fonksiyonu eklenecek
  • U operatörünün önceliği daha sezgisel hale getirilecek
  • Boş birleşim girdisi desteklenecek

İlgili okumalar

1 yorum

 
GN⁺ 12 일 전
Hacker News yorumları
  • Yazarı olarak söyleyeyim, dışa doğru yuvarlama hassasiyet sorunlarını ele almak için interval arithmetic içinde en bilinen yaklaşım ama bence sadece bunun öne çıkması biraz üzücü. Araştırma makalelerinde geçen içerme özelliği her ölçekte çalışıyor; bu yüzden 50 * (10 + [-1, 1]) = [450, 550] gibi sonuçlar doğal biçimde ortaya çıkıyor. Bunun üstüne bir union katmanı ekleyince kare fonksiyonunun gerçek ters fonksiyonu gibi şeyleri de ele alabiliyorsunuz; sqrt yerine sqinv(64) denerseniz ne demek istediğimi anlarsınız. Aslında bu interval calculator, başka bir proje olan backwards updating spreadsheet için geliştirdiğim interval union arithmetic uygulamasını denemek amacıyla yapılmıştı. Uygulama not-so-float, ilgili proje ise bidicalc ve HN tartışması
    • Gerçekleştirdiğiniz arithmetic’in IEEE 1788 standardından nasıl farklı olduğunu merak ediyorum. Bağlantısını verdiğiniz iki makalenin o standartla nasıl bir ilişkisi olduğunu da öğrenmek isterim. Yazıda söz edilen sorunları çözmek için tamamen sıfırdan başlamak mı gerekti, yoksa IEEE standardının üzerine inşa etmek mümkün müydü, bunu da merak ediyorum
    • Gerçekten harika; biraz daha kurcalamayı düşünüyorum. Özellikle iki şeyi merak ediyorum. Birincisi, çok değerli fonksiyonları eklemek ne kadar zor olurdu? Mesela asin(1) için Mathematica olmadan [pi/2, pi/2] + n[2pi, 2pi] biçimindeki tüm kümeyi elde edebilmek çok güzel olurdu. İkincisi, kullanıcı giriş sayılarının nasıl yorumlandığına dair açıklama biraz kafa karıştırıcı geldi. Bana kalırsa girdiyi içeren en küçük intervalin çıktı sınır değerleri, girdi değerini çevreleyen en yakın iki IEEE 754 sayısı olmalı; ama şu anki ifadeyle IEEE754(input)+[-epsilon, epsilon] gibi okunuyor ve anlam farklılaşıyor
  • Bu gerçekten çok iyi. Matt Keeter’ın implicit surfaces çalışmaları ve interval math kullanarak yaptığı optimizasyonlar da ilginç olabilir. İlgili kısımları bu sunumda görebilirsiniz
  • Benim de interval arithmetic ile yapılmış bir grafik hesap makinem var; ilginizi çekebilir. Doğrudan deneyebileceğiniz formulagraph burada, nasıl çalıştığı ve ilgili kodun açıklaması da bu yazıda yer alıyor
    • İlk izlenimim bunun GrafEq’e benzediği yönünde oldu. Eski GrafEq aklıma geldi
  • Ben de bunu eğlenceli bulduğum için Raku ile basit bir Math::Interval kütüphanesi yazmıştım. raku-Math-Interval adlı bu deneme, Raku’nun yerleşik Junction ve Range sınıfları üzerine kuruluydu ve oldukça ilginç bir deneyimdi
  • Çok güzel, paylaştığınız için teşekkürler. Interval’lerde üst ve alt sınırın dahil olup olmadığını göstermek de güzel olur diye düşünüyorum. Benim alışık olduğum gösterimde değer dahil değilse dışa bakan köşeli parantezler kullanılıyor ve bu sonsuzluk için de her zaman böyle yazılıyor. Örneğin ]-∞, -1] U [0.5, +∞[ şeklinde; ortadaki hariç tutulan aralık da ]-1, 0.5[ olur. Anladığım kadarıyla min ve max de burada bu şekilde yorumlanıyor. Ayrıca sonuç alanındaki ifadeye tıklayınca ya da dokununca giriş kutusuna kopyalanması gibi bir UI fikri de kullanışlı olabilir
    • Bağlantı verilen makaleyi okuyunca burada yalnızca kapalı interval’lerin ele alındığını gördüm. Interval union, kapalı ve birbirinden ayrık interval kümeleri olarak tanımlanıyor; yalnızca uçlardaki extreme interval sınırları ±∞ olabiliyor
    • Bu tür bir gösterimi desteklemek mümkün olurdu ama kodu çok daha karmaşık hale getiriyor. Bu yüzden çok erken bir aşamada bunu desteklememeye karar verdim. Yine de hoş bir ek özellik olabilir
    • Ben de burada biraz kafam karıştı. Benim bildiğim standart gösterim yuvarlak parantezlerleydi; gerçi ASCII ortamında bu pek uygun olmayabilir diye düşündüm
  • Çok etkileyici. Tüm işlemleri tamamen anladığımı söyleyemem ama anladığım kadarıyla bile oldukça etkileyici. Derslerde interval’ler üzerindeki aritmetik ile daha erken tanışmış olmayı isterdim. Temel istatistikte güven aralıkları ya da ikinci dereceden denklemlerdeki ± gibi yerlerde benzer fikirler zaten çıkıyor; ama bunları tek bir veri gibi hesaplamaya devam etmek yerine her seferinde ±’nin iki değerini ayrı ayrı ele almak bana hep biraz yetersiz gelmişti. Elbette öğretmenin uygulamalara hızlıca dönmek istemesini anlıyorum, o yüzden derine inilmemesi anlaşılır. Yine de bu tür nesneler üzerinde de genel aritmetik yapılabildiğine dair küçük bir ipucu bile güzel olurdu. Burada gösterilen şey bunun çok ötesine geçiyor ama interval’leri kendi davranışları olan veri yapıları olarak görmenin anlamlı olduğuna dair bir doğrulama gibi geldi
  • Keşke zamanında Clojure’daki zaman interval’i kütüphanesi tick’i ilk kullanırken interval arithmetic’i biliyor olsaydım. Bu kütüphane Allen's Interval Algebra uygulamasını da içeriyor ve pratik hesaplamalarda yararlı olan ayrık interval kümeleri fikrini de benimsemiş durumda. Örneğin bir yıl içindeki izin aralıkları kümesini hesaplamak gibi HR işleri için çok uygun. Ben Allen’ın çalışmasını biliyordum ama bu tür kümelerin avantajlarını biraz tesadüfen keşfetmiş oldum. Kod burada: juxt/tick
  • Bu aracın işe yararlılığını görebiliyorum ama kişisel olarak olasılıksal bir hesap makinesinin daha faydalı olacağını düşünüyorum. Örneğin 1 / [-1, 2] gibi bir sonuç, hangi değerin ne kadar olası olduğuna dair hiçbir şey söylemiyor; hatta girdinin eşit dağıldığını varsaysak bile çıktının kesinlikle uniform distribution olmayacağı anlaşılıyor
  • Ben de yakın zamanda benzer bir şey uyguladım ama benim bakış açım küme üyeliği yönündeydi. Bu yüzden interval membership üzerinde tam bir Boolean analizi yapmak için tümleyen işlemi gerekliydi. Buradaki interval’lerin hepsi kapalı kümeler olduğundan tümleyen açık interval oluyor; fakat benim kullanım alanımda uç noktaların dahil olup olmaması önemli değildi, bu yüzden açık ve kapalı interval’leri özellikle ayırmadım. Hatta yaklaşık arithmetic’te bir kümenin açık mı kapalı mı olduğunun kendisi bile iyi tanımlı olmayabilir diye düşünüyorum
  • Mantığı union of intervals’e genişletmek etkileyici görünüyor ama karmaşıklığı merak ediyorum. Bir işlemin iki interval üretebildiği durumda, N işlem sonrasında bazı vakalarda üstel büyüme ortaya çıkacakmış gibi görünüyor. O zaman belli bir sayının üstünde yaklaşıklaştırma yapılmadıkça abstract interpretation gibi yaygın kullanımlarda pratik olmayabilir diye endişeleniyorum
    • Bu doğru bir nokta ve bu tür sorunlar abstract interpretation tarafında iyi biliniyor. Dediğiniz gibi genelde nesnenin boyutuna bir cap konuyor; sınır aşılınca interval’ler birleştiriliyor. Gerçi en azından abstract interpretation’da çoğu zaman interval’lerden daha ince taneli domain’ler de kullanılıyor diye düşünüyorum