1. Bu site çerezler kullanır. Bu siteyi kullanmaya devam ederek çerez kullanımımızı kabul etmiş olursunuz. Daha Fazla Bilgi.

Derleyiciler ve C Dilinin Özellikleri

'Bilgisayar Programlama ve Kodlama' forumunda Powers tarafından 15 Ocak 2013 tarihinde açılan konu

  1. Powers

    Powers Administrator Site Yetkilisi

    Üst düzey dillerden biri ile yazılmış olan bir programı, makine diline çeviren programa derleyici denir. TURBO C de böyle bir derleyicidir. TURBO C isminin belirttiği gibi "hızlı C" şeklinde değil de, Borland firmasının çıkardığı C lisanı derleyicisi versyonu olarak düşünmek gerekir.

    C dilini diğerlerinden ayıran özellikleri şöyle sıralayabiliriz.

    a) C dili orta sınıf bir dildir.

    b) C dili yapısal bir dildir.

    c) C dili gerçek programcıların kabul ettiği bir dildir.

    d) C dili değişik bilgisayarlara kolayca adapte olan bir dildir.



    C, genel amaçlı bir dil olarak hazırlanmıştır. PC’nin, BASIC veya PASCAL gibi diller kullanılarak ulaşılamayan bazı bölümlerin kullanılmasını sağladığı için, uygulama programcılarının bir çoğu C’yi yeğlerler. C, bilgisayarın herhangi bir yerine kolayca ulaşmamızı sağlar.



    C kullanırken yapabileceğimiz en önemli hatayı, yalnızca bilgisayarı kapatıp açarak düzeltebiliriz. C, PC’nin ortaya çıkması ile başlamadı. C’nin kökeni çok daha eskiye gider. C, 70’li yılların başında, AT&T tarafından, mini bilgisayarlarda kullanılmak üzere tasarlanmıştır. Bu dilin beğenilmesi sonucunda, C kısa zamanda yayıldı. Sonunda C, UNIX adı verilen bir işletim sisteminin oluşturulmasında kullanıldı. 1978’de American National Standarts Institude (ANSI) tarafından standart hale getirilen C dili orta sınıf bir dildir.



    TURBO C’YE GENEL BİR BAKIŞ



    Turbo C, diğer C editör ve derleyici uyarlamalarından farklı bir biçimde işler. Derleyiciler genellikle DOS işletisinden çağrılır ve buradan diskete/diske daha önceden kaydedilmiş olan bir metin kütüğünün çevrilmesine yöneltilirler.



    Yapısal programlama, program karmaşıklığını azaltmak ve programları daha kolay anlaşılabilir, okunabilir, geliştirilebilir, değiştirilebilir biçime getirmeyi amaçlayan genel bir programlama yöntemidir.



    Metin kütüğünü yazmak için, bir metin editörü veya bir kelime işlemci kullanılmalıdır. Derleyicilerin pek azının kendi editörleri vardır.



    TURBO C ÇEVRESİ



    Birleşik TURBO C çevresi, editör ve derleyiciyi tek bir programda birleştirdiği için, programın yazılmasını ve edit edilmesini kolaylaştırır.



    Bir programı oluşturmak için, TURBO C editörüne girin ve program metnini yazın. Programın tümünü yazdıktan sonra, TURBO C derleyicisini doğrudan editörden çalıştırabilirsiniz. Programı derlenmeden önce diske/diskete kaydetmeniz gerekli değildir. Tek bir tuşa basarak programı derleyebilirsiniz.



    Üzerinde çalıştığınız kütük, bellekte tutulduğu için, birleşik çevre derleme işini bütün derleyicilerden daha hızlı yapar. Ayrı bir editör ve derleyici yerine tek bir program kullanmanın hızlı olmanın yanında başka avantajları da vardır.



    Birleşik TURBO C çevresinde, editör derleyicinin bulduğu hataları her zaman bilir. TURBO C editörü, derleyicinin bulduğu her hatanın yerini size gösterir.



    Birleşik TURBO C çevresi kullanıldığında oluşan yapı;

    · programın yazılması

    · programın işletilmesi

    · programın değiştirilmesi

    · programın işletilmesi



    MENÜ SİSTEMİ:



    TURBO C değişik bir menü sistemi kullanır. Menüler programlama sırasında sık sık kullanılırlar. Bir menü her zaman, ne yapabileceğinizi çok açık biçimde gösterir.



    C PROGRAM YAPISI



    TÜMCELER : Bütün C programları, bir dizi tümceden oluşurlar. Genellikle bir tümce tek bir eylem olarak düşünülebilir. Tümceler bir dizi sözcükten (komuttan) oluţurlar. Her tümce C’de ";" karakteri ile bitirilir.





    ÖRNEK

    int i;

    a=a+1;

    while(z<23) a=a+54;



    Her satıra tek bir tümce yazılırsa, tümceleri birbirinden ayırmak daha kolay olur. Bu derleyici için bir zorunluluk değildir.

    Tümceler genellikle iki gruptan birine girerler.

    · iţletilebilen

    · bildirim

    İşletilebilen tümceler, işlem yapabilen komutlar içerirler. Bu tür tümcelerin bir blok içine ( { } parantezleri içine) yerleştirilmeleri gerekir.

    Bildirim tümceleri, programın işletmek zorunda olduğu yapıları belirlerler. Aşağıdaki özel bildirim tümcesi, bütün C programlarında bulunmalıdır.



    Main( )



    Bu tümce, programın nerede çalışmaya başlayacığını gösterir.



    BLOKLAR



    Tümceler, blok adı verilen birimlerde bir araya toplanırlar. Bir blok, herhangi bir tümce veya blok grubundan oluşabilir. Blokun başlangıcını ve bitişini göstermek için oklu parantezler ( { } ) kullanılır. Blokları birbirinden ayırmak, programı anlamak açısından oldukça önemlidir.



    ÖRNEK

    z=z*x /* blok 1 */

    { /* blok 2 */

    printf("%d", z);

    for (i=5;i<z;i++);

    printf("%d",z);

    }

    { /* blok 3 */

    i=i-1;

    d=z*x-i;

    printf("%d", d);

    }

    { /* blok 4 */

    { /* blok 4-a */

    { /* blok 4-b */

    i=78;

    i=i*z;

    printf("%d", i);

    }

    printf("%d", z);

    }

    }



    DERLEME KOMUTLARI



    Bir C programı, tümcelere ek olarak, derleyici için komutlar da içerebilir. Derleyici komutları adı verilen bu komutlar, gerçek programın bir parçası değildir. Programda bulunan diğer tümcelerin çevirisini yönetirler.



    Bu komutlar her zaman numara sembolü (#) ile başlarlar. Programın herhangi bir yerinde, tek bir satırda, yalnız başlarına olmalıdırlar.



    AÇIKLAMALAR



    Açıklamalar herhangi bir yerde olabilir, /* karakterleri ile başlamalı ve */ karakterleri ile bitmelidir.



    ÖRNEK

    # include <stdio.h> /* standart girdi/çıktıyı dahil et*/

    main ( )

    {

    printf ("Merhaba, Dünya\n");

    printf ("Bu benim ilk C programım\n");

    }



    Programın ilk satırı # işareti ile başladığı için bu satırın bir derleyici komutu olduğu anlaşılır. include komutu, derleyiciye stdio.h kütüğünü bulmasını ve derlemekte olduğu programa eklemesini söyler. Stdio.h özel bir kütüktür. Giriş ve çıkış için komutlar içerir.



    Main ( ) özel bildirimi, kendisini izleyen blokun, program işletiminin başladığı yer olduğunu bildirir.



    Printf ( ) işletilebilir bir komuttur. Parantezler arasına yazılan herhangi bir metni ekranda yazdırır. Metin üstten (" ") işaretleri arasına yazılmalıdır.



    \n karakterleri printf ( ) tarafından özel olarak yorumlanır. Alttaki satırın başına geçilmesini sağlar. <ENTER> tuşu gibi.





    DEĞİŞKENLER



    Bir C değişkeni, bir kutuya benzer. Kutular nesnelerin saklanması için kullanılırlar, değişik şekillerdeki nesneler, değişik şekillerdeki kutularda saklanırlar ve her bir kutuya tek bir nesne konulabilir. Değişkenlerin farklı tipleri vardır. Değişkenin tipi, içinde nasıl bir nesne saklanabileceğini belirler. En basit değişken tipi int değişkenlerdir. (Tamsayı anlamındaki integer için kullanılan bir kısaltmadır.) Bir int değişkeninde -32768 ile 32767 arasındaki herhangi bir sayı saklanabilir fakat kesir kullanılamaz.

    78 456 9 -38 -89 0 geçerli

    9.8 5/8 6.666666 geçersiz



    DEĞİŞKENLERİN BİLDİRİLMESİ



    Bir değişkenin bildirimini yapmak için, değişkenin tipi ardından da değişkenin adı yazılır. Değişken isimleri, bir harfle başlamalı ve yalnızca harfler, sayılar ve alt çizgileri ( _ ) içermeleri gerekir. 32 karakterden fazla olmamalıdır.



    ÖRNEK

    m i sayı dur son_nokta toplam : geçerli

    998 7son bu.sonuc adı? gir+bir : geçersiz



    DEĞİŞKENE DEĞER VERİLMESİ

    C’de bir değişkene bilgi yerleştirmek için eşit(=) işareti kullanılır.

    a=10; b=100; c=0;

    gibi



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    a=10;

    printf("a’nın değeri %d\n", a); }

    DEĞİŞKEN TİPLERİ



    Char : Char tipi, özellikle karakterlerin saklanması içindir.



    ‘a’ ‘1’ ‘=’ ‘&’ ‘\’ ‘B’ ... geçerli karakterlerdir.

    Her bir karakter iki üstten virgül arasındadır.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    char a;

    a=’z’;

    printf("a’nın değeri %c\n", a);

    }



    NOT: Bir char değişkeni, bir int değişkeninden daha küçüktür, bu nedenle, bir int değişkeni gibi sayılar alabilmesine karşın, bu sayılar daha küçük olmalıdır. Char tipi bir değişkene, yalnızca 0 ile 255 arasındaki sayılar saklanabilir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    char a;

    a= 8;

    printf("a’nın değeri %c\n", a);

    }



    NOT : Bir char değişkenine 255’den büyük bir sayı sığdırmaya çalışılırsa sonuç 0 olur. Herhangi bir hata oluşmaz, bu C’nin bir esnekliğidir.



    FLOAT : Float tipi bir değişken, ondalıklı bir sayı içerir.

    8.7 0.898 4.23E9 6.666 ... gibi



    Yukarıdaki değerlerden hiç birisi, bir int değişkeninde saklanamaz. Bir int değişkenini 3.88 ile eşitlerseniz sonuç 3 olur.



    7 98 330030 gibi tam sayı değişkenleri float değişkenine eşitlenirse 7 7.0, 98 98.0 olarak değiştirilir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    float a;

    a= 8.909;

    printf("a’nın değeri %f\n", a);

    }



    float değişkenleri 3.4E-38 ile 3.4E+38 arasındaki herhangi bir değere eşitlenebilirler.



    LONG : (uzun tamsayı), yalnızca çok uzun tamsayılar gerektiği zaman kullanılırlar.

    -2,147,843 ile 2,147,843 arasında değer alabilir. Tamsayılar ile yapılan işlemler tam kesinlikte olacaktır. Toplama ve çarpma gibi işlemler. Float tipi, gezer nokta derişkenleri için durum böyle değildir. Böyle değişkenler için yalnızca belirli bir sayıda kesinlik rakamı vardır.



    DOUBLE : Float tipi değişkenlerde kesinlik önemli ise bu tür tanımlama yapılır.



    TİP ALT ÜST YAKLAŞIK KESİNLİK

    Float 3.4E-38 3.4E+38 7 rakam

    Double 1.7E-308 1.7E+308 14 rakam



    Teorik olarak, sonsuz sayıda gezer_nokta sayısı vardır.



    .5 4.55 4.555 4.5555 4.55555 4.555555555 4.555555555555555



    Yukarıdaki örnekte son iki sayı float tipi değişkene eşitlenirse, 4.555555556 olarak yuvarlnır.

    Double kullanarak daha iyi bir sonuç elde edilebilir. Sonuç 4.555555555555556 olarak değişir. Kesinlik önemli ise double kullanılmalıdır.



    MAKROLAR : Bir C makrosu, belli bir değeri bir isimle değiştirmek için kullanışlı bir yöntem sağlar. Sık kullanılan değerlere bir isim vermenin kolay bir yöntemidir. Bir C tümcesi değildir, derleyici komutuna benzer. Sintaksı (kullanım şekli) şöyledir.



    # define isim değer



    Bu derleyiciye, ne zaman isim görülürse onun yerine belli bir değer koymasını söyler.



    ÖRNEK

    # include <stdio.h>

    # define PI 3.1415 /* PI için değer belirlenmesi */

    main( )

    float b=PI;

    float a;

    a=PI;

    printf("a’nın değeri %f\n", a);

    printf("a’nın değeri %f\né, PI);

    }



    MATEMATİKSEL İŞLEMLER



    C dili hemen hemen her matematiksel uygulamada kullanılabilir.

    + toplama

    - çıkarma

    * çarpma

    / bölme

    aritmetik işlemler için kullanılırlar.



    MODÜLÜS : İki sayının modülüsü, bir sayının diğerine bölünmesinden oluşan kalandır. Modülüs işlemi için % işareti kullanılır. 5%2 örneğinde 5 sayısı 2’ye tam olarak iki defa bölünür ve 1 artar. Bu nedenle 5 ve 2’nin modülüsü 1 dir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    a=6%3;

    printf("a’nın değeri %d\n", a);

    }



    örneğinde a=0’dır. 6’da 3 iki defa vardır, kalan sıfırdır.



    # include <stdio.h>

    main( )

    {

    int a;

    a=2%6;

    printf("a’nın değeri %d\n", a);

    }



    örneğinde sonuç 2’dir. 2 sayısında 6 hiç olmadığı için kalan 2’dir



    ÖNCELİK :



    C’de işlemlerin, öncelik adı verilen bir özellikleri vardır. Önceliği yüksek olan işlemler önce yapılırlar. Beş temel işlem öncelik sırası aşağıda verilmiştir.



    İŞLEM ÖNCELİK

    * / % ilk

    + - son



    NOT : Aynı öncelikte iki işlem arasında seçim yapmak gerektiğinde, işlem soldan sağa doğru çözülür.



    ÖRNEK :

    # include <stdio.h>

    main( )

    {

    float a;

    a=5+6*7/2;

    printf("a’nın değeri %f\n", a);

    }



    Bu program nasıl bir değer verir? Bu eşitlikte, hem çarpmanın hem de bölmenin toplamaya göre öncelikleri vardır. İlk olarak bu iki işlemden biri yapılmalıdır. Çarpma daha solda olduğu için ilk önce yapılır.



    Bu iţlem 6*7=42 sonucunu verir.

    a=5+42/2; Daha sonra bölme işlemi yapılır.

    a=5+21; ve toplama işlemi yapılır.

    a’nın değeri 26.000000



    Öncelik kurallarını karıştırmamak için parantezler kullanılır. parantez içindeki işlemler önce yapılır.



    a=((5+6)*7)/2; gibi



    EŞİTLİKLERDE DEĞİŞKEN KULLANIMI



    Tipi yazdıktan sonra, değişken isimleri araya virgüller koyarak aynı tipte birden fazla değişken tanımlanabilir.



    Tip isim1, isim2, isim3;

    int a,b,c;



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int x,y,a;

    x=4;y=2;

    a=x*x+y*y; printf("a’nın değeri %d\n", a);

    }



    NOT : Bir değişkenin içeriğini kullanmadan önce, değişkenin bir değere eşitlenmiş olmasına dikkat edilmelidir. Program derlenirken warning(uyarı mesajı) verebilir. Bu nedenle C, değişkenlerin tanımı yapılırken değişkenlere değer atanmasına olanak sağlar.



    Bu tümce ţöyledir.



    Tip isim1=değer;

    veya

    tip isim1=değer1, isim2=değer2;



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a,x=0,y=0;

    y=2;

    a=x*x+y*y;

    printf("a’nın değeri %f\n",a);

    }



    FONKSİYON ÇAĞRILARI KÜTÜPHANELER



    Bir standart fonksiyon kullanabilmek için, C’ye bu fonksiyonun tanımının nerede bulunabileceğini belirtmek gerekir. Bu # include derleyici komutu ile yapılır.



    Bu tür standart fonksiyon kütükleri bir dizi bildirim tümcesi içerir. Bu komut digesi, başlatım kütüklerinde toplanır. Bu kütükler kütük adı eki olarak .h alırlar. Biz şimdiye kadar yalnızca stdio.h başlatım kütüğünü kullandık.



    Stdio.h kütüğü C’nin bütün standart giriş/çıkış fonksiyonlarını kullanmasına olanak sağlar.

    En önemlilerinden bazıları şunlardır.



    Stdio.h : C’nin en önemli kütüphanesi. Programın bütün üstdüzey giriş ve çıkışlarını yapar.



    Math.h : Bütün matematiksel uygulamalarda kullanılır. tanjant, sinüs, cosinüs... gibi fonksiyonların kullanılmasına olanak sağlar.



    Ctype.h : Bir değişkenin tipini kontrol eden bir dizi kısa yordam. Örneğin bir karakter değişkeninin nokta içerip içermediğine bakabilirsiniz.



    Stdlib.h : Rasgele sayı üreten, sıralama yapan, Dos’a çıkan veya başka gerekli işleri yapan karışık bir yordam grubu.





    C FONKSİYONLARI



    Fonksiyon, belli bir işi yapmak üzere tasarlanmış program parçasıdır. Parametre (değer) kullanabilirler ve kullanmayabilirler. Fonksiyon bittiği zaman bir değer verbilir veya vermeyebilir. Printf(), en azından bir parametre kullanan bir C fonksiyonudur. Bu karakterleri ekrana yazdırır ve bir değer vermeden ana programa geri döner.



    ÖRNEK

    # include <stdio.h>

    # include <ctype.h>

    main( )

    {

    char a,b;

    b=’F’;

    a=tolower(b);

    printf("a’nın değeri %c", a);

    }



    tolower( ) fonksiyonu C’nin ctype.h kütüphanesindedir. Bu fonksiyon büyük harfi küçük harfe çevirir.



    Printf( ) fonksiyonu genel amaçlı bir format çevirim fonksyonudur. İki parametresi vardır. İlki bir karakter dizgisidir. % işareti ikinci parametrenin nereye konulacağını ve hangi biçimde yazılacağını gösterir.



    FORMAT BELİRLEMESİ

    char %c

    int %d

    float %f

    ASCII DEĞER: Bilgisayarda, her bir karakter belli bir sayıya eşitlenir. Bu sayıya ASCII değeri adı verilir. Örneğin A harfi 65 olarak saklanır.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    char=65;

    printf("a=%c veya %d\n", a, a);

    }



    program sonucu a=’A’ veya a=65 olur.



    SCANF( ) FONKSİYONU



    Klavyeden değer okumak için kullanılır. scanf( ) ile kullanılan parametreler, printf( ) ile kullanılanlarla aynı kurala uyarlar.scanf( )’in format dizgileri genellikle format belirlemelerinden oluşur.



    scanf("%d", &cevap);



    Bu tümce bir tamsayı okur ve cevap adlı bir değişkeni bu tamsayıya eşitler.



    Scanf( ) bir format dizgisi ve & işareti ile başlayan değişken isimleri listesi gerektirir, tüm değişken isimlerinin & ile başlaması gerekir. Scanf( ) <ENTER> tuşuna basılana kadar hiç bir şey okumaz. <ENTER> tuşuna basar basmaz, scanf( ) basılan tuşları okumaya baţlar.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int sayı;

    scanf("%d", &sayı);

    printf("sayınıa=%d\n", sayı);

    }



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    char kar1,kar2,kar3,kar4;

    scanf("%c%c%c%c", &kar1, &kar2, &kar3, &kar4);

    printf("%c%c%c%c", kar1, kar2, kar3, kar4);

    }



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    float a,b,c,d;

    scanf("%f%f", &a, &b);

    scanf("%f%f", &c, &d);

    printf("%f%f%f%f", d, c, b, a);

    }



    NOT: Format belirlemesinin türünün, değişkeninki ile aynı olması gerekir. Sayısal değerler girilirken değerleri birbirinden boşluk, tab veya return tuşu ile birbirinden ayırmak gerekir. Char tipi değişkenlerde ise bu işlem yapılmaz.



    KONTROL TÜMCELERİ



    Kontrol tümceleri programın akışını kontrol ederler.

    KONTROL YAPISI SINIFLARI



    Kontrol yapıları üç ayrı grupta toplanabilir.



    · if (eğer) tümceleri; farklı koşullar altında farklı tümcelerin işletilmesini sağlarlar.



    · döngüler; bir dizi tümcenin bir kaç defa tekrarlanabilmesine olanak sağlarlar



    · fonksiyonlar; bir dizi tümcenin programın değişik noktalarında kullanılmasını

    sağlarlar. Her kontrol yapısı kontrol ettiği bir tümceyi veya tümce bloğunu içerir.



    {

    a=a+3;

    z=a+b;

    }

    veya



    {a=a+3;z=a+b}



    tümceleri birer bloktur.



    IF TÜMCELERİ



    Bir if (eğer) tümcesi bir eşitliği kontrol eder ve eşitlik doğru ise, kontrol ettiği tümce işletilir. Eşitlik yanlış ise tümce göz ardı edilir.



    İlk biçimi; if (eşitlik)

    tümce;



    C’de eşitlik için = = (çift eşit) işaretleri kullanılır.



    a= =0;a==b;a= =1...

    gibi



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    printf("a’nın değerini girin:");

    scanf("%d", &a);

    if (a= =1)

    printf("a birdir\n");

    }



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    printf("a’nın değeri :");

    scanf("%d", &a);

    if (a= =1)

    {

    a=a+100;

    printf("a’nın değeri = %d\n", a); } }



    NOT: Bir if cümlesi içerisinde eşitleme işlemi yapılabilir. Fonksiyonlar genellikle, işlemi yapabildikleri zaman doğru yapamadıkları zaman yanlış değerini alırlar.



    ÖRNEĞİN atoi( ) fonksiyonu dizgileri sayıya çevirir.

    atoi("451") dizgiyi yani "451"’i sayıya çevirebilir ve sonuç olarak doğru verir.



    atoi("Ali") dizgiyi "Ali"’yi sayıya çeviremez ve yanlış verir.





    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int sayı;

    if (sayı=atoi("592")) /* "==" değil */

    printf("Dizgi bu sayıdır: %d\n", sayı);

    }



    İLİŞKİ İŞARETLERİ

    a<b küçüktür

    a>b büyüktür

    a<=b küçük veya eţit

    a>= büyük veya eţit

    a!=b eşit değil



    Bütün bu işlemlerde a veya b yerine herhangi bir değer, değişken veya eşitlik konulabilir.



    a>=780

    76<=9

    x+23!=y-z

    8-3==887-deger



    IF-ELSE DEYİMİ : Genel yapısıaşağıdaki şekildedir.



    İf (eşitlik)

    tümce1;

    else

    tümce2;



    eşitlik doğru ise tümce1 işletilir yanlış ise tümce2 işletilir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a, b;

    printf("a=\n");

    scanf("%d", &a);

    printf("b= \n");

    scanf("%d", &b);

    if (a+b>=5)

    printf("4’ten daha fazlalar\");

    else

    printf("4’den daha azlar\n"); }





    KARMAŞIK EŞİTLİKLER



    İki veya daha fazla eşitliği karşılaştırarak karmaşık eşitlikler oluşturulabilir. Bunun için and (ve), or (veya) kullanılır C’de; and için &&, or için || işaretleri kullanılır.



    if (a==0 && b==0) Bu örnekte hem a=0, hem de b=0 ise doğru değeri verilir.



    if (a==0 || b==0) tümcesinde a veya b sıfır ise doğru değeri verilir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a, b;

    printf("a=\n");

    scanf("%d", &a);

    printf("b= \n");

    scanf("%d", &b);

    if (a==5 && b==5)

    printf("ikisi de uyuyor\n");

    }



    Aritmetiksel işlemler gibi ilişkisel ve mantıksal işlemler de sonuç olarak bir değer verirler. İf tümcesindeki parantezin içinde yalnızca bir değer olması yeterlidir.



    İf (değer)

    tümce;



    Değer doğru ise tümce işletilir. C’de 0 olmayan bütün sayılar doğrudur. Sıfır yanlışı

    gösterir. İlişkisel ve mantıksal işlemlerde doğru genellikle -1, yanlış 0 değerini verirler.



    ÖNCELİK SIRASINA GÖRE İŞLEMLER



    Sembol Anlamı Öceliği



    * çarpma 1

    / bölme 1

    % modülüs 1

    + toplama 2

    - çıkarma 2

    < küçüktür 3

    > büyüktür 3

    <= küçükeţit 3

    >= büyükeţit 3

    == eţit 3

    != eşitdeğil 3

    && mantıksal ve 4

    || mantıksal veya 4

    = eţitlik 5



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a=5, b=4, c=1;

    if (a+b<=c*45)

    printf("Bu doğrudur\n"); }



    DÖNGÜLER (LOOPS)



    Döngü adı verilen kontrol yapısı bir tümce blokunu bir kaç kez işletir. Döngü sayısının nasıl belirleneceği, döngünün tipine bağlıdır. C’de üç tip döngü vardır.



    · while döngüsü

    · for döngüsü

    · do döngüsü



    WHILE DÖNGÜSÜ



    Bu döngü bir koşul doğru olduğu sürece tümce blokunu tekrarlar. Koşul geçerli olmadığı anda program döngüyü izleyen komutlara geçer. Koşul tümcesinin kullanımı ile aynıdır. Genel şekli;



    while (koţul)

    blok1;



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    a=10;

    while (a>0)

    {

    a=a-1;

    printf("a’nın değeri= %d\n", a);

    }

    printf("döngü bitti\n");

    }



    SONSUZ DÖNGÜ

    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    a=10;

    while (a>0)

    {

    printf("a’nın değeri= %d\n", a); }

    printf("döngü bitti\n"); }



    a değişkeni hiç değişmediği için koşul hiç değişmez ve döngü tekrarlanıp durur.



    ARTIMLAR VE EKSİLİMLER



    Döngü kullanımında kontrol değişkenine 1 eklenir (ileri sayma) veya 1 çıkartılır. (geri sayma)

    Aritmetik olarak a=a+1 veya a=a-1 biçiminde yapılır. Ancak C bu işlemler için daha kısa yollar sunar. İşlem işaretlerinden ++ ve - artım ve eksilim işaretleri olarak tanınırlar. ++ değişken 1 ekler, -- değişkenden 1 çıkarır. Yukarıdaki örnek şu şekilde yapılabilir di.



    # include <stdio.h>

    main( )

    {

    int a=10;

    while (a>0)

    {

    a--;

    printf("a’nın değeri= %d\n", a); }

    printf("döngü bitti\n"); }



    Bu işlemlerin avantajı, bir eşitliğin içinde kullanılabilmeleridir. Her bir işlem iki biçimde kullanılabilir.

    --a

    a--

    ++a

    a++

    Sembol değişkenden önce gelirse artım veya eksilim işlemin bulunduğu tümceden önce yapılır. Sembol değişkenden sonra gelirse işlem tümceden sonra yapılır.



    a=a-1;

    printf("a’nın değeri= %d\n", a);

    Bu aşağıdaki tek satıra dönüştürülebilir.



    printf("a’nın değeri= %d\n", --a);



    Aşağıdaki tümceyi ele alalım;



    printf("a’nın değeri= %d\n", a--);



    Bu aşağıdaki iki tümce ile aynı işi yapar;



    printf("a’nın değeri= %d\n", a);

    a=a-1;



    NOT: Bu işlemler bulundukları eşitliğin bir parçası olmadıklarından diğer işlemlerden biraz farklı çalışırlar. Diğer tüm işlemlerden daha büyük bir önceliğe sahiptirler.



    ÖRNEK

    a=c++*12+saatlerin_toplamı;



    Önceliği en yüksek işlem ++ olduğu için eşitlik şu duruma gelir.



    a=c*12+saatlerin_toplamı;



    c=c+1;



    Burada c++ olduğu için a üzerinde bir etkisi yoktur.



    A=++c*12+saatlerin_toplamı;



    Burada ++c olduğundan ++ işleminin a üzerinde bir etkisi vardır.



    c=a+++b; eşitliğinde belirsizlik vardır. C, artımı a değişkenine bağlar fakat istenmeyen durumlardan kaçınmak için



    c=a+++b; eşitliği ya c=a++ +b; veya c=(a++) +b; şeklinde yazılır.





    FOR DÖNGÜSÜ



    For döngüsü program kontrolünü biraz daha basitleştirir. While döngüsü kadar esnek olmamasına rağmen anlaşılması ve kullanımı daha kolaydır. Genel bir kural olarak, bütün döngülerin üç ayrı parçası olmalıdır.



    ·ilk durum belirlenmelidir. (a=10;)

    ·durumu değiştirilmelidir. (a--;)

    ·döngünün sürüp sürmeyeceğinin belirlenmesi için durumu belirlemenin bir

    yolu olmalıdır. (a>0)



    for döngüsünün kullanımı şöyledir.



    for (ilk durum; koşul ; değiştirici tümceler)

    blok;



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    for (a=10; a>0; a--)

    printf("a’nın değeri %d\n", a);

    printf("döngü bitti");

    }



    for(a=10; a<0;)

    printf("a’nın değeri\n");



    sonsuz döngü; tümcenin yanlış olduğu hemen görülebilir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a;

    printf("ilk değeri girin="); /*Başlangıç koşulunun girilmesi*/

    scanf("%d", &a);

    for(;a>0;a--)

    printf("a’nın değeri %d\n", a);

    printf("döngü bitti\n");

    }



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    char ch=0;

    while (ch!=’q’)

    {

    printf("döngü başlangıcı\n"); /* Bir miktar tümce */

    printf("bitirmek için q’ya devam etmek için herhangi bir tuşa basın;");

    ch=getch( );

    printf("\n");

    }

    }



    Bu program q harfi yazılana kadar açıklama satırı ile aynı blokta bulunan tümceleri tekrarlar. Yazılan tuşu okumak için getch( ) fonksiyonu kullanılır. getch( ) <ENTER> tuşuna basılmasını beklemez.



    For döngüsü genellikle tekbir değişkenin değiştiği durumlarda kullanılır.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a,b;

    a=0;

    b=100;

    while (a!=b)

    {

    printf("ilk değer: \n"); scanf("%d", &a);

    printf("2.değer: \n"); scanf("%d", &b);

    }

    printf("Bu sayılar eşittir\n"); }



    Yukarıda verilen örneğin for döngüsü kullanılarak yapılması, bunun yazılması ve de

    anlaşılması daha zordur. While ile yapılan program tercih edilir. Döngünün bitiş noktasının program yazılırken bilindiği uygulamalarda for döngüsü kullanılır.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int a,b;

    for (a=0, b=100;a!=b)

    {

    printf("ilk= %d\n"); scanf("%d", &a);

    printf("ikinci= %d\n"); scanf("%d", &b);

    }

    printf("Bu sayılar eşittir\n");

    }



    ÖRNEK



    for(i=0;i<10;i++)



    Bu döngü tam olarak 10 defa işletilir ve yalnızca döngü tümcesine bakılarak bu durum

    anlaşılabilir. While döngüleri genellikle koşul değişkenlerinin bir kaç değişik şekilde

    değiştirilebildiği durumlarda kullanılır.



    while(i<10 && ch!=’q’)



    Bu döngünün kaç defa işletileceği ancak döngü içindeki tümcelere bakılarak anlaşılır.



    DO DÖNGÜSÜ



    Do döngüsü for ve while döngüsünde kontrol edilen bitiş koşullarını döngü tümceleri işletildikten sonra kontrol eder. Bunun en önemli etkisi bir do döngüsündeki tümcelerin en az bir kez işletilmesidir. Genel kullanımı şöyledir;



    do

    blok;

    while (koţul);



    While döngüsünde olduğu gibi blok içindeki tümceler koşul doğru olduğu sürece iţletilirler. Koţul kontrol edilmeden önce blok içindeki tümceler bir defa iţletilir.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int ch;

    do

    {

    printf("Bitirmek için q’ya basın:\n");

    ch=getch( ); }

    while(ch!=’q’);

    printf("döngü bitti\n"); }



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    do

    {

    printf("bitirmek için q’ya basınız\n");

    }

    while(getch( )!=’q’);

    printf("döngü bitti\n"); }



    FONKSİYONLAR



    Programın farklı yerlerinde benzer işlemler yapılması gerekiyorsa gerekli komutlar tekrarlanmalıdır. Fonksiyonlar bu konuda yardımcı olurlar. Fonksiyonlar programınızı ayrı ve kolay anlaşılabilir parçalara bölmenize olanak sağlarlar.



    FONKSİYON BİLDİRİMLERİ



    Bütün fonksiyonlar iki parçadan oluţurlar;



    · bildirim

    · gövde



    Basit bir fonksiyon bildirimi olan main( )’i gördük. Bunu izleyen blok, main( ) fonksiyonunun gövdesidir.



    Fonksiyonların genel sintaksı aşağıdaki gibidir.



    tip fonksiyon_ismi (parametre1, parametre2, ..., parametreN)

    parametre bildirimleri;

    blok;



    Tip fonsiyonun verceği değerin tipini gösterir.



    ÖRNEK

    # include <stdio.h>

    merhaba_de( )

    {

    printf("Merhaba\n");

    printf("Bu bir fonksiyon ile yazıldı\n");

    }

    main( )

    {

    printf("Bir defa çağır\n");

    merhaba_de( );

    printf("Bir kaç defa çağır\n");

    merhaba_de( );

    merhaba_de( );

    }



    Fonksiyon bildirimi main( ) fonsiyonundan önce yapılmıştır. Fonksiyon yalnızca fonksiyon ismi, parantezler ve bir ;’den oluşan tek bir tümce kullanılarak çağrılabiliyor.



    Derleyici ;’ fonksiyon bildirilerini fonksiyon çağrılarından ayırmak kullanır.



    RETURN TÜMCESİ



    Bir fonksiyondan kendisini çağıran programa geri dönmek için return tümcesi kullanılır. Return’u herhangi bir terim izleyebilir.



    Return (terim)

    şeklindedir. Çağıran fonksiyon gerekirse gönderilen terimi göz ardı edebilir.



    int toplam(a, b)

    int a,b;

    {

    int c;

    c=a+b;

    return c; }



    Bu program ana programdan iki değer alır (a ve b) bunlar toplanır ve sonuç c’ye yerleştirilir. Sonra fonksiyon bu sonucu ana programa göndererek fonksiyonu sona erdirir.



    PARAMETRELER



    Parametre program ile fonksiyon arasında bilgi aktarmakta kullanılan özel bir değişkendir. Parametre tanımlamaları fonksiyon isminden hemen sonra tanımlanır. Fonksiyon isminden önce tip bildirimi yapılır, bu fonksiyonun ana programa hangi tipte değer göndereceğini belirtir.



    Herhangi bir değer vermeyen bir fonksiyonun tipi void olarak bildirilir. Bir fonksiyonun gönderdiği değerleri kullanabilmek için bir değişkeni fonksiyonun ismine eşitlemek gerekir.



    ÖRNEK

    # include <stdio.h>

    int toplam(a, b)

    int a, b;

    {

    int c;

    c=a+b;

    return c;

    }

    main( )

    {

    int a;

    a=toplam(3, 4);

    printf("toplam= %d\n", a);

    }



    Bir bildirimde tip belirtilmezse C int tipi bir değer istediğimizi varsayar. Bununla birlikte bazı hatalarla karşılaşmamak için tip belirtilmelidir.



    Fonksiyon bir değer vermesini istemiyorsanız void sözcüğünü kullanmalısınız.



    YEREL DEĞİŞKENLER



    Yukarıdaki örnekte toplam( ) fonksiyonundaki a, main( )’deki a’dan farklıdır. Çünkü a yerel bir değişkendir. Bu değişken ve parametreler yalnızca bildirdikleri fonksiyonun içinde tanınabilirler. Hiç bir fonksiyon başka bir fonksiyonun içinde bildirilen parametre ve değişkenleri tanıyamaz. Bu nedenle bir programda aynı isimde birden fazla değişken kullanılabilir.



    PROTOTİP



    Prototip TURBO C’ye fonsiyonun formatını gösterir. C’de bunu kullanır ve fonksiyon çağrısı yapılmadan önce bütün değerlerin uygun tiplerine çevrilmelerini sağlar. Bildirim şekli şöyledir;



    tip fonsiyon_ismi(tip,tip, ...,tip);



    Bir bildirimden farklı olarak prototipin sonuna bir noktalı virgül konulmalıdır.



    İnt toplam(int, int);

    gibi



    ÖRNEK

    # include <stdio.h>

    int toplam(int,int);

    int toplam(a,b)

    int a,b;

    {

    int c;

    c=a+b;

    return c; }

    main( )

    {

    int a;

    a=toplam(3.1,4.2);

    printf("a’nın değeri= %d\n", a);

    }





    parametre kullanmayan fonksiyonlar için



    void merhaba_de(void);



    şeklinde prototip tanımlanır.



    İÇ İÇE FONKSİYONLAR



    # include <stdio.h>

    int toplam(int,int);

    void bekle(void);

    toplam(a,b)

    int a,b;

    {

    int c;

    printf("%d ile %d toplanacak\n",a,b);

    bekle( );

    c=a+b;

    return c;

    }

    void bekle(void)

    {

    printf("Devam etmek için herhangi bir tuşa basın\n");

    getch( );

    }

    main( )

    {

    int x,y;

    y=5;

    x=toplam(4,y);

    printf("sonuç=%d\n",x);

    }



    DİZİLER



    Dizi aynı ad altında toplanmış ve aynı tipte olan değişkenlerin sıralı bir listesidir. C’de bir dizi için bildirim yapılırken kullanılan genel kural şudur.



    tip dizi_ismi[eleman_sayısı];



    Bütün diziler 0 ile baţlar.



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int sayı_listesi[10]; /* 10 tamsayı içieren bir dizi */

    sayı_listesi[4]=823;

    sayı_listesi[0]=38;

    printf("eleman %d : %d\n",4,sayı_listesi[4]);

    pirntf("eleman %d : %d\n",0,sayı_listesi[0]);

    }



    ÖRNEK

    # include <stddio.h>

    main()

    {

    int i, tpl;

    int a[10], b[10], c[10];

    for (i=0;i<=9;i++)

    a=b=c=0;

    tpl=0;

    for (i=0;i<=9;i++)

    {

    a=i;

    b=i*i;

    c=2*a+b;

    tpl=tpl+c;

    }

    printf (" sayi karesi 2*sayi+karesi \n");

    for (i=0;i<=9;i++)

    printf("%8d %8d %8d \n", a,b,c);

    printf(" toplam =%d \n",tpl);

    }



    ÖRNEK

    # include <stddio.h>

    int i;

    int kare[21];

    {

    for (i=1;i<=20;i++)

    kare=i*i

    }



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    int i;

    float sonuc[10];

    printf("10 tane reel sayı girin\n");

    for (i=0;i<10;i++);

    {

    printf("No %d:",i+1);

    scanf("%f, &sonuç);

    }

    printf("sayılar girildi\n");

    printf("sonuç için 1 ile 10 arasında bir sayı\n");

    printf("çıkış için 0 yazın\n);

    do

    {

    printf(":"); scanf("%d", &i);

    if (i>0 && i<11) /* geçerli bir eleman (1-10) */

    printf("Eleman %d, %f içeriyor\n", i, sonuç[i-1]); /* elemanlar 0 ile 9 arasında */

    }

    while (i!=0)

    }



    KARAKTER DİZGİLERİ



    Bir sözcük veya tümceyi bir değişkende saklamak istediğimizde bunu yapmanın bir yolu tümceyi bir karakter dizisine yerleştirmektir.



    Bir dizgi, bir dizi olduğu için = işareti kullanılamaz.



    Bir dizgiyi bir karakter dizisinden diiğerine taşımak için dizgi kopyalama fonksiyonu olan strcpy( )’yi kullanmak gerekir. Bu fonksiyonun iki parametresi vardır. Kaynak dizgisi ve hedef dizgisi.



    char hedef[80];

    char kaynak[80];

    strcpy (hedef,kaynak);



    ÖRNEK

    # include <stdio.h>

    main( )

    {

    char dizgi1[80], dizgi2[80];

    printf("lütfen bir dizgi girin\n:");

    scanf("%s", &dizgi1);

    printf("bu dizgi2’ye aktarılıyor\n");

    strcpy(dizgi2, dizgi1);

    printf("Dizgi %s\n", dizgi2);

    }



    NOT :Bir dizi aynı ad altında bir araya gelmiş olan bir grup değişkenden oluşur. Dizinin her bir değerine elman adı verilir. Bir elemanı belirtmek için kullanılacak sayı pozitif bir tam sayı olmalıdır ve bu elemanın içerdiği değer herhangi bir tipte olabilir.



    MATRİS İLE İLGİLİ ÖRNEK:



    # define sira 3

    # define kolon 3

    # include <stdio.h>

    main()

    {

    int i, j, k, katsayı;

    int matris [sira][kolon];

    for (i=0;i<sira;i++)

    for (j=0;j<kolon;j++)

    matris[j]=0;



    for (i=0;i<sira;i++)

    {

    j=0;

    while (j<kolon)

    {

    printf("matris[%d][%d]=",i,j);

    scanf("%d",&katsayi);

    if (katsayi<0)

    break;

    matris[j]=katsayi;

    j++;

    }

    }

    for (i=0;i<sira;i++)

    {

    for (j=0;j<kolon;j++)

    printf("matris[%d][%d]=%d",i,j,matris[j]);

    printf("\n");

    }

    }



    BREAK DEYİMİ



    C de döngüden çıkmak için kullanılır. Bilgisayar döngünün sonunu beklemeden, istenilen koşulun sağlandığını kabul ederek, bir sonraki satırdaki komutları işletir.



    for, while veya do..while döngülerinde kullanılır. if..else ile kullanılamaz.



    Örnekte, katsayi sıfırdan küçük olursa, o sıradaki diğer elemanların hep sıfır değeri alması istendi. Bu durumda break ile bilgisayar j döngüsünden çıkıp bir sonraki i değerini alarak işleme devam eder.



    ÖRNEK (CONTINUE deyimi) : C 'de continue "kaldığın yerden devam et", döngüyü tamamlayıncaya kadar devam et anlamındadır.



    # include <stdio.h>

    main()

    {

    int i, j;

    int a[5];

    for (i=0;i<5;i++)

    a=0;

    for (i=0;i<5;i++)

    scanf("%d",&a);

    for (i=0;i<5;i++)

    {

    if ( a<0)

    continue;

    printf("%d TAMAM \n", a[j]);

    } }



    Bu örnekte, eğer a[j] değeri sıfırdan küçükse döngünün sonuna, yani { işaretine kadar gitmeden başa dön, j nin bir sonraki değerini alarak işleme devam et denmektedir.



    program çalıştırıldığında; 11 -22 33 -44 55 değerleri girilirse

    11 TAMAM

    33 TAMAM

    55 TAMAM

    çıktısı elde edilir.



    ÖRNEK : Enter tuşuna basıncaya kadar verilen tüm karakterleri ASCII koduna çeviren program.



    # include <stdio.h>

    main()

    {

    int i;

    cahar c;

    for (i=0;(c=getchar())!='\n';++i)

    printf("%d \n",c);

    }



    ÖRNEK ( Özel operatörler ve ifadeler)



    # include <stdio.h>

    main()

    {

    int a, b, i;

    for (i=0;i<=10;i++)

    a=a+i;

    printf("toplam a nın değeri = %d \n",a);



    for (i=0;i<=10;i++)

    b+=i;

    printf("toplam b nin değeri = %d \n", b);

    }



    Bu örnekte a=55 ve b=55 değeri elde edilir.



    Genel olarak x=x+y yerine x+=y yazılabilir. Yani,

    x=x op y yerine x op =y komutu yazılabilir.

    Örneğin;

    x=x*(y+1) yerine x *=(y+1) yazılabilir.

    ÖRNEK toplamını a, b, n 'in çeşitli değerleri için hesaplanacağını düşünüp bunun için bir fonksiyon yazalım.



    # include <stdio.h>

    main()

    {

    double seri();

    int i;

    for (i=1;i<=5;++i)

    printf("%d %1.6f %1.6f %1.6f \n", i, seri(1,i,0), seri(2,i,1));

    }

    double seri(a,n,b)

    int a,n,b;

    {

    double s, r;

    int j;

    r=0;

    s=0;

    for (j=1;j<=n;++i)

    {

    r=a*j-b;

    s=s+(1/r);

    }

    return(s);

    }



    ÖRNEK (Kısaltılmış if)



    # include <stdio.h>

    main()

    {

    int i; float a, b, z;

    a=4; b=1.5; z=0;

    for (i=0; b<=a+100.0; i++)

    {

    a=(a+7.3)*i;

    b=(b+1.0)*(i+1.0);

    if (a>b)

    z=a;

    else

    z=b;

    printf(%12.7f \n", z); } }



    NOT : C ' de mümkün olan diğer bir kısaltma da if ... else deyimlerinde ? işaretinin operatör olarak kullanılmasıdır. Yukarıdaki programın aynısı bu operatör kullanılarak aşağıda verilmiştir.



    # include <stdio.h>

    main()

    {

    int i; float a, b, z;

    a=4; b=1.5; z=0;

    for (i=0; b<=a+100.0; i++)

    {

    a=(a+7.3)*i;

    b=(b+1.0)*(i+1.0);

    z=(a>b) ? a: b;

    printf(%12.7f \n", z); } }

    Not: z=(a>b) ? a: b; ifadesinde önce (a>b) işelem konur, eğer true (yani pozitif, doğru) ise 2.parametre olan a işlem görür, yani z=a; daha sonra ise yani (a>b) değilse son parametre olan b işlem görüyor, yani z=b; olur.



    BAZI ÖNEMLİ MATEMATİK FONKSİYONLARI



    Eklenecek kütüphaneler:

    # include <math.h>

    # include <stdlib.h>



    radyan = acı*pi/180, x double tipli değişken



    sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), sinh(x), cosh(x), tanh(x), sech(x)



    **************************************************************



    sqrt(x) : x in karekökünü hesaplar



    log(x) : e tabanına göre logaritma alır (ln(x))



    log10(x) : 10 tabanına göre logaritma alır



    pow(x,y) : değerini hesaplar



    exp(x) : değerini hesaplar



    ceil(x) : x den küçük olmayan en küçük tamsayıyı hesaplar (tamdeğer)



    fabs(x) : x in mutlak değerini hesaplar



    fmod(x,y) : x/y oranında kalanı hesaplar.



    abs(x) : tamsayı olan x in mutlak değerini verir.



    labs(x) : long türünden olan x in mutlak değerini verir.



    max(x,y) : x, y nin enbüyüğünü bulur



    min(x,y) : x, y nin enküçüğünü bulur



    rand() : 0 ile 32767 arasında rasgele bir sayı seçer



    rand(x) : 0 ile x arasında rasgele bir sayı seçer



    randomize(); rasgele sayı için başlangıç değerini değiştirir

    ( <time.h> da eklenmelidir)



    ÖRNEK PROGRAMLAR



    *******************************************************************

    faktoryel hesaplayan program

    *******************************************************************

    #include<stdio.h>

    /* 1 den 100 e kadar olan sayilarin faktoriyeli */

    main()

    { int a,i;

    double f;

    f=1;

    clrscr();

    for (a=1;a<101;a++)

    { f=f*a;

    printf(" %d faktoriyel %f \n",a,f);

    i++;

    if (i>10)

    {i=1;

    getch(); }

    }

    getch();

    }





    **********************************************************************

    Asal sayıları bulan program

    **********************************************************************

    /* BIRDEN 2000 E KADAR ASAL SAYILARI BULAN PROGRAM */

    #include <stdio.h>

    #include <math.h>

    float tam(sayi)

    float sayi;

    {

    int i;

    i=sayi;

    return i+.0;

    }

    int asal(sayi)

    int sayi;

    {

    int i,sonuc;

    sonuc=1;

    for (i=2;i<sayi/2+1;i++)

    {

    if ((sayi+.0)/i==tam((sayi+.0)/i))

    {

    sonuc=0;

    i=sayi;

    }

    }

    if (sayi==-1 ||sayi==0||sayi==1) sonuc=0;

    return sonuc;

    }

    main()

    {

    int j;

    clrscr();

    for(j=2;j<2000;j++)

    if (asal(j)==1) printf("%4d",j);

    getch();

    }







    *******************************************

    e değerini hesaplayan program

    *******************************************

    #include <stdio.h>

    #include<math.h>

    double fakt(sayi)

    int sayi;

    {

    int i;

    double fak=1.0;

    for (i=1;i<sayi+1;i++)

    fak=fak*i;

    return fak;

    }

    double expu(x)

    float x;

    {

    int i;

    double e=0.0;

    for (i=0;i<41;i++)

    e=e+pow(x,i)/fakt(i);

    return e;

    }

    main()

    {

    float x;

    clrscr();

    printf("Exp i alinacak sayiyi giriniz..:");

    scanf("%f",&x);

    printf("Yaklaşık exp(%f)=%.20f\n",x,expu(x));

    printf("program fonksiyonu exp(%f)=%.20f",x,exp(x));

    getch();

    }





    *****************************************************

    Bazı betimsel istatistikleri hesaplayan program

    *****************************************************

    #include<stdio.h>

    #include<math.h>

    # define boyut 1000

    main()

    {

    int t,a,n,i,j;

    int dizi[boyut], max,min,gen;

    double var,ort,ss,med;

    int vr;

    clrscr();

    printf("dizi kac elemanli = ");

    scanf("%d",&n);

    printf("elemanlari girin \n ");

    for (i=1;i<n+1;i++)

    { printf(" %d",i);printf(".eleman=");

    scanf("%d",&dizi[i]);}

    /* siralama */

    for(i=1;i<n;i++)

    for(j=i+1;j<n+1;j++)

    if (dizi[i]>dizi[j])

    { a=dizi[i];

    dizi[i]=dizi[j];

    dizi[j]=a;

    }

    printf("SIRALI HALi.. ");

    for(i=1;i<n+1;i++)

    printf("%d ",dizi[i]);

    printf("\n");

    /* max min */

    max=dizi[n];min=dizi[1];gen=max-min;

    printf("maximum= %d \n",max);

    printf("minimum= %d \n",min);

    printf("orneklem genisligi= %d \n",gen);

    /* ortalama s.sapma varyans*/

    t=vr=0;ort=var=ss=0;

    for(i=1;i<n+1;i++)

    t=t+dizi[i];

    ort=t/n;

    for(i=1;i<n+1;i++)

    vr=vr+pow((dizi[i]-ort),2);

    var=vr/(n-1);

    ss=sqrt(var);

    printf("ortalama %f \n",ort);

    printf("varyans %f \n",var);

    printf("s.sapma %f \n",ss);

    printf("ortanca ");

    if (pow(-1,n)<0) med=dizi[(n+1)/2];

    else med=(dizi[n/2]+dizi[n/2+1])/2;

    printf("%f \n",med);

    getch();

    }







    *****************************************************

    program adi : kokbul.c

    Çeşitli fonksiyonların köklerini değişik yöntemlerle bulan program

    *****************************************************

    #include<stdio.h>

    #include<math.h>

    #include <conio.h>

    #include <stdlib.h>

    #include <graphics.h>



    int e=2.71182818;

    char *dizi[14];

    void aktar(void)

    {

    int sayac;

    int graphdriver=DETECT,graphmode;

    initgraph(&graphdriver,&graphmode,"");

    setbkcolor(1);

    setcolor(14);

    settextstyle (GOTHIC_FONT,HORIZ_DIR,1);

    setcolor(11);

    setlinestyle(0,0,3);

    settextstyle(DEFAULT_FONT,HORIZ_DIR,2);

    outtextxy(250,15,"SORULAR");

    gotoxy(1,1);printf("Selcuk Cobanoglu");

    gotoxy(4,2);printf("95052732");

    line(0,50,700,50);

    settextstyle(SMALL_FONT,HORIZ_DIR,7);



    dizi[1]=" X-SIN(X)-1=0 ";

    dizi[2]=" X-e^(-X)=0 ";

    dizi[3]=" X^3+10X-11.6=0 ";

    dizi[4]=" X*e^X-1=0 ";

    dizi[5]=" X^3-100=0 ";

    dizi[6]=" e^X-3*X=0 ";

    dizi[7]=" X*TAN(X)-0.5=0 ";

    dizi[8]=" COS(X)=3*X ";

    dizi[9]=" X^3-3X+1=1 ; Xo=1.5 ";

    dizi[10]=" e^X-LN(X)=20 ";

    dizi[11]=" e^X=(2*X)+21 ; Xo=3 ";

    dizi[12]=" LN(X)=1+1/(X^2) ";

    {

    settextstyle(SMALL_FONT,HORIZ_DIR,1);

    setcolor(1);

    for (sayac=1;sayac<13;sayac++)

    {

    gotoxy(30,4+sayac);printf("%d",sayac);printf(dizi[sayac]);

    printf("\n");

    }

    }

    }

    /******************************************/

    double fonk(double x,int fno)

    {

    double f1;

    switch(fno)

    {

    case 1:{f1= x-sin(x)-1;break;}

    case 2:{f1= x-pow(e,-1*x);break;}

    case 3:{f1= pow(x,3)+10*x-11.6;break;}

    case 4:{f1= x*pow(e,x)-1;break;}

    case 5:{f1= pow(x,3)-100;break;}

    case 6:{f1= pow(e,x)-3*x;break;}

    case 7:{f1= x*tan(x)-0.5;break;}

    case 8:{f1= cos(x)-3*x;break;}

    case 9:{f1= pow(x,3)-3*x;break;}

    case 10:{f1= pow(e,x)-log(x)-20;break;}

    case 11:{f1= pow(e,x)-2*x-21;break;}

    case 12:{f1= log(x)-1-1/pow(x,2);break;}

    }

    return f1;

    }

    /************************************/

    double turev(double x,int fno)

    {

    double t1;

    switch(fno)

    {

    case 1:{t1= 1-cos(x);break;}

    case 2:{t1= 1+pow(e,-1*x);break;}

    case 3:{t1= 3*pow(x,2)+10;break;}

    case 4:{t1= pow(e,x)+x*pow(e,x);break;}

    case 5:{t1= 3*pow(x,2);break;}

    case 6:{t1= pow(e,x)-3;break;}

    case 7:{t1= tan(x)+x*(1+pow(tan(x),2));break;}

    case 8:{t1= -1*sin(x)-3;break;}

    case 9:{t1= 3*pow(x,2)-3;break;}

    case 10:{t1= pow(e,x)-1/x;break;}

    case 11:{t1= pow(e,x)-2;break;}

    case 12:{t1= 1/x+2/pow(x,3);break;}

    }

    return t1;

    }

    /************************************/

    double ifonk(double x,int fno)

    {

    double f1;

    switch(fno)

    {

    case 1:{f1= sin(x)+1;break;}

    case 2:{f1= pow(e,-1*x);break;}

    case 3:{f1= (11.6-pow(x,3))/10;break;}

    case 4:{f1= pow(e,-1*x);break;}

    case 5:{f1= 10/pow(x,0.5);break;}

    case 6:{f1= log(3*x);break;}

    case 7:{f1= atan(1/(2*x));break;}

    case 8:{f1= cos(x)/3;break;}

    case 9:{f1= pow(x,3)-3*x;break;}

    case 10:{f1= log(log(x)+20);break;}

    case 11:{f1= log(2*x+21);break;}

    case 12:{f1= pow(e,1+1/(x*x));break;}

    }

    return f1;

    }

    /************************************/

    void cevap(no,yontem)

    int no,yontem;

    {

    int sayac;

    float xx,x,x1,x2,eps;

    printf("Xo 'i Giriniz..:");

    scanf("%f",&xx);

    printf("Epsilon'u Giriniz");

    scanf("%f",&eps);

    printf("\n");

    if (yontem==1 && no!=10 && no!=12)

    {

    /***YARILAMA YONTEMI********/

    sayac=1;

    x1=-1*5;

    x2=5;

    x=(x1+x2)/2;

    printf("Xo=%f\n",x);

    while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)

    {

    if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;

    x=(x1+x2)/2;

    printf("X%d=%f\n",sayac,x);

    sayac++;

    }

    printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));

    }

    if (yontem ==2 && no!=10 && no!=6 && no !=12)

    {

    /***REGULA FALSI YONTEMI****/

    sayac=1;

    x1=-1*10;

    x2=5;

    x=(x1+x2)/2;

    printf("Xo=%f\n",x);

    while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)

    {

    if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;

    x=(x1*fonk(x2,no)-x2*fonk(x1,no))/(fonk(x2,no)-fonk(x1,no));

    printf("X%d=%f\n",sayac,x);

    sayac++;

    }

    printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));

    }

    if (yontem==3)

    {

    /*** NEWTON RAPSON YONTEMI***/

    sayac=1;

    x=xx;

    printf("Xo= %f\n",x);

    while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)

    {

    x=x-(fonk(x,no)/turev(x,no));

    printf("X%d= %.6f\n",sayac,x);

    x1=x;

    }

    printf("\nE%d=%.6f\n",sayac-1,ifonk(x,no));

    }

    if (yontem==4)

    {

    /***BASIT ITERASYON YONTEMI****/

    sayac=1;

    x=xx;

    printf("Xo= %f\n",x);

    while (-1*eps>=x-ifonk(x,no) || x-ifonk(x,no)>=eps)

    {

    x=fonk(x,no);

    printf("X%d= %.6f\n",sayac,x);

    }

    printf("\nE%d=%.6f\n",sayac-1,x-ifonk(x,no));

    }

    }

    /************************************/

    main()

    {

    int s,y;

    aktar();

    gotoxy(45,40);printf("Secenek Gir..:");

    scanf("%d",&s);

    gotoxy(50,50);printf(" \n YONTEMLER \n");

    gotoxy(50,51);printf("1 => YARILAMA\n");

    gotoxy(50,52);printf("2 => REGULA FALSI\n");

    gotoxy(50,53);printf("3 => NEWTON RAPSON\n");

    gotoxy(50,54);printf("4 => BASIT ITERASYON\n\n");

    gotoxy(50,55);printf("Secenek Giriniz..:");

    scanf("%d",&y);

    if (s>0 && s<14) cevap(s,y);

    getch();

    }







    ************************************

    matrislerle ilgili iţlem yapan program

    ************************************

    #include<stdio.h>

    /* matrislerin toplami max min toplami max-min satir top min olan sutun*/

    main()

    {

    int n;

    int ma[100][100],mb[100][100],mc[100][100];

    int i,j,k,s;

    int maxa,maxb,mina,minb,satir[100],sutun[100];

    int iza[100][100],izb[100][100],a[100],b[100];

    clrscr();

    printf("n= ");

    scanf("%d",&n);

    for (i=1;i<n+1;i++)

    for (j=1;j<n+1;j++)

    ma[i][j]=0;

    mb[i][j]=0;

    mc[i][j]=0;

    printf("A matrisi (nxn) \n");

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    scanf("%d",&ma[i][j]);

    printf("B matrisi (nxn) \n");

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    scanf("%d",&mb[i][j]);

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)



    mc[i][j]=ma[i][j]+mb[i][j];

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    printf("%d ",mc[i][j]);

    printf(" \n ");

    /* max - min bulma */

    maxa=ma[1][1];mina=ma[1][1];

    maxb=mb[1][1];minb=mb[1][1];

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    {if (maxa<ma[i][j]) maxa=ma[i][j];

    if (maxb<mb[i][j]) maxb=mb[i][j];

    if (mina>ma[i][j]) minb=ma[i][j];

    if (minb>mb[i][j]) minb=mb[i][j];}

    printf("a matrisinin en buyuk degeri= %d \n",maxa);

    printf("b matrisinin en buyuk degeri= %d \n",maxb);

    printf("a matrisinin en kucuk degeri= %d \n",mina);

    printf("b matrisinin en kucuk degeri= %d \n",minb);

    /* satir ve sutunda max min */

    for(i=1;i<100;i++)

    {satir[i]=0;sutun[i]=0; }

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    { satir[i]=satir[i]+ma[i][j];

    sutun[i]=sutun[i]+mb[j][i];}

    maxa=0;minb=0;

    maxa=satir[1];minb=sutun[1];



    for (i=1;i<n+1;i++)

    { if(maxa<satir[i]) maxa=satir[i];

    if(minb>sutun[i]) minb=sutun[i];}

    printf("toplami max olan a matrisi satiri= %d \n",maxa);

    printf("toplami min olan b matrisi sutunu= %d \n",minb);

    /* a ve b matirisinin kosegenleri */

    s=0;k=0;

    for(i=1;i<n+1;i++)

    {a[i]=ma[i][i];

    b[i]=mb[i][i];}



    printf("a matrisi kosegenleri \n");

    for(i=1;i<n+1;i++)

    { k=k+a[i];

    printf("%d \n",a[i]);}

    printf("kosegen toplami= %d \n",k);

    printf("b matrisi kosegenleri \n");

    for (i=1;i<n+1;i++)

    { s=s+b[i];

    printf("%d \n",b[i]); }

    printf("kosegen toplami= %d \n",s);

    /* matrisin transpozu*/

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    { iza[j][i]=ma[i][j];

    izb[j][i]=mb[i][j]; }

    printf("a nin izi \n");

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    printf(" %d ",iza[i][j]);

    printf("\n");

    printf("b nin izi: \n");

    for(i=1;i<n+1;i++)

    for(j=1;j<n+1;j++)

    printf(" %d ",izb[i][j]);



    getch();



    }









    ********************************

    52 lik kağıt destesini karıştıram program



    # include <stdio.h>

    # include <math.h>

    # include <stdlib.h>

    # include <time.h>



    int dizi[53];

    int sayi_cek()

    {

    int k,num;

    k=((rand()+.0)/32767)*4+1;

    num=((rand()+.0)/32767)*13+1;

    return k*100+num;

    }

    void kar(void)

    {

    int i,j,sayi;

    for (i=1;i<=52;i++)

    {

    sayi=sayi_cek();

    for (j=1;j<i;j++)

    if (sayi==dizi[j])

    {

    j=i;

    i=i-1;

    }

    if (j<i+2)

    {

    dizi[i]=sayi;

    }



    }

    }

    main()

    {

    int i,s,t,x,y;

    randomize();

    gotoxy(2,30);

    printf("Ahmet Ba§c￾");

    gotoxy(3,36);

    printf("95052714");

    clrscr();

    kar();

    x=5;

    y=4;

    for(i=1;i<=52;i++)

    {

    s=dizi[i];

    t=s/100;

    x=x+1;

    if (x>18)

    {

    x=6;

    y=y+20;

    }

    gotoxy(y,x);

    switch(t)

    {

    case 1:printf("%d=> Maca ",i);break;

    case 2:printf("%d=> Sinek ",i);break;

    case 3:printf("%d=> Kupa ",i);break;

    case 4:printf("%d=> Karo ",i);break;

    }

    if (s-t*100==1)

    printf("As "); else printf("%d ",s-t*100);

    }

    getch();

    }





    ***********************************

    ******* grafik ekran kullanımı**********

    ***********************************

    # include <stdio.h>

    # include <stdlib.h>

    # include <math.h>

    # include <graphics.h>

    main()

    {

    int x,y,i;

    int graphdriver=DETECT,graphmode;

    initgraph(&graphdriver,&graphmode,"");

    setbkcolor(0);

    setcolor(4);

    settextstyle (GOTHIC_FONT,HORIZ_DIR,9);

    outtextxy(70,100,"sim￾lasyon");

    setcolor(11);

    setlinestyle(0,0,5);

    x=getmaxx();

    y=getmaxy();

    rectangle(0,0,x,y);

    getch();

    cleardevice();

    setcolor(5);

    settextstyle(DEFAULT_FONT,HORIZ_DIR,6);

    outtextxy(200,25,"ANAMENš");

    line(0,100,700,100);

    settextstyle(SMALL_FONT,HORIZ_DIR,6);

    outtextxy(150,150,"[1]-DAGILIMLARDAN SAYI URETME");

    outtextxy(150,175,"[2]-DAGILIMLARIN GRAFIGI");

    outtextxy(150,200,"[3]-DAGILIMLARIN TABLOSU");

    outtextxy(150,225,"[4]-VERI GIRISI");

    outtextxy(150,250,"[5]-CIKIS");

    gotoxy(10,25);printf("SECIMINIZ ? ");

    getch();

    closegraph();

    }





    ****************************************************

    ******* rasgele hareket eden parçacığın simülasyonu*********

    ****************************************************

    # include <graphics.h>

    # include <math.h>

    # include <stdio.h>

    # include <stdlib.h>

    main ()

    {

    char ch;

    double l,x2,y2,x1,y1,alfa;

    int x,y,i,r1,r2;

    int graphdriver=DETECT,graphmode;

    initgraph(&graphdriver,&graphmode,"");

    x1=50.0;

    y1=50.0;

    setbkcolor(0);

    setcolor(7);

    settextstyle (GOTHIC_FONT,HORIZ_DIR,9);

    outtextxy(70,100,"sim￾lasyon");

    getch();

    cleardevice();

    setlinestyle(0,0,5);

    x=getmaxx();

    y=getmaxy();

    rectangle(0,0,x,y);

    i=1;

    while (i<3000)

    {

    r1=rand();

    alfa=r1/32767.0*6.48;

    r2=rand();

    l=r2/32767.0*10.0;

    y2=l*sin(alfa)+y1;

    x2=l*cos(alfa)+x1;

    line(x1+50,y1+50,x2+50,y2+50);

    x1=x2;y1=y2;

    i++;

    }

    getch();

    closegraph();

    }







    ****************************************************

    /* Monte-Carlo intagrasyon yontemi ile f(x)=(1-x^2)^.5 */

    /* fonksiyonunun (0,1) araliginda yaklasik integralini bulur */

    ****************************************************

    # include <stdio.h>

    # include <math.h>

    main ()

    {

    int i,k;

    double z,alan,x,y;

    clrscr();

    i=0;

    k=0;

    for (i=1;i<=500;i++)

    {

    x=rand()/32767.0;

    y=rand()/32767.0;

    z=2.0;



    /* z=sqrt(1.0-x*x);*/

    if ( y <= z )

    k++;



    /* gotoxy(10,14);printf("N= %d",i);

    gotoxy(10,12);printf("k= %d",k);*/

    alan=(k*1.0)/(i*1.0);

    gotoxy(10,16);printf("alan= %2.9f",alan);

    }

    gotoxy(10,24);printf("cikis icin herhengi bir tusa basiniz");

    getch();

    }





    /*********************** */

    /*dusen bir topun gozlenmesi*/

    /*********************** */

    # include <graphics.h>

    # include <stdio.h>

    # include <math.h>

    main ()

    {

    double a,b,k,y1,li;

    float pi =3.14159654;

    int x,y,yuks ,iii, ex , ey ,ii,j, i,m,n;

    void gotoxy(int a, int b);

    int graphdriver=DETECT,graphmode;

    initgraph(&graphdriver,&graphmode,"");

    line (0,295,510,295);

    iii=0;

    x=0;

    y=0;

    yuks=250;

    a=pi/70.0;

    b=90*pi/180.0;

    k=.0014;

    for (i=1;i<200;i++)

    {

    /*cleardevice();*/

    line (0,295,510,295);

    iii=iii+3;

    y1=yuks*sin(a*iii+b)*exp(-k*iii);

    y1=300-abs(y1)-10;

    circle(x,y,5);

    circle(iii+20,y1,10);

    x=iii+20;

    y=y1;

    }

    getch();cleardevice();

    }





    ********************************************

    ********* normal dağılım için sayısal integral hesabı

    ********************************************

    # include <stdio.h>

    # include <math.h>

    main ()

    {

    int n1;

    double sonuc,a1,b1;

    double fonk();

    double integral();

    clrscr();

    a1=0.0;

    b1=1.0;

    n1=500;

    gotoxy(10,24);printf(".....lütfen bekleyiniz.........");

    sonuc=integral(a1,b1,n1);

    gotoxy(10,10);printf("sonu‡ = %4.9f \n",sonuc);

    getch();

    }

    double integral(double a,double b, int n)

    {

    double x1,h,integ,integ1,integ2;

    int i;

    h=(b-a)/n*1.0;

    integ1=0.0;

    integ2=0.0;

    integ=0.0;

    for (i=1;i<=n;i=i+2)

    {

    x1=a+i*h*1.0;

    integ1=integ1+4.0*fonk(x1);

    integ2=integ2+2.0*fonk(x1);

    integ=integ1+integ2+fonk(a)+fonk(b);

    integ=integ*h/3.0;

    }

    return(integ);

    }

    double fonk(double x)

    {

    double y;

    y=0.39904*exp(-0.5*pow(x,2.0));

    return(y);

    }





    ********************************************************

    ******** kolmogorov smirnov uyum-iyiliği testi üstel dağılım*******

    ********************************************************

    # include <stdio.h>

    # include <stdlib.h>

    # include <math.h>

    # include <conio.h>

    # define BOYUT 200

    main()

    {

    double ustel();

    double uretme();

    void swap (double *, double *);

    double dizi[BOYUT];

    double dizi1[BOYUT];

    double dizid[BOYUT];

    double dizif[BOYUT];

    double ddeger[BOYUT];

    double levo;

    int n,teta,i;

    n=5;

    teta=9;

    clrscr();

    { for(i=1;i<=n;i++)

    { dizi[i]=0.0;

    dizi1[i]=0.0;

    dizid[i]=0.0;

    dizif[i]=0.0; }}

    ddeger[4]=.565;

    ddeger[5]=.509;

    ddeger[6]=.468;

    ddeger[7]=.436;

    ddeger[8]=.410;

    ddeger[9]=.387;

    ddeger[10]=.369;

    ddeger[11]=.352;

    ddeger[12]=.338;

    ddeger[13]=.325;

    ddeger[14]=.314;

    ddeger[15]=.304;

    ddeger[16]=.295;

    ddeger[17]=.286;

    ddeger[18]=.279;

    ddeger[19]=.271;

    ddeger[20]=.265;

    ddeger[21]=.259;

    ddeger[22]=.253;

    ddeger[23]=.247;

    ddeger[24]=.242;

    ddeger[25]=.238;

    ddeger[26]=.233;

    ddeger[27]=.229;

    ddeger[28]=.225;

    ddeger[29]=.221;

    ddeger[30]=.218;

    ddeger[31]=.214;

    ddeger[32]=.211;

    ddeger[33]=.208;

    ddeger[34]=.205;

    ddeger[35]=.202;

    ddeger[36]=.199;

    ddeger[37]=.196;

    ddeger[38]=.194;

    ddeger[39]=.191;

    ddeger[40]=.189;



    clrscr();

    uretme(dizi,n,teta);

    sirala(dizi,n);



    yaz(dizi,n);



    for(i=1;i<=n;i++)

    { dizi1[i]=(i*1.0)/n*1.0; }



    for(i=1;i<=n;i++)

    { levo=dizi[i];

    dizif[i]=ustel(teta,levo);}



    for(i=1;i<=n;i++)

    { dizid[i]=dizif[i]-dizi1[i];

    if (dizid[i]< 0.0)

    dizid[i]=-1.0*dizid[i]; }



    sirala(dizid,n);

    getch();

    clrscr();



    gotoxy(2,10);printf("hesaplanan d değeri= %f",dizid[n]);

    if (n>40)

    ddeger[n]=1.22/sqrt(n);

    gotoxy(2,12);printf("tablo d değeri= %f",ddeger[n]);



    { if (dizid[n]>ddeger[n])

    { gotoxy(2, 15);printf("H0 red edilecek.....>");}

    else

    { gotoxy(2, 17);printf("******** H0 kabul edilecek.....>");}

    }

    getch();

    exit(0);

    }

    double uretme(sayi,n1,teta1)

    double sayi[];

    int n1, teta1;

    {

    int i;

    double x;

    for(i=1;i<=n1;i++)

    { x=rand();

    x=x/32767.0;

    x=-1.0*teta1*log(x);

    sayi[i]=x; } }



    void swap (double *a, double *b)

    { double temp;

    temp = *a;

    *a= *b;

    *b=temp; }



    sirala (sayi2,n2)

    double sayi2[];

    int n2;

    {

    int j,k;

    double l1,l2;

    for (j=1;j<=n2-1;j++)

    { for(k=j+1;k<=n2;k++)

    { if(sayi2[j]>sayi2[k])

    { l1=sayi2[j];

    l2=sayi2[k];

    swap (&l1,&l2);

    sayi2[j]=l1;

    sayi2[k]=l2;

    }}}}



    yaz (sayi3,n3)

    double sayi3[];

    int n3;

    { int i;

    for(i=1;i<=n3;i++)

    { printf("%f\n",sayi3[i]);} }



    double ustel(teta3,x)

    int teta3;

    double x;

    { double f0;

    f0=1.0-exp((-x*1.0)/(1.0*teta3));

    return(f0); }





    ************************************

    *** bölünmüţ faklar tablosu*************

    ************************************

    #include<stdio.h>

    #include<conio.h>

    #include<math.h>

    main()

    {

    float y,fx[100],f[100][100],x[100],c=1,p=0;

    int n,i,j;

    clrscr();

    printf("n=");scanf("%d",&n);

    printf("x=");scanf("%f",&y);

    for(i=0;i<=n;i++)

    {

    printf("x(%d),f(%d) :",i,i);scanf("%f,%f",&x[i],&fx[i]);

    }

    for(i=1;i<=n;i++) f[1][i]=(fx[i]-fx[i-1])/(x[i]-x[i-1]);



    for(i=2;i<=n;i++)

    {

    for(j=1;j<=(n-i+1);j++) f[i][j]=(f[i-1][j+1]-f[i-1][j])/(x[i-1+j]-x[j-1]) ;

    }

    p=fx[0];

    for(i=0;i<=(n-1);i++)

    {

    c*=(y-x[i]);

    p+=c*f[i+1][1];

    }

    for(i=1;i<=n;i++)

    {

    for(j=1;j<=n-i+1;j++)

    {

    gotoxy(i*10,n+4+j);printf("%f",f[i][j]);

    }

    }

    gotoxy(1,2*n+9);printf("polinom degeri :%f",p);

    getch();}

    ***********************************************

    ***********gregory newton formulu ****************

    ***********************************************

    #include<stdio.h>

    #include<math.h>

    #include<conio.h>

    main()

    {

    float x0,x,df[100][100],p,c=1,h,s;

    int i,j,n;

    clrscr();

    printf("n=");scanf("%d",&n);

    printf("x,x0,h :");scanf("%f,%f,%f",&x,&x0,&h);

    s=(x-x0)/h;

    printf("s=%f\n",s);

    getch();

    for(i=0;i<=n;i++)

    {

    printf("df[0][%d]=",i);scanf("%f",&df[0][i]);

    }



    for(i=1;i<=n;i++)

    for(j=0;j<=n-i;j++)

    {

    df[i][j]=df[i-1][j+1]-df[i-1][j];

    }

    p=df[0][0];

    for(i=0;i<=n-1;i++)

    {

    c*=(s-i)/(i+1);

    p+=c*df[i+1][0];

    }

    for (i=1;i<=n;i++)

    {

    gotoxy(i*11+1,n+7); printf("df[%d]",i);

    for (j=0;j<=n-i;j++)

    {

    gotoxy(i*11,n+8+j);printf("%f",df[i][j]);

    }

    }

    gotoxy(1,2*n+10); printf("polinomun de§eri:%f",p);

    getch();

    }





    ***********************************************

    /*INTERPOLASYON*/

    ***********************************************

    #include <stdio.h>

    main()

    {

    int i,j,n;

    float p=0,l[100];

    float y,x[100],fx[100];

    clrscr();

    printf("n=");scanf("%d",&n);

    printf("x=");scanf("%f",&y);

    for(i=0;i<=n;++i)

    {

    printf("x(%d),fx(%d) :",i,i);scanf("%f,%f",&x[i],&fx[i]);

    }

    for(i=0;i<=n;i++)

    {

    l[i]=1;

    for(j=0;j<=n;j++)

    {

    if(i!=j) l[i]*=(y-x[j])/(x[i]-x[j]);

    }

    p+=l[i]*fx[i];

    }

    printf("Polinom degeri=%f",p);

    getch();



    }





    ***********************************************

    /* denklem sistemleri ICIN BASIT ITERASYON YONTEMI*/

    ***********************************************

    #include<stdio.h>

    #include<stdlib.h>

    #include<math.h>

    #define g1(a) (.5*cos(a))

    #define g2(b) (.5*sin(b))

    main()

    {

    float f1,f2,x0[3],x1[3],temp[3],eps;

    int n=0,i;

    clrscr();

    for(i=1;i<=2;++i)

    {

    printf("x0(%d)=",i);scanf("%f",&x0[i]);

    }

    printf("eps=");scanf("%f",&eps);

    do

    {

    x1[1]=g1(x0[2]);

    x1[2]=g2(x0[1]);

    temp[1]=x0[1];temp[2]=x0[2];

    x0[1]=x1[1];

    x0[2]=x1[2];

    f1=fabs(x1[1]-temp[1]);

    f2=fabs(x1[2]-temp[2]);

    n++;

    }while(max(f1,f2)>eps);

    printf("ad￾m say￾s￾=%d\n",n);

    printf("kok=%f,%f",x1[1],x1[2]);

    getch();

    }





    ***************************

    Üç boyutlu grafik çizen program

    ***************************

    # include <graphics.h>

    # include <stdio.h>

    # include <math.h>

    # include <dos.h>



    main ()

    {

    double yy;

    int y,artim,j,i,x;

    double a[21] [21];

    void gotoxy(int a, int b);

    int graphdriver=DETECT,graphmode;

    initgraph(&graphdriver,&graphmode,"");

    setbkcolor(0);

    settextstyle(1,0,5);

    outtextxy(1,1,"GRAFIK PROGRAMI");

    {

    for (j=-10;j<10;j++)

    {

    for (i=-10;i<10;i++)

    {

    yy=200+sin(j)*cos(i)*12;

    a [j+11] [i+11]=yy;

    }

    }

    }

    {

    setcolor(2);

    for (j=1;j<20;j++)

    {

    for (i=1;i<20;i++)

    {

    artim=a[i][j];

    x=(i*10)+50+(j*5);

    y=(j*4)+30+artim/1.1;

    if (i==1)

    {

    moveto(x,y);

    line(x,y,x,y);

    }

    else

    lineto(x,y);

    }

    }

    }

    {

    setcolor(4);

    for (i=1;i<20;i++)

    {

    for (j=1;j<20;j++)

    {

    artim=a[i][j];

    x=(i*10)+50+(j*5);

    y=(j*4)+30+artim/1.1;

    if (j==1)

    {

    moveto(x,y);

    line(x,y,x,y);

    }

    else

    lineto(x,y);

    }

    }

    }

    getch();cleardevice();

    closegraph();

    }[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i]
     
    Tags:

Bu Sayfayı Paylaş

  1. Bu site çerezler kullanır. Bu siteyi kullanmaya devam ederek çerez kullanımımızı kabul etmiş olursunuz. Daha Fazla Bilgi.
  1. Bu site çerezler kullanır. Bu siteyi kullanmaya devam ederek çerez kullanımımızı kabul etmiş olursunuz. Daha Fazla Bilgi.
Yükleniyor...