Izgara çarpması

Çarpmada **ızgara yöntemi** (**kutu yöntemi** veya **matris yöntemi** olarak da bilinir), ondan büyük sayıların yer aldığı çok basamaklı çarpma hesaplamalarına yönelik, giriş düzeyinde bir yaklaşımdır.

Geleneksel uzun çarpma ile karşılaştırıldığında, ızgara yöntemi çarpma ve toplamayı açıkça iki adıma ayırması ve basamak değerine daha az bağımlı olmasıyla ayrılır.

Geleneksel yönteme göre daha az *verimli* olsa da, ızgara çarpması daha *güvenilir* kabul edilir; çünkü çocukların hata yapma olasılığı daha düşüktür. Çoğu öğrenci, ızgara yönteminde rahat ettikten sonra geleneksel yöntemi öğrenmeye geçer; ancak ızgara yöntemi bilgisi, karışıklık durumunda yararlı bir "yedek" olarak kalır. Ayrıca, günümüzde çok çarpma yapan birinin genellikle cep hesap makinesi kullanacağı düşünüldüğünden, salt verimlilik daha az önemlidir; benzer biçimde, bunun çocukların çarpma algoritmasını daha seyrek kullanacağı anlamına gelmesi nedeniyle, daha açık (dolayısıyla daha akılda kalıcı) bir yönteme aşina olmaları yararlı görülür.

Izgara yönteminin kullanımı, 1990'larda "sayısal beceri saati" (*numeracy hour*) ile birlikte yürürlüğe giren bir 'National Numeracy Strategy' (*Ulusal Sayısal Beceriler Stratejisi*) vesilesi ile, İngiltere ve Galler'de ilkokullardaki Matematik eğitiminde standart hâle gelmiştir. Yöntem, başka yerlerdeki çeşitli öğretim programlarında da yer alır. Açık bir ızgara düzeni kullanılmasa da, temelde aynı hesaplama yaklaşımı **kısmi çarpımlar algoritması** veya **kısmi çarpımlar yöntemi** adıyla da bilinir.

## Hesaplamalar

### Giriş motivasyonu

Izgara yöntemi, düzenli bir dizideki noktaların sayısının, örneğin bir çikolata kalıbındaki karelerin sayısının nasıl toplanacağı düşünülerek tanıtılabilir. Hesaplamanın boyutu büyüdükçe, onar onar saymaya başlamak ve hesaplamayı çok sayıda nokta çizmek yerine bölünebilen bir kutu olarak temsil etmek daha kolay hale gelir.

En basit düzeyde, öğrencilerden yöntemi 3 × 17 gibi bir hesaplamaya uygulamaları istenebilir. 17'yi (10 + 7) olarak parçalayarak ("ayırarak"), bu alışılmadık çarpma işlemi iki basit çarpma işleminin toplamı olarak hesaplanabilir:

:

böylece 3 × 17 = 30 + 21 = 51.

Bu, çarpma yöntemine adını veren "ızgara" veya "kutu" yapısıdır.

34 × 13 gibi biraz daha büyük bir çarpma işlemiyle karşılaşıldığında, öğrencilerin başlangıçta bunu da onluklara bölmeleri teşvik edilebilir. Yani, 34'ü 10 + 10 + 10 + 4 ve 13'ü 10 + 3 olarak genişleterek, 34 × 13 çarpımı şu şekilde gösterilebilir:

:

Her bir satırın içeriği toplandığında, hesaplamanın nihai sonucunun (100 + 100 + 100 + 40) + (30 + 30 + 30 + 12) = 340 + 102 = 442 olduğu görülür.

### Standart bloklar

Öğrenciler tüm çarpımı ayrı kutulardan gelen katkılara bölme fikrine alıştıktan sonra, onlukları bir araya getirmek doğal bir adımdır, böylece 34 × 13 hesaplaması şu hale gelir:

:
bu da şu toplama işlemini verir
::

böylece 34 × 13 = 442 olur.

Bu, ızgara hesaplamasının en olağan biçimidir. Izgara yönteminin öğretilmesinin olağan olduğu Birleşik Krallık gibi ülkelerde, öğrenciler yöntem tamamen rahat ve tanıdık gelene kadar yukarıdaki gibi hesaplamaları düzenli olarak yaparak önemli bir zaman harcayabilirler.

### Daha büyük sayılar
Izgara yöntemi, daha büyük sayıları içeren hesaplamalara doğrudan genişletilebilir. Örneğin, 345 × 28'i hesaplamak için öğrenci altı kolay çarpma işlemiyle ızgarayı oluşturabilir:

:

ve cevabı 6900 + 2760 = 9660 olarak bulur.

Ancak bu aşamada (en azından standart mevcut Birleşik Krallık öğretim uygulamasında), öğrencilerin bir ızgara çizmek zorunda kalmadan geleneksel uzun çarpma formunu kullanarak bu tür bir hesaplamayı yapmaları teşvik edilmeye başlanabilir. Geleneksel uzun çarpma, sayılardan yalnızca birinin ayrı ayrı çarpılmak üzere onluk ve birlik parçalara bölündüğü bir ızgara çarpımı ile ilişkilendirilebilir:
:

Geleneksel yöntem nihayetinde daha hızlı ve çok daha derli topludur; ancak öğrencilerin ilk başta zorlanabilecekleri, önemli ölçüde daha zor iki çarpma işlemi gerektirir. Izgara yöntemiyle karşılaştırıldığında, geleneksel uzun çarpma daha soyut ve daha az açık olabilir, bu nedenle bazı öğrenciler her aşamada ne yapılması gerektiğini ve nedenini hatırlamakta zorlanabilir. Bu nedenle öğrencilerin, bir kontrol ve yedek yöntem olarak, daha verimli olan geleneksel uzun çarpma yönteminin yanı sıra daha basit olan ızgara yöntemini de kullanmaları bir süre daha teşvik edilebilir.

## Diğer uygulamalar

### Kesirler

Normalde kesirleri çarpma için standart bir yöntem olarak öğretilmese de, ızgara yöntemi, çarpımı parçalayarak bulmanın daha kolay olduğu basit durumlara kolayca uygulanabilir. Örneğin, 2 × 1 hesaplaması, ızgara yöntemi kullanılarak şu şekilde düzenlenebilir:

:

böylece sonuç çarpımı 2 +  + 1 +  = 3 olarak bulunur.

### Cebir

Izgara yöntemi, temel cebirde (genellikle ortaokula kadar karşılaşılmasa da) standart bir konu olan (*a* + 3)(*b* + 2) gibi binomların (*ikiterimli*) çarpımının açılımını göstermek için de kullanılabilir:

:

Böylece (*a* + 3)(*b* + 2) = *ab* + 3*b* + 2*a* + 6 olur.

### Bilişim

32-bit CPU'larda genellikle iki 64-bit tam sayıyı çarpacak bir komut bulunmaz. Ancak çoğu, iki 32-bit tam sayı arasındaki çarpımdan tam 64-bit sonucu almaya, yani "uzun çarpma" işlemine izin verir. Bu genellikle (80386 ile tanıtılan `mul r/m32` ve ARMv4t komut setine eklenen `umull` gibi) iki ayrı yazmaçta (*register*) çıktı üretilmesini içerir. Bu komutları destekleyen platformlarda, ızgara yönteminin biraz değiştirilmiş bir sürümü kullanılır. 10'un katlarını kullanmak yerine, 232'nin katları, yani `0x100000000` kullanılır. 64-bitlik bir tam sayı, ortadan bölünerek bu tür iki sayıya ayrılabilir. Ayrıca, iki 64-bit tam sayının çarpımı teknik olarak 128-bitlik bir sonuç üretir. Eğer sadece (burada olduğu gibi) alt 64-bit gerekliyse, bir 32-bit çarpma işleminden tasarruf edilebilir. Bunun nedeni ızgara yönteminin (Nb + a)(Nd+c) = ac + N(bc+ad) + N^2(bd) gerçeğine dayanmasıdır. *N* = 232 olduğundan, *N*2 = 264 olur, bu nedenle bd'deki herhangi bir sonuç 64-bit aralığının dışına kaydırılır. Bu aynı zamanda, *bc* ve *ad*'nin yüksek 32 bitleri de aralık dışına kaydırılacağından, yalnızca bir 32-bit "uzun çarpma" gerektiği anlamına gelir.

C dilindeki rutin şöyle olacaktır:

```c
#include <stdint.h>

uint64_t multiply(uint64_t ab, uint64_t cd)
{
    /* Bu kaydırmalar ve maskelemeler genellikle örtüktür, çünkü 64-bit tam sayılar
     * sıklıkla 2 adet 32-bit yazmaç (register) olarak aktarılır.
     */
    uint32_t b = ab >> 32, a = ab & 0xFFFFFFFF;
    uint32_t d = cd >> 32, c = cd & 0xFFFFFFFF;
    /* taşmalı çarpma */
    uint64_t ac = (uint64_t)a * (uint64_t)c;
    uint32_t high = ac >> 32;
    /* taşma */
    uint32_t low = ac & 0xFFFFFFFF;
    /* 32-bit çarp ve yüksek bitlere ekle */
    high += (a * d);
    /* ad'yi ekle */
    high += (b * c);
    /* bc'yi ekle */
    /* 0x100000000 ile çarp (sola kaydırma ile) ve ikili veya (binary or) ile düşük bitlere ekle.
     */
    return ((uint64_t)high << 32) | low;
}
```

ARM assembly dilindeki rutin şöyle olacaktır:

```asm
multiply:
        ; a = r0
        ; b = r1
        ; c = r2
        ; d = r3
        push    {r4, lr}        ; r4 ve lr'yi yığına (stack) yedekle
        umull   r12, lr, r2, r0 ; r2 ve r0'ı çarp, sonucu r12'de ve taşmayı lr'de sakla
        mla     r4, r2, r1, lr  ; r2 ve r1'i çarp, lr'yi ekle ve r4'te sakla
        mla     r1, r3, r0, r4  ; r3 ve r0'ı çarp, r4'ü ekle ve r1'de sakla
                                ;
                                ; Değer örtük olarak sola kaydırılır çünkü
                                ; 64-bit tam sayının yüksek bitleri r1'de döndürülür.
        mov     r0, r12         ; Dönüş değerinin düşük bitlerini r12 (ac) olarak ayarla
        pop     {r4, lr}        ; r4 ve lr'yi yığından geri yükle
        bx      lr              ; r0 ve r1'de sırasıyla düşük ve yüksek bitleri döndür
```


## Matematik
Matematiksel olarak, bir çarpma işlemini bu şekilde parçalayabilme yeteneği, cebirde *a*(*b*+*c*) = *ab* + *ac* özelliği olarak ifade edilebilen dağılma özelliği olarak bilinir. Izgara yöntemi, çarpımı genişletmek için dağılma özelliğini iki kez kullanır; bir kez yatay çarpan için ve bir kez dikey çarpan için.

Tarihsel olarak ızgara hesaplaması (biraz değiştirilmiş haliyle), ortaçağ Arap ve Hint matematiğinde geliştirilen standart çok basamaklı çarpma yöntemi olan kafes çarpımı (*lattice multiplication*) adlı yöntemin temeliydi. Kafes çarpımı, on üçüncü yüzyılın başında Fibonacci tarafından Arap rakamlarıyla birlikte Avrupa'ya tanıtıldı; ancak rakamlar gibi, onlarla hesaplama yapma yollarının benimsenmesi de başlangıçta yavaş oldu. Napier'in kemikleri, 1617'de İskoç John Napier tarafından kafes yöntemi hesaplamalarına yardımcı olmak için tanıtılan bir hesaplama yardımcısıydı.

## Ayrıca bakınız
* Çarpma algoritmaları
* Çarpım tablosu

## Kaynakça
* Rob Eastaway ve Mike Askew, *Maths for Mums and Dads*, Square Peg, 2010. . s.&nbsp;140–153.

## Dış bağlantılar
* Uzun çarpma − Kutu yöntemi, *Maths online*.
* Uzun çarpma ve bölme, BBC GCSE Bitesize