Programlamanın arkasındaki teoriyle gittikçe daha fazla ilgilenmeye başladığımda, kendimi görünüşte basit şeylerden etkilenmiş ve şaşırmış buluyorum.

S : Bu nasıl çalışıyor?

C : Çünkü öyle!

Bu farkındalıktan nefret ediyorum! Bilgiyi seviyorum ve bunun da ötesinde öğrenmeyi seviyorum, ki bu da benim soruma yol açıyor (geniş olsa da).

Soru:

Temel matematik operatörleri programlama dilleriyle nasıl değerlendirilir?

Mevcut yöntemler nasıl geliştirildi?

Örnek

var = 5 * 5; 

Benim yorumum:

$num1 = 5; $num2 = 5; $num3 = 0;
while ($num2 > 0) {
    $num3 = $num3 + $num1;
    $num2 = $num2 - 1;
}
echo $num3;

Bu oldukça verimsiz görünüyor. Daha yüksek faktörlerle, bu yöntem çok yavaştır, standartta yerleşik olan standart ise anlamsızdır. Eklemeyi yinelemeden çarpımı nasıl simüle ederdiniz?

var = 5 / 5;

Bu nasıl yapılır? Kelimenin tam anlamıyla 5'i 5 eşit parçaya bölmenin bir yolunu düşünemiyorum.

var = 5 ^ 5; 

Ekleme yinelemelerinin yinelemesi? Benim yorumum:

$base = 5;
$mod = 5;
$num1 = $base;
while ($mod > 1) {

    $num2 = 5; $num3 = 0;
    while ($num2 > 0) {
        $num3 = $num3 + $num1;
        $num2 = $num2 - 1;
    }
    $num1 = $num3;
    $mod -=1;
}
echo $num3;

Yine, bu son derece verimsiz, ancak bunu yapmanın başka bir yolunu düşünemiyorum. Bu aynı soru otomatik olarak ele alınan tüm matematiksel ilişkili işlevleri de kapsar.

Bir bilgisayarın içindeki aritmetiğin nasıl çalıştığını gerçekten anlamak için, montaj dilinde programlanmış olmanız gerekir. Tercihen küçük kelime boyutuna sahip ve çarpma ve bölme talimatları olmadan biri. 6502 gibi bir şey.

6502'de, neredeyse tüm aritmetik, Akümülatör adlı bir kayıt defterinde gerçekleştirilir. (Bir kayıt işlemcinin içinde hızlı bir şekilde erişilebilen özel bir hafıza alanıdır.) Böylece iki sayı eklemek için ilk sayıyı Akümülatöre yükler ve ardından ikinci sayıyı eklersiniz.

Ama bu aşırı basitleştirici. 6502 8 bit işlemci olduğundan, yalnızca 0 - 255 arasındaki sayıları yönetebilir. Çoğu zaman daha büyük sayılarla çalışmak isteyebilirsiniz. Bunları parçalara, bir seferde 8 bit eklemelisiniz. İşlemcide, iki sayının eklenmesinin sonucu Akümülatörün üzerine çıktığında ayarlanan bir Taşıma bayrağı bulunur. İşlemci, bir ekleme yaparken, bir sayının en düşük sıradaki bayt ile başladığınızı varsayarak "1" i taşımak için kullanılabileceğini de ekler. 6502'deki bir multi-byte eklentisi şuna benzer:

1. Taşıma bayrağını temizle (CLC)
2. İlk sayının en düşük sipariş baytını yükle (LDA, yük aküsü)
3. İkinci sayının en düşük sıra baytını ekle (ADC, carry ile ekle)
4. Sonuçta en düşük sıralı bayt depolayın (STA, mağaza akümülatörü)
5. Ardışık yüksek-sıralı baytlarla 2-4 arasındaki adımları tekrarlayın
6. Sonunda, taşıma ayarlandıysa, taşan; bir hata mesajı oluşturmak gibi uygun işlemleri yapın (BCS / BCC, eğer taşınırsa set / sil)

Çıkarma, siz ilk önce siz belirlediğiniz, ADC yerine SBC komutunu kullandığınız ve benzer şekilde akışın olup olmadığı netleştiği için benzer .

Fakat bekle! Ya negatif sayılar? 6502 ile bunlar ikisi tamamlayıcı olarak adlandırılan bir formatta saklanır. 8 bitlik bir sayı varsayalım, -1 255 olarak saklanır, çünkü bir şeye 255 eklediğinizde, Akümülatörden (artı bir taşıma) bir tane daha az elde edersiniz. -2, 254 olarak depolanır ve -128'e kadar, 128 olarak depolanır. Bu nedenle, işaretli tamsayılar için, 0-255'lik bir bayt aralığının yarısı, pozitif sayılar için yarısı ve negatif sayılar için yarısı kullanılır. (Bu kural, negatif olup olmadığını görmek için sayının en yüksek bitini kontrol etmenizi sağlar.)

24 saatlik bir saat gibi düşünün: saate 23 eklemek, bir saat öncesindeki bir zamanla sonuçlanacaktır (ertesi gün). Öyleyse 23, saatin modüler eşittir -1.

1 bayttan fazla kullanıyorsanız negatifler için daha büyük sayılar kullanmanız gerekir. Örneğin, 16 bit tam sayılar 0-65536 aralığındadır. Bu yüzden 65535, -1'i temsil etmek için kullanılır, çünkü herhangi bir sayıya 65535 eklenmesi daha az sonuç verir (artı bir taşıma).

6502'de yalnızca dört aritmetik işlem vardır: toplama, çıkarma, ikiye çarpma (sola kaydırma) ve ikiye bölme (sağa kaydırma). Çarpma ve bölme, ikili işlem yaparken sadece bu işlemler kullanılarak yapılabilir. Örneğin, 5'i (ikili 101) ve 3'ü (ikili 11) çarpmayı düşünün. Ondalık uzun çarpmalarda olduğu gibi, çarpanın sağ hanesi ile başlayıp 101'i 1 ile çarparak, 101'i veririz. Sonra çarpımı sola kaydırır ve 1010'u 1 ile çarpıp 1010 veririz. Sonra bu sonuçları bir araya getiririz, 1111'i verir, veya 15. Hiç bir zaman sadece 1 veya 0 ile çarpmadığımız için, gerçekten çarpmadık; çarpanın her bir biti , bize (değiştirilmiş) çarpımın eklenip eklenmeyeceğini söyleyen bir bayrak görevi görür .

Bölünme, ikili durumlar haricindeki deneme bölenlerini kullanarak manuel uzun bölmeye benzerdir. Eğer bir sabit ile bölerseniz, bunu çıkarmaya benzer bir şekilde yapmak mümkündür: X ile bölmek yerine, istenen sonucu artı bir taşma üreten önceden hesaplanmış 1 / X yorumlaması ile çarpın. Bugün bile, bu bölünmeden daha hızlıdır.

Şimdi montajda kayan nokta matematiği yapmayı veya montajda kayan nokta sayılarını güzel çıktı formatlarına dönüştürmeyi deneyin. Ve unutmayın, saat 1979 ve saat hızı 1 MHz, bu yüzden mümkün olduğunca verimli bir şekilde yapmalısınız.

Bugün daha büyük sözcük boyutları ve daha fazla yazmaç dışında, işler hala oldukça fazla çalışıyor ve elbette matematiğin çoğu şimdi donanım tarafından yapılıyor. Ama yine de aynı temel şekilde yapılır. Bir çarpma için gereken vardiya ve ek sayısını toplarsanız, örneğin, 6809 gibi, böyle bir talimatı olan ilk işlemcilerde, bir donanım çarpma talimatı için gerekli olan döngü sayısı ile iyi bir ilişki kurar. microcode içinde de aynı şekilde elle yaparsınız. (Daha büyük bir transistör bütçeniz varsa , vardiyaları ve eklemeleri yapmanın daha hızlı yolları vardır , bu nedenle modern işlemciler bu işlemleri sırayla gerçekleştirmezler ve tek bir döngü kadar az bir sürede çarpımları gerçekleştirebilirler.)

Sonunda, donanımda temel aritmetik işlemler yapılır. Daha spesifik olarak, CPU'da (veya aslında, bunun bir alt bölümü)

Başka bir deyişle, elektronik devreler. Uygun bitleri girdi olarak ayarlayın, uygun bitleri çıktı olarak alacaksınız. Temel mantık kapılarının bir birleşimidir.

http://en.wikipedia.org/wiki/Adder_%28electronics%29

http://en.wikipedia.org/wiki/Binary_multiplier

Bunların hepsi Don Knuth'un Bilgisayar Programlama Sanatı Sanatında büyük bir sabrı var.

Toplama, çıkarma, çarpma ve bölme işlemlerine yönelik verimli algoritmaların tümü ayrıntılı olarak açıklanmaktadır.

Bu bölümü iyi anlatan şeyleri okuyabilirsiniz.

http://research.microsoft.com/pubs/151917/divmodnote.pdf

Elektronik devrelerde pikosaniye cinsinden yapılır. Ayrıntılar için Google 'donanım çarpanı' vb. Modern CPU'lar, onlarca yıllık sürekli iyileştirmenin son derece karmaşık bir sonucudur.

Btw, tekrarlanan ekleme ile çarpmadığınız için, neden bir bilgisayarın olacağını hayal edersiniz?

Bu, herhangi bir yöntemle tam bir cevap olmak anlamına gelmez, ancak işlerin nasıl uygulandığı konusunda size biraz fikir vermelidir. Muhtemelen bildiğiniz gibi sayılar ikili olarak gösterilmiştir. Örneğin, bir bilgisayar, 5 sayısını 00000101 olarak gösterebilir. Bir bilgisayarın yapabileceği çok temel bir işlem, 0'a 1010 verecek olan sola kaydırmaktır. Bu, onluk 10 olur. Basamakları bir kere sola kaydırdığımız her defasında sayıyı ikiye katlıyoruz. X sayısının olduğunu ve 17 ile çarpmak istediğimi söyleyin. X'i 4 kez sola kaydırıp sonra sonucu x ekleyebilirim (16x + x = 17x). Bu sayıyı 17 ile çarpmanın etkili bir yolu olacaktır. Bu, bir bilgisayarın yalnızca tekrarlanan eklemeleri kullanmadan büyük sayıları nasıl çarpabileceği hakkında bir fikir vermelidir.

Bölünme, toplama, çıkarma, sağa kaydırma, sola kaydırma, vb. Kombinasyonlarını kullanabilir. Rakamları üstlere çıkarmak için sayısız numara da vardır.

Çocukken, çok fazla eklemeyle zaman kaybetmeden bir kalem ve bir kağıtla nasıl çarpılacağını ve bölüneceğini öğrendim. Daha sonra kareköklerin de bu şekilde hesaplanabilir olduğunu öğrendim.

Üniversitede trigonometrik ve logaritmik işlemlerin bir düzine çarpma, bölme ve ekleme ile nasıl hesaplanacağını öğrendim. Buna Taylor serisi diyorlardı.

Ondan önce, babam bana bu karmaşık işlemlerin zaten yüzlerce değer için hesaplandığı ve tablolarda sunulduğu bir kitap verdi. İki hesaplanan değer arasında bir değerin sinüsünü istediğinizde hatayı tahmin etmek için bazı açıklamalar da yapıldı.

Tamsayılı birimler, kayan nokta birimleri, GPU ve DSP tüm bu eski teknikleri silikon üzerinde uygular.

Size dijital devrelerin dijital işleme sorunlarını çözmek için nasıl tasarlandıklarını, ortaya çıkardığınız sorunları kullanarak nasıl bir fikir vermeye çalışacağım: CPU'lar toplama ve çarpma işlemlerini nasıl uygularlar.

Birincisi, doğrudan soruyu önümüze çıkaralım: bir programlama dili çarpma ve toplama işlemlerini etkin bir şekilde nasıl değerlendirir? Cevap basit, onları çarparak derliyor ve talimat ekliyorlar. Örneğin, aşağıdaki kod:

a = 1 + 1;
b = a * 20;

sadece şöyle bir şey için derlenmiştir:

ADD 1 1  a
MUL a 20 b

(Not: Yukarıdaki derlemenin, basitlik uğruna varolmayan hayali bir CPU içindir).

Bu noktada yukarıdaki cevabın basitçe sorunu değiştirdiğini ve onu donanım sihiriyle çözdüğünü fark edersiniz. Takip eden soru açıkça bu donanım büyüsü nasıl çalışır?

İlk önce daha basit soruna bakalım: toplama.

İlk önce tanıdık bir problem çıkarıyor, 10 bazda düzenli olarak ekliyoruz:

 17
+28

İlk adım 7 ve 8 eklemek olacaktır. Fakat bu 15 ile sonuçlanır ve bu rakam tek bir rakamdan daha fazladır. Yani biz 1 taşıyan:

(1)
 17
+28
= 5

Şimdi birlikte 1, 1 ve 2 ekliyoruz:

 17
+28
=45

Bundan dolayı aşağıdaki kuralları alırız:

1. ekleme sonucu birden fazla basamak olduğunda, en az anlamlı basamağı tutarız ve en önemli basamağı ileriye taşırız

2. sütunumuza ilerletilen bir rakam varsa, onu eklediğimiz sayılarla birlikte ekleriz

Şimdi, yukarıdaki 2 - boolean cebirindeki yukarıdaki kuralları yorumlamanın zamanı geldi.

Böylece boolean cebirinde 0 ve 1'i bir arada = 1 eklemek. 0 ve 0 = 0 eklemek. Ve birden fazla rakam olan 1 ve 1 = 10 ekleyerek 1'i ileriye taşıyoruz.

Bundan bir doğruluk tablosu oluşturabiliriz:

a b  |  sum  carry
-------------------
0 0  |   0     0
0 1  |   1     0
1 0  |   1     0
1 1  |   0     1

Bundan iki devir / boole denklemi kurabiliriz - biri toplamın çıktısı, diğeri taşınan çıktısı için. En saf yol, tüm girdileri basitçe listelemektir. Herhangi bir gerçek tablo, ne kadar büyük ve karmaşık olursa olsun bu formda yeniden düzenlenebilir:

(AND inputs in first row) OR (AND of inputs in second row) OR ...

Bu temelde ürün formunun toplamıdır. Yalnızca 1 ile sonuçlanan ve 0'ları yok sayan çıktılara bakarız:

sum = (NOT a AND b) OR (a AND NOT b)

Bunu VEYA yazmayı kolaylaştıracak şekilde programlama dili sembolleriyle değiştirelim:

sum = (!a & b) | (a & !b)

Temel olarak, masayı şöyle dönüştürdük:

a b  |  sum  equation
-------------------
0 0  |   0   
0 1  |   1   (!a & b)
1 0  |   1   (a & !b)
1 1  |   0   

Bu doğrudan bir devre olarak uygulanabilir:

                _____
 a ------------|     |
    \          | AND |-.     ____
     \  ,-NOT--|_____|  \   |    |
      \/                 `--| OR |----- sum
      /\        _____    ,--|____|
     /  `-NOT--|     |  /
    /          | AND |-`
 b ------------|_____|

Gözlemci okuyucular bu noktada yukarıdaki mantığın aslında tek bir geçit olarak uygulanabileceğini fark edeceklerdir - uygun bir şekilde gerçek tablomuzun gerektirdiği davranışa sahip bir XOR geçidi:

                _____
 a ------------|     |
               | XOR |---- sum
 b ------------|_____|

Ancak, donanımınız size bir XOR kapısı sağlamazsa, yukarıdaki adımlar, onu AND, OR ve NOT geçitleri açısından nasıl tanımlayıp uyguladığınızla ilgilidir.

Lojik kapıları gerçek donanıma nasıl dönüştüreceğiniz, sahip olduğunuz donanıma bağlıdır. Mekanizma bir çeşit anahtarlama davranışı sağladığı sürece çeşitli fiziksel mekanizmalar kullanılarak uygulanabilirler. Mantık kapıları, su jetleri veya hava kabarcığından (akışkanlar) transistorlara (elektronik) düşen mermere kadar her şeyle gerçekleştirildi. Bu başlı başına büyük bir konudur, bu yüzden sadece onu anlatacağım ve mantık kapılarını fiziksel cihazlar olarak kullanmanın mümkün olduğunu söyleyeceğim.

Şimdi aynı şeyi taşıma sinyali için yapıyoruz. Taşıma sinyalinin doğru olduğu tek bir koşul olduğundan, denklem basitçe:

carry = a & b

Yani taşıma basittir:

                _____
 a ------------|     |
               | AND |---- carry
 b ------------|_____|

Onları bir araya getirerek yarı toplayıcı olarak bilinen şeyi elde ederiz:

                _____
 a ------;-----|     |
         |     | XOR |---- sum
 b --;---|-----|_____|
     |   |      _____
     |   '-----|     |
     |         | AND |---- carry
     '---------|_____|

Bu arada yukarıdaki devrenin denklemleri şöyle görünür:

sum = a ^ b
carry = a & b

Yarım toplayıcı bir şey eksik. İlk kuralı uyguladık - sonuç ileri sürmek yerine birden fazla basamaktaysa, ancak ikinci kuralı uygulayamadık - bir taşıma varsa, sayıları ile birlikte ekleyin.

Bu yüzden, tam bir toplayıcı, birden fazla basamaktan sayı ekleyebilen bir ekleme devresi uygulamak için bir doğruluk tablosu tanımlamamız gerekir:

a b c  |  sum  carry
---------------------
0 0 0  |   0     0
0 0 1  |   1     0
0 1 0  |   1     0
0 1 1  |   0     1
1 0 0  |   1     0
1 0 1  |   0     1
1 1 0  |   0     1
1 1 1  |   1     1

Toplam için denklem şimdi:

sum = (!a & !b & c) | (!a & b & !c) | (a & !b & !c) | (a & b & c)

Denklemi hesaba katmak ve basitleştirmek ve bunu bir devre olarak yorumlamak için aynı işlemi uygulayabiliriz, ancak yukarıda yaptığımız gibi bu cevabın aşırı uzun sürdüğünü düşünüyorum.

Artık dijital mantığın nasıl tasarlandığı hakkında bir fikir edinmelisiniz. Karnaugh haritaları (doğruluk tablolarını basitleştirmek için kullanılır) ve espresso gibi mantık derleyicileri (böylelikle el ile boole denklemlerini hesaba katmak zorunda kalmazsınız) gibi bahsetmediğim başka püf noktaları da var, fakat temel olan benim yukarıda özetlenen:

1. Tek bit (rakam) düzeyinde çalışana kadar sorunu çözün.

2. Bir doğruluk tablosu kullanarak istediğiniz çıktıları tanımlayın.

3. Masayı bir boole denklemine dönüştürün ve denklemi basitleştirin.

4. Denklemi mantık kapıları olarak yorumlar.

5. Mantık geçitlerini uygulayarak mantık devrenizi gerçek donanım devrelerine dönüştürün.

Temel (veya daha doğrusu, düşük seviyeli) problemlerin gerçekte çözülmesi - işte bu kadar çok doğruluk tablosu. Asıl yaratıcı çalışma, MP3 kod çözme gibi karmaşık bir görevin bit seviyesine parçalanmasıdır, böylece üzerinde gerçeği tablolarıyla çalışabilirsiniz.

Üzgünüm, çarpmanın nasıl uygulanacağını açıklayacak vaktim yok. Çarpma işleminin ne kadar süreceği, ikilik olarak yorumlanması ve gerçeği tablolarına ayırmaya çalışarak kuralları çözerek bir çatlak çekmeyi deneyebilirsiniz. Ya da Wikipedia’yı okuyabilirsiniz: http://en.wikipedia.org/wiki/Binary_multiplier

Temel aritmetik talimatlar, son derece verimli montaj talimatlarıyla gerçekleştirilir.

Daha karmaşık (veya soyut) talimatlar ya döngü mekanizmalarıyla montajda yapılır ya da std kütüphanelerinde kullanılır.

Üniversitede matematik okurken Lambda Calculus ve Big-O notasyonu gibi şeyleri çalışmaya başlayacaksınız. Bunların hepsi ve daha fazlası, programcılar tarafından etkin algoritmalar değerlendirmek ve oluşturmak için kullanılır. Her neyse, temel malzeme genellikle montaj veya c işaretçilerle olduğu gibi düşük seviyede gerçekleştirilir.

Bu konunun büyük bir giriş Charles Petzold tarafından "Kod" dir.

Freshman / Sophomore EE öğrencileri için hala oldukça standart olduğunu düşündüğüm Dijital Mantığın Temelleri ... gibi bir kitap edinin ve üzerinde çalışın (ed: küçük bir servete mal olur; o). Bu sizi adders ve çarpanlara götürecek ve donanımın ne yaptığının arkasındaki prensiplerin bazılarını anlamaya başlamak için yeterli bir arka plan sağlayacaktır.

Cevabınız, kısa vadede "çünkü bu karmaşık davranışı uyandırmak için" basitçe "basit" mantıklı "mantık" u uyandırdığı için "olacaktır.

Programların nasıl derlenip çalıştırıldığının tüm prensiplerini anlamaya çalışmak istiyorsanız, bununla birlikte gidin, böylece sonuçta her şeyin ortada nasıl birleştiğini görebilirsiniz.

Burada çok iyi cevaplar var. Siz de doğru fikirle başladınız: çarpma gibi karmaşık işlemler daha basit işlemlerden oluşur. Tahmin ettiğiniz gibi, bir çarpma talimatı olmadan çarpma talimatı kullanmaktan çok daha hızlı yöntemler vardır. Herhangi bir çarpma, küçük çarpmaların toplamı olarak veya vardiya ve toplamaların bir kombinasyonu olarak uygulanabilir. Örnekler:

a = 5 + 5 + 5 + 5 + 5;           // 5*5, but takes 5 operations
b = (5 << 2) + 5;                // 5*5 in only 2 operations
c = (41 << 4) + (41 << 2) + 41   // 41*21 in 4 operations

Bölünme aynı şekilde daha küçük işlemlere ayrılabilir. XOR (^), şu ana kadar baktığım her işlemcide yerleşik bir talimattır, ancak yine de AND, OR ve NOT'un bir kombinasyonu olarak uygulanabilir.

Bununla birlikte, belirli yanıtların, bir işlemcinin sağladığı talimat türleri ve bu talimatların daha karmaşık işlemlerde nasıl birleştirilebileceği konusundaki genel fikir fikrinden daha az tatmin edici olacağını hissediyorum. Bu tür bir merak için sağlıklı bir meclis dili dozundan daha iyi bir şey yoktur. İşte MIPS assembly diline çok yaklaşılabilir bir giriş.

Modern bir işlemcinin iki 64 bit tamsayının çarpımını nasıl uygulayabileceği:

Uzun el çarpma işleminin nasıl yapıldığını biliyorsunuz. İki 10 basamaklı sayıları çarpmak için, diğer sayının 10 hanesinin her biriyle bir 10 basamaklı sayıyı çarpın, 11 basamak sonucunu bir diğerinin altına yazın ve kaydırın, ardından tüm sayıları ekleyin.

Modern bir işlemci bunu 64 - 64 bit ile yapıyor. Ancak, iki tek bitlik sayının çarpımı çok basittir: 1 x 1 = 1, diğer tüm ürünler sıfırdır. Bu mantıklı ve uygulanmaktadır. Ve sonucun iki basamağın olabileceği ondalık ürünün aksine, tek bitlik sayılardan oluşan ikili bir ürün her zaman bir bit.

Şimdi eklenmesi gereken 64 bitlik 64 bitiniz var. Ancak 64 bitlik sayının 64 ilavesi slooooooow'dur. Böylece işlemci 3/2 bir toplayıcı veya 7/3 bir toplayıcı kullanır: 3 tek bitlik bir sayı eklerseniz, sonuç iki bite uyan 0, 1, 2 veya 3 olabilir. 7 tek bitlik sayı eklerseniz, sonuç 0 ile 7 arasında bir sayıdır ve bu değer 3 bit ile gösterilebilir. IBM, sadece 18 ilkel devreli (PowerPC dokümantasyonu) 7/3 toplayıcı yapabildiklerini iddia ediyor, Intel ve ARM de bunu yapabilir.

4096 bitiniz var, bunları aynı bit pozisyonlarında yaklaşık 600 bitlik 7 bit grubu halinde gruplandırın ve sonucu 4096 bitten 2,000'in altına düşürmek için yaklaşık 600 7/3 ekleyici kullanın. Sonra sıradan bir tam toplayıcıya beslenebilecek bit çiftleriyle sonuçlanana kadar tekrar tekrar yapın.