Ada Programlama Dili Temelleri

Bölüm 3

Standard Pakette Tanımlanan Öntanımlı Veri Tipleri

Bölüm 3 Sayfa 4

3.2.3.2 - Integer Veri Tipi İçin Tanımlı İşlemciler

Ada programlam dilininde, Integer veri tip gibi Standard pakette tanımlanmış bir öntanımlı veri tipi olsun, ister kullanıcılar tarafından yaratılmış özgün bir veri tipi olsun her veri tipine uygulanabilecek tüm işlemciler, bu işlemcilerin işlenenleri ve döndüreceği değerler kesin olarak tanımlanmış olmalıdır. Bu konuda, Standard pakette Integer veri tipi gibi, tüm öntanımlı veri tiplerinin işlemcileri tüm ayrıntıları ile tanımlanmıştır. Kullanıcılar, kendi veri tiplerini daima Standard pakette tanımlanmış veri tiplerinin alt tipleri olarak yaratabilirler. Kullanıcı tipi veriler, kendi üst veri sınıfının işlemcilerini kalıtım yolu ile elde ederler. Kullanıcı tanımlı verilerde, kullanıcılar isterlerse kendi veri tiplerinin işlemcilerini yeniden tanımlayarak (kalıtımla gelen tanım üzerine bindirirerek) yeniden tanımlayabilirler. Fakat bu işlem çok alt düzey bir işlem olduğundan, sıradan bir kullanıcının kendi tipi için işlemcilerini bindirmesine çok az rastlanır. Genellikle tüm alt veri tipleri, kalıtım yolu ile elde ettikleri üst veri tipinin işlemcilerini aynen muhafaza ederler.

Ada programlama dilinde, beş tane tamsayı tipinin öntanımı yapılmıştır. Bunlardan ilki ve tamsayı tiplerinin ilk atası (ultimate ancestor) root_integer veri tipidr. Bu tip kuramsal bir tiptir ve Standart pakette sadece adı açıklanmıştır. İkinci üst tamsayı sınıfı, universal_integer tamsayı sınıfıdır ve bu da kısmen kuramsal bir veri tipi olduğundan Standart pakette sadece ismi belirtilmiştir. Standart pakette kapsamı ve işlemcileri tanımlanan ilk tamsayı veri tipi Integer veri aslında, ilk tanımlı tip olduğundan, tüm tamsayı alt tipleri Integer veri tipinin alt tipleri sayılır. Çünkü diğer iki üst atanın spesifikasyonları açıklanmamıştır fakat, Integer veri tipinin üst ataları olduğundan ve Integer veri tipi için geçerli olan tüm işlemcilere bu iki üst atanın da uygulanabileceği bildirildiğinden aynı işlemcileri paylaştıkları açıklanmış olmaktadır. Aslında, root_integer kök sınıfının yaratılması, universal_integer tamsayı sınıfının işlemcilerinin her tarafındaki veri tipinin universal_integer olması gerekliğinden kaynaklanmış bir kuramsal belirsizilik kuşkusudur.

Stanadrt pakette işlemcileri ve kapsamı tam olarak tanımlanmış olan Integer tipinin tüm operasyonel tamsayı alt tiplerin de atası olduğu ve işlemcilerini kalıtım yolu ile alt öntanımlı (Natural ve Positive veri tipleri) ile kullanıcı tanımlı tamsayı alt tiplerine aktardığı düşünülürse, Integer veri tipinin işlemcilerinin çalışma yönteminin çok iyi özümsenmesi gerekir. Bu konuda ve her konuda en iyi öğrenme yöntemi, spesifikasyondaki tanımların iyi incelenmesi ve üzerinde uygulamalar yaparak çalışma yöntemininin olabildiğince iyi anlaşılmasıdır. Bunuın için, çalışmalar sırasında daima gözönünde olması için, Ada 2012 spesifikasyonu ile birlikte gelen Standard paketin görünebilir kısmında tanımlanan tamsayı veri tiplerinin (Integer, Natural ve Positive veri tipleri) tanımı yeniden verilmiştir.

   -- The integer type root_integer and the
   -- corresponding universal type universal_integer are predefined.
   type Integer is range implementation-defined;
   subtype Natural  is  Integer range 0 .. Integer'Last;
   subtype Positive is Integer range 1 .. Integer'Last;
   -- The predefined operators for type Integer  are as follows:
   -- function "="  (Left, Right : Integer'Base) return Boolean;
   -- function "/=" (Left, Right :  Integer'Base) return Boolean;
   -- function "<"  (Left, Right : Integer'Base)  return Boolean;
   -- function "<=" (Left, Right : Integer'Base)  return Boolean;
   -- function ">"  (Left, Right : Integer'Base)  return Boolean;
   -- function ">=" (Left, Right : Integer'Base)  return Boolean;
   -- function "+"   (Right : Integer'Base) return Integer'Base;
   -- function "-"   (Right : Integer'Base)  return Integer'Base;
   -- function "abs" (Right : Integer'Base)  return Integer'Base;
   -- function "+"   (Left, Right : Integer'Base) return Integer'Base;
   -- function "-"   (Left, Right :  Integer'Base) return Integer'Base;
   -- function "*"   (Left, Right : Integer'Base) return Integer'Base;
   -- function "/"   (Left, Right : Integer'Base)  return Integer'Base;
   -- function "rem" (Left, Right : Integer'Base) return Integer'Base;
   -- function "mod" (Left, Right : Integer'Base)  return Integer'Base;
   -- function  "**"  (Left : Integer'Base; Right : Natural)
   --                   return Integer'Base;
   -- The specification of  each operator for the type
   -- root_integer, or for any additional  predefined integer
   -- type, is obtained by replacing Integer  by the name of the type
   -- in the specification of the corresponding  operator of the type
   -- Integer. The right operand of the  exponentiation operator
   -- remains as subtype Natural.

Standart paketteki tanımından, öntanımlı Integer tamsayı veri tipinin aritmetik ve ilişkisel işlemcilerinin tanımlanmış olduğu görülmektedir. Aritmetik işlemciler,

olarak belirtilmiştir.

Integer veri tipinin ilişkisel işlemcileri, iki işlenenli (binary) işlemcilerdir.

Mantıksal (lojik) işlemciler, tüm veri tiplerinde olduğu gibi, Integer veri tipinde değerlerden oluşan ve sonucu Boolean olan ilişkisel ifadelerin mantıksal işlemcilerin işlenenleri olarak kullanılması ile uygulanır. Mantıksal işlemciler Boolean veri tipi ile birlikte incelenmişlerdir.

Standart pakette, Integer veri tipi işlemcilerinin işlenenlerin ve döndürülen değerlerin bir kısmının veri tipleri, Integer'Base olarak belirtilmiştir. Bilindiği gibi, öntanımlı Integer veri tipi, kapsam sınırı olan bir alt tamsayı tipidir. Integer veri tipinin işlemcilerini kalıtımsal olarak elde edecek kullanıcı tanımlı tamsayı alt tiplerinin kapsam alanları çok daha geniş olabilir. Bu nedenle, öntanımlı Integer veri tipinin işlemcileri, kapsam sınırı olmayan genel bir tamsayı sınıfı için tanımlanmışlardır. Eğer işlenen olarak aşağıdaki gibi,

34 + 48

şeklinde tamsayı literalleri kullanılmış ise, bu literaller zaten kapsam alanı sistemin destekleyebileyeceği kadar geniş olan universal_integer veri tipindedir.

Aritmetik İşlemciler

Tekli Aritmetik İşlemciler

Tekli Artı

Tekli artı işlemcisi,

+ (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması işlenende bir değişikliğe neden olmaz. Bundan dolayı programlarda uygulanmaz.

Tekli Eksi

Tekli eksi işlemcisi,

- (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile işlenenin işareti değişir.

Mutlak Değer (abs)

Mutlak Değer (abs) işlemcisi,

abs (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile işlenenin işareti gözönüne alınmaz ve mutlak değeri kullanılır. Tekli aritmetik işlemcilerin uygulanması ile ilgili bir prosedür aşağıda görülmektedir.

 

with Ada.Text_IO;

with Ada.Integer_Text_IO;

procedure b3_2_3_2_uyg_1 is

Tamsayı_Değeri : Integer ;

begin

   Tamsayı_Değeri := -16;
   
   Ada.Text_IO.Put(Item =>"Tamsayı Verisi : ");
   
   Ada.Integer_Text_IO.Put(Item =>Tamsayı_Değeri, width => 10);
   
   Ada.Text_IO.New_Line;
   
   Ada.Text_IO.Put(Item =>"-Tamsayı Verisi : ");
   
   Ada.Integer_Text_IO.Put(Item =>-Tamsayı_Değeri, width => 9);
   
   Ada.Text_IO.New_Line;
   
   Ada.Text_IO.Put(Item =>"abs Tamsayı Verisi : ");
   
   Ada.Integer_Text_IO.Put(Item =>abs Tamsayı_Değeri, width => 4);
   
   
end b3_2_3_2_uyg_1;
		
Bu programın sonucu, 

Tamsayı Verisi :        -16
-Tamsayı Verisi :        16
abs Tamsayı Verisi :   16

olmaktadır.
			

Yukarıdaki prosedürde, dikkat edilmesi gereken nokta, Tamsayı verisinin değerinin program sonuna kadar değişmediğidir. Tamsayı verisine program başlangıcında bir başlangıç değeri verilmiş ve program sonuna kadar bu değişkene yeni bir değer atanmamıştır. Programda değişen, sadece çeşitli ifadelerin değerleridir.

Çiftli Aritmetik İşlemciler

Çiftli Artı

Çiftli artı işlemcisi,

(sol işlenen : Integer'Base) + (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile sol işlenenin değerine sağ işlenenin değeri eklenerek sonuç döndürülür.

Çiftli Eksi

Çiftli eksi işlemcisi,

(sol işlenen : Integer'Base) - (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile sol işlenenin değerinden sağ işlenenin değeri çıkarılarak sonuç döndürülür.

Çarpım İşlemcisi

Çarpım işlemcisi,

(sol işlenen : Integer'Base) * (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile sol işlenenin değeri ile sağ işlenenin değeri çarpılarak sonuç döndürülür.

Bölüm İşlemcisi

Bölüm işlemcisi,

(sol işlenen : Integer'Base) / (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile sol işlenenin değeri sağ işlenenin değerine bölünür. Sonuç tamsayı değilse, ondalıklı kısım (kalan) kesilerek (truncation) tamsayı kısmı döndürülür.

Çiftli aritmetik işlemcilerin uygulanması aynen matematikte olduğu gibidir. Ada programlama dilinde, ifadelerin tip tekdüzeliğinin sakınımı koşulu bulunmaktadır. Bu nedenle, tamsayı veri tiplerinin nesnelerinin matematiksel ifadelerde kullanımı uygun değildir. Tamsayı nesneleri sayma, toplama dizi ve döngü indisleri oluşturma gibi tamsayı nesneleri gerektiren işlemlerde kullanılır. Dört işlemde çiftli işlemcilerin uygulanmalarını konu alan bir prosedür aşağıda görülmektedir.

 

with Ada.Text_IO;

with Ada.Integer_Text_IO;

procedure b3_2_3_2_uyg_2 is

Tamsayı_Değeri_1 , Tamsayı_Değeri_2 : Integer;

begin

   Tamsayı_Değeri_1 := 23;
   
   Tamsayı_Değeri_2 := 7;
   
   Ada.Text_IO.Put(Item => "Tamsayı Verisi_1 : ");
   
   Ada.Integer_Text_IO.Put(Item => Tamsayı_Değeri_1, width => 10);
      
   Ada.Text_IO.New_Line;   
   
   Ada.Text_IO.Put(Item => "Tamsayı Verisi_2 : ");
   
   Ada.Integer_Text_IO.Put(Item => Tamsayı_Değeri_2, width => 11)
   
   Ada.Text_IO.New_Line
   
   Ada.Text_IO.Put(Item => "Toplama : ");
   
   Ada.Integer_Text_IO.Put(Item =>  Tamsayı_Değeri_1 + Tamsayı_Değeri_2, width => 23);
   
   Ada.Text_IO.New_Line;
  
   Ada.Text_IO.Put(Item => "Çıkarma : ");
   
   Ada.Integer_Text_IO.Put(Item => Tamsayı_Değeri_1 - Tamsayı_Değeri_2, width => 23);   
   
   Ada.Text_IO.New_Line;
      
   Ada.Text_IO.Put(Item => "Çarpma : ");
   
   Ada.Integer_Text_IO.Put(Item => Tamsayı_Değeri_1 * Tamsayı_Değeri_2, width => 23);   
   
   Ada.Text_IO.New_Line;
      
   Ada.Text_IO.Put(Item => "Bölme : ");
   
   Ada.Integer_Text_IO.Put(Item => Tamsayı_Değeri_1 / Tamsayı_Değeri_2, width => 27);

   
end b3_2_3_2_uyg_2;

			
Bu programın sonucu,

Tamsayı Verisi_1 :         23
Tamsayı Verisi_2 :           7
Toplama :                      30
Çıkarma :                      16
Çarpma :                     161
Bölme :                           3

olmaktadır.
			

rem İşlemcisi

rem işlemcisi,

(sol işlenen : Integer'Base) rem (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile sol işlenenin değeri sağ işlenenin değerine bölünür. Sonuç tamsayı değilse, sıfıra en yakın tamsayı değerine tamamlanır, rem değeri,

rem = Bölünen - Tamsayı Sonuç * Bölen

olarak hesaplanır. Örnek : 11 / 5 = 5.5 , 5 < 5..5 < 6 , sıfıra en yakın tamsayı = 5 , rem = 11 - 5 *2 , rem = 1 olarak bulunur.

Negatif sonuçlarda sıfıra en yakın tamsayı, en büyük değerdir. Örnek : Bölünen = 26 , Bölen = -3 , Sonuç = -8.66666 , -9 < -8.6 < -8 , sıfıra en yakın tamsayı = -8 , rem = 26 - (-8 * -3) , rem = 26 - 24 = 2.

Negatif sonuçlarda rem değerinin işareti bölünen ile aynıdır. Örnek : Bölünen : -18 , Bölen : -4 , Sonuç = 4.5 , 4 < 4.5 < 5 , sıfıra en yakın tamsayı = 4 , rem = -18 - (4 * -4) , rem = -18 - 16 = -2 (rem değeri daima bölünenin işaretindedir).

Aşağıda, rem değerlerinin hesaplandığı etkileşimli bir prosedürün program listesi verilmiştir.

 


   with Ada.Text_IO;
   with Ada.Integer_Text_IO;
   procedure b3_2_3_2_uyg_3 is       Bölünen, Bölen , Bölme_Sonucu, Rem_Değeri : Integer;
   begin

      Ada.Text_IO.Put(item => "Lütfen Bölüneni Giriniz : ");
      Ada.Integer_Text_IO. Get(item => Bölünen);
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item => "Lütfen Böleni Giriniz : ");
      Ada.Integer_Text_IO. Get(item => Bölen);
      Bölme_Sonucu := Bölünen / Bölen;
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item => "Bölme İşlemi :  " & Integer'Image(Bölünen) & " / " & Integer'Image(Bölen) & "   Sonuç (Tamsayı Kısmı)(Ondalık Kısmı Kesilmiş) :  " & Integer'Image(Bölme_Sonucu));       Ada.Text_IO.New_Line;
      Rem_Değeri := Bölünen rem Bölen;
      Ada.Text_IO.Put(item => "Bölme işlemi Sonucunda Hesaplanan rem Değeri  : " & Integer'Image(Rem_Değeri));
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item => "Sağlama : Bölen * Bölme_Sonucu + rem = "  & Integer'Image(Bölen) & " * " & Integer'Image(Bölme_Sonucu) & " + " & Integer'Image(Rem_Değeri) & " = " & Integer'Image( Bölen * Bölme_Sonucu + Rem_Değeri));
   end b3_2_3_2_uyg_3;
Bu programın sonucu,

Lütfen Bölüneni Giriniz : -5
Lütfen Böleni Giriniz : 3
Bölme İşlemi :  -5 /  3   Sonuç (Tamsayı Kısmı)(Ondalık Kısmı Kesilmiş) :  -1
Bölme işlemi Sonucunda Hesaplanan rem Değeri  : -2
Sağlama : Bölen * Bölme_Sonucu + rem =  3 * -1 + -2 = -5

olmaktadır.
			

mod İşlemcisi

mod işlemcisi,

(sol işlenen : Integer'Base) mod (sağ işlenen : Integer'Base) geri döndürülen değer Integer'Base

şeklinde uygulanır. Bu işlemcinin uygulanması ile sol işlenenin değeri sağ işlenenin değerine bölünür. Sonuç tamsayı değilse, en küçük tamsayı değerine tamamlanır, mod değeri,

mod = Bölünen - Tamsayı Sonuç * Bölen

olarak hesaplanır. Örnek : 11 / 5 = 5.5 , 5 < 5..5 < 6 , en küçük tamsayı = 5 , mod = 11 - 5 *2 , mod = 1 olarak bulunur. Görüldüğü gibi, pozitif sayılar için rem ve mod değerleri aynıdır.

Negatif sayılarda durum değişir. Negatif sayılarda en küçük değer sıfıra en uzak değerdir. Örnek : Bölünen = 26 , Bölen = -3 , Sonuç = -8.66666 , -9 < -8.6 < -8 , sıfıra en uzak (en küçük) tamsayı = -9 , mod = 26 - (-9 * -3) , mod = 26 - 27 = -1 (mod değeri daima bölenin işaretindedir).

Aşağıda, mod değerlerinin hesaplandığı etkileşimli bir prosedürün program listesi verilmiştir.

 

   with Ada.Text_IO;
   with Ada.Integer_Text_IO;
    procedure b3_2_3_1_uyg_4 is
      Bölünen, Bölen , Bölme_Sonucu, Mod_Değeri : Integer;
   begin
      Ada.Text_IO.Put(item => "Lütfen Bölüneni Giriniz : ");
      Ada.Integer_Text_IO. Get(item =>Bölünen);
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item => "Lütfen Böleni Giriniz : ");
      Ada.Integer_Text_IO. Get(item => Bölen);
      Mod_Değeri := Bölünen mod Bölen;
      Bölme_Sonucu := (Mod_değeri - Bölünen) / (- Bölen);
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item => "Bölme İşlemi :  " & Integer'Image(Bölünen) & " / " & Integer'Image(Bölen) & "   Sonuç (Tamsayı Kısmı)(Sonucun En Yakınında Olan En küçük Tamsayı Değerine İndirgenmiş) :  " & Integer'Image(Bölme_Sonucu));       Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item =>"Bölme işlemi Sonucunda Kalan (mod) Değeri  : " & Integer'Image(Mod_Değeri));
      Ada.Text_IO.New_Line;
      Ada.Text_IO.Put(item =>"Sağlama : Bölen * Bölme_Sonucu + mod = "  & Integer'Image(Bölen) & " * " & Integer'Image(Bölme_Sonucu) & " + (" & Integer'Image(Mod_Değeri) & ") = " & Integer'Image( Bölen * Bölme_Sonucu + Mod_Değeri));        end b3_2_3_1_uyg_4;
Bu programın sonucu,

Lütfen Bölüneni Giriniz : 26
Lütfen Böleni Giriniz : -3
Bölme İşlemi :   26 / -3   Sonuç (Tamsayı Kısmı)(Sonucun En Yakınında Olan En küçük Tamsayı Değerine İndirgenmiş) :  -9
Bölme işlemi Sonucunda Kalan (mod) Değeri  : -1
Sağlama : Bölen * Bölme_Sonucu + mod = -3 * -9 + (-1) =  26

olmaktadır.
			

Yukarıdaki prosedür sonuçlarından da görüldüğü gibi,
rem daima bölünenin
mod daima bölenin
işaretini taşır.

Üs Alma İşlemcisi (Yüksek Öncelikli İşlemci)(**)

Ada programlama dili, çok az program dilinde bulunan üs alma işlemcisi içerir. Üs alma işlemcisi diğer tüm işlemcileren daha yüksek önceliklidir. Bu yüzden, "Yüksek Öncelikli İşlemci" olarak da tanımlanır. Üs alma işlemcisi,

(sol işlenen : Integer'Base) ** (sağ işlenen : Natural) geri döndürülen değer Integer'Base

olarak uygulanır. Bu işlemcinin üs alma değeri, Stanadrt pakette bir Tamsayı alt tipi olarak tanımlanmış olan Natural tamsayı tipindedir. Natural tamsayı tipinin kapsam aralığı 0 .. yerleşime bağlı olarak tanımlanmıştır. Yani, üs alma değerleri 0 olabilir fakat negatif değerler olamaz. Ayrıca, dikkat edilmezse kolaylıkla kapsam aşımı hatası oluşabilir. Bunun dışında, çok kullanışlı ve yararlı bir işlemcidir. Aşağıdaki prosedürde, bir üs alma işleminin uygulanması görülmektedir.

with Ada.Text_IO;
with Ada.Integer_Text_IO;

procedure b3_2_3_2_uyg_5 is

begin

   Ada.Text_IO.Put("2 + 12 **2 ifadesinin sonucu : ");

   Ada.Integer_Text_IO.Put(2+12**2);

end b3_2_3_2_uyg_5;
			

Bu programın sonucu,

2 + 12 **2 ifadesinin sonucu :         146

olmaktadır.
			

Yukarıdaki prosedür çıkışında da da açıkça görüldüğü gibi, üs alam işlemcisi en yüksek önceliklidir. Çünkü önce 12 **2 işlemi ile 144 sayısı bulunmuş, sonra buna 2 eklenerek sonuç 146 olmuştur. Yine de ifadelerde, öncelik sıralarının iyi kestirilemediği durumlarda en güvenli yöntem, parantezlerin kullanılması ile, ifade sonucunun hedeflendiği gibi hesaplanmasını sağlamaktır.

İlişkisel İşlemciler

Integer öntanımlı veri tipi için, < , > <= , >= , = , /= ilişkisel işlemcileri tanımlıdır. Bu işlemcilerin uygulanma yöntemleri daha önce incelemiş olduğumuz Boolean veri tipinin ilişkisel işlemlerinin uygulanması ile aynıdır.

Intger veri tipi nesnelerinin büyüklüklerinin tanımı açıktır. Eğer Integer veri tipi, sayılabilir bir veri tipi olarak düşünülürse, tamsayı elemanlarının önce küçük değerden başlayarak giderek teker teker monotonik büyüyen değerler (sonraki = önceki +1) olarak yerleştiği düşünülebilir. Buradan sayılabilir verilerin en son tanımlanan elemanlarının en büyük olarak kabul edilmelerinin de mantığı açıklanmış olur.

Integer veri tipinin incelemelerini burada tamamlamış oluyoruz. Artık bu veri tipini uygulamalarımızda bilinçli olarak kullanabilecek duruma gelmiş durumdayız.

3.2.4 - Long_Integer

Ada 2012 spesifikasyonu, tüm derleyicilerin Long_Integer veri tipini desteklemesini gerekli kılmıştır. Long_Integer veri tipi eskiden 16 bit sistemlerin yaygın olduğu dönemlerde, sistemlere 32 bitlik tamsayı değişkeninin kapsamının sağlanması amacı ile oluşturulmuştur. Günümüzde 32 bit sistemler standart hale gelmiş ve 64 bitlik sistemler de yaygınlık kazanmaya başlamıştır. 32 bit sistemlerde Integer ve Long_Integer farkı kalmadığından, Long_Integer veri tipinin kullanımı gereksiz hale gelmiştir. Bu veri tipi, günümüzde sadece eskiye uyum için desteklenmektedir ve gelecekte kullanımdan kalkacağı kesindir. Biz de bu çalışma kapsamında Long_Integer veri tipini kullanmayacağız. Kullanıcılar kendi özgün tamsayı alt tiplerini kolaylıkla tanımlayabilmekte ve uygulayabilmektedirler. Bu nedenle standart dışı veri tiplerinin kullanımı sağlık verilmemektedir.

3.2.5 - Long_Long_Integer

Long_Long_Integer veri tipi 64 bit tanım genişliği ile, Integer ve Long_Integer veri tiplerinden daha geniş kapsamlı tamsayı tanım aralığı sağlamaktadır. Buna rağmen, güncel eğilim kullanıcıların öntanımlı tiplerden çok kendi gereksinmelerine göre kendi özgün veri tiplerini tanımlayıp uygulamaları yönündedir. Bu düşünce ile, long_long_Integer veri tipinin kullanımı yerine kullanıcıların kendi özgün tiplerini tanıtıp kullanmaları daha uygun olacaktır.

3.2.6 - Wide_Integer ve Wide_Wide_Integer

Ada programlama dili, öntanımlı veri tipi tanımlamaz. Veri tipleri, prensip olarak bir De-Facto veri tipi standardı oluşturan Standard pakette tanımlanır. Wide_Integer ve Wide_Wide_Integer veri tipleri, Ada 2012 spesifikasyonu ile birlikte dağıtılan Standard pakette tanımlanmamışlardır. Bu veri tiplerini en çok kullanılan GNAT derleyicisi desteklememektedir. Bunun nedeni, kullanıcıların kendi özgün alt veri tiplerini kolaylaylıkla tanımlayarak uygulayabildikleri, çok esnek bir programlama dili olan Ada programlama dilinde, temel veri tipleri dışında alt veri tiplerinin öntanımının gereksiz görülmüş olmasıdır. Bu desteğin verilmemiş olmasının kullanıcıya kaybettireceği birşey yoktur. Kullanıcı kendi çalışmalarına uygun alt veri tiplerini, kolaylıkla kendisi tanımlayıp uygulayabilmektedir.