Created
November 24, 2012 20:30
-
-
Save selimssevgi/4141304 to your computer and use it in GitHub Desktop.
Matrix Operations
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// a program which contains possible operations can be made on matrices | |
// 231112 | |
// Girilen bir matris sabit bir sayiya boluneceginden float deger üretebilir.Ama butun tanımlamar int, | |
// o yüzden matrisi sabit bir sayiya bolme islemi eklenmedi! | |
#include <stdio.h> | |
#include <stdlib.h> | |
// Global Variables | |
// firstMatris ~ matrix[0] , secondMatris ~ matrix[1], resultMatris ~ matris[2] | |
// determinant hesaplanırken derinlik 5x5 iken 3'e kadar gidiyor.5 seçmemiz simdilik yeterli. | |
int** matrix[5]; // Matrisleri point eden pointerları tutacaz. | |
// program menusu, baslangıcta kullanıcıyı karsılıyor. | |
int printMenu(); | |
// her matrisin row ve col sayısını bir artıyorum.Her matris beraberinde satır ve sutun sayısını da tasısın diye | |
// sadece tek row eklemek yeterlı olabilirdi.Ancak matrisler arasındaki islemlerin uygulanabilirliği için | |
// satir ve sutun sayilarini 1 den baslatmamız daha uygun | |
// artırımdan sonra bellek ayırıyor | |
// sonra da row ve col bilgilerini [0][0] ve [0][1] sakliyor. | |
int** allocateMatrix(int, int); | |
// Yapılacak her islem sonrasında ya da hata durumlarında ayrılan memory i serbest bırak. | |
void freeAll(); | |
// baslangıc adresi parametre olarak verilen matrisi, matris yapısında ekrana yazıyor. | |
void printMatrix(int**); | |
// Başlangıc noktası verilen matrisin elemanlarını kullanıcıdan alıyor | |
// boyutları zaten matrisin icinde.for dongusunun sınırlarına dikkat! | |
void getMatrixElement(int**); | |
// Yapılacak işlem icin gereken matris sayisi parametre olarak aktırılıyor | |
// fonksiyon içerisinde matris icin yer ayırımı ve matris degerlerini almak | |
// icin diğer fonksiyonlar da cagiriliyor | |
void getMatrixSize(int); | |
// yapacagımız isleme göre sonuc matrisimizin boyutları bellidir | |
// Bunun için degisik durumlara gore row ve col hesaplanıp allocateMatris ile yer ayrılıyor. | |
void calSizesOfResultMatrix(int); | |
// kullanıcıdan aldıgımız matrisler global matrix dizisini kullanarak ulaşabileceğimiz | |
// için aktarmaya genel olarak gerek yok. | |
void add(); | |
void sub(); | |
void transpose(); | |
void mulWithConstant(); | |
void multiple(); | |
int determinant(int** , int ); | |
int main(){ | |
int operation; | |
char devam='e'; | |
while( devam == 'e' || devam == 'E' ){ | |
freeAll(); | |
printf("\n"); | |
operation = printMenu(); | |
switch( operation ){ | |
case 1: // toplama islemi | |
getMatrixSize(2); // iki matris gerekiyor | |
if( matrix[0][0][0] != matrix[1][0][0] || matrix[0][0][1] != matrix[1][0][1] ){ | |
printf("HATA : toplama ve cikarma icin iki matrisin satir ve sutun sayiları esit olmalı!\n"); | |
continue; | |
} | |
add(); | |
printf("Verilen iki matrisin toplamı : \n"); | |
break; | |
case 2: // cikarma islemi | |
printf("\n BILGILENDIRME : Birinci matristen ikinci matris cikartilacaktir.\n"); | |
getMatrixSize(2); // 2 matris gerekiyor | |
if( matrix[0][0][0] != matrix[1][0][0] || matrix[0][0][1] != matrix[1][0][1] ){ | |
printf("HATA : toplama ve cikarma icin iki matrisin satir ve sutun sayiları esit olmalı!\n"); | |
continue; | |
} | |
sub(); | |
printf("1.Matristen 2.matrisin cikarilmasiyla olusan matris :\n"); | |
break; | |
case 3: // Sabit ile carpma | |
getMatrixSize(1); | |
// Herhangi bir kontrole gerek yok | |
mulWithConstant(); | |
printf("\nMatrisin sabit ile carpilmis hali : \n"); | |
break; | |
case 4:// determinant, bir matris lazim. | |
getMatrixSize(1); | |
if( matrix[0][0][0] != matrix[0][0][1] ){ | |
printf("HATA : determinantının alinması icin kare matris olmalı! \n"); | |
continue; | |
} | |
printf("Determinant : |A| : %d \n", determinant(matrix[0],0)); | |
// BU KISIMDA SORUN VAR! | |
break; | |
case 5:// Carpma islemi | |
getMatrixSize(2); | |
if( matrix[0][0][1] != matrix[1][0][0] ){ | |
printf("HATA : Carpma islemi icin 1.matrisin sutun sayisi \n 2.matrisin satir sayisina esit olmalı! \n"); | |
continue; | |
} | |
multiple(); | |
printf("Iki matrisin carpiminin sonucu : \n"); | |
break; | |
case 6: // Transpoze islemi | |
getMatrixSize(1); | |
// Herhangi bir kontrole gerek yok. | |
transpose(); | |
printf("Verilen matrisin transpozesi : \n"); | |
break; | |
case 0: | |
return 0; | |
break; | |
} // the end of switch | |
// Determinanta sayısal bir sonuc olustugu ıcın durumu farklı digerlerinde sonuc matrisi ekrana yazdiriliyor | |
if( operation != 4 ){ | |
//hesaplama isleminin sonucu hep matrix[2] nin gosterdiği yerde saklanacak. | |
printMatrix(matrix[2]); | |
} | |
getchar(); | |
printf("\nNew operation e/h? > "); | |
devam = getchar(); | |
} // the end of while | |
return 0; | |
}// the end of main | |
int printMenu(){ | |
int op; | |
printf("=== Matrix operations ===\n"); | |
printf("[1] - Toplama\n"); | |
printf("[2] - Cikarma\n"); | |
printf("[3] - Sabit ile Carpma\n"); | |
printf("[4] - Determinant\n"); | |
printf("[5] - İki matrisin carpimi\n"); | |
printf("[6] - Transpoze\n"); | |
printf("[0] - Exit\n"); | |
do{ | |
printf("\nHangi islemi yapmak istiyorsanız basindaki sayiyi giriniz > "); | |
scanf("%d", &op); | |
}while( op<0 || op>6 ); | |
return op; | |
} | |
int** allocateMatrix(int row, int col){ | |
int i; | |
int **matrixPointer; | |
// ilk satirda matrislerin boyutlarını saklıyor | |
row++; | |
col++; | |
// Matris icin memory allocation. | |
matrixPointer = (int**)malloc( row * sizeof(int*) ); | |
//Kontrol | |
if( matrixPointer == NULL){ printf("HATA : Gerekli alan ayrılamadi!."); exit(0); } | |
for( i=0; i<row; i++ ){ | |
matrixPointer[i] = (int*)malloc( col * sizeof(int) ); | |
// Kontrol | |
if( matrixPointer[i] == NULL){ printf("HATA : Gerekli alan ayrılamadi!."); exit(0); } | |
} | |
// Store matrix row and col info in its first row | |
matrixPointer[0][0] = row; | |
matrixPointer[0][1] = col; | |
return matrixPointer; | |
} | |
void printMatrix(int** theMatrix){ | |
int i,j; | |
for( i=1; i<theMatrix[0][0]; i++ ){ | |
printf("\n"); | |
for( j=1; j<theMatrix[0][1]; j++ ){ | |
printf(" %2d", theMatrix[i][j]); | |
} | |
} | |
printf("\n\n"); | |
} | |
void getMatrixElement(int** theMatrix){ | |
int i,j; | |
printf("\n"); | |
for( i=1; i<theMatrix[0][0]; i++ ){ | |
for( j=1; j<theMatrix[0][1]; j++ ){ | |
printf("[%d][%d] element : ", i,j); | |
scanf("%d", &theMatrix[i][j]); | |
} | |
} | |
} | |
void getMatrixSize(int numberOfMatrix){ | |
int i; | |
int row,col; | |
for( i=0; i<numberOfMatrix; i++ ){ | |
// Get size of the matrix | |
printf("\n%d.Matrisin Satir Sayisi > ", i+1); | |
scanf("%d", &row); | |
printf("\n%d.Matrisin Sutun Sayisi > ", i+1); | |
scanf("%d", &col); | |
// Allocate memory for the maxtrix | |
matrix[i] = allocateMatrix(row, col); | |
// Get value of the elements of matrix | |
getMatrixElement(matrix[i]); | |
printf("\n%d.Matris : \n", i+1); | |
printMatrix(matrix[i]); | |
} | |
} | |
void calSizesOfResultMatrix(int op){ | |
int row, col; | |
switch( op ){ | |
case 1: // toplama | |
case 2: // cikarma | |
case 3: // sabit ile carpma | |
row = matrix[0][0][0] - 1; // -1 because it will add 1 in the allocate function. | |
col = matrix[0][0][1] - 1; | |
break; | |
case 5: | |
row = matrix[0][0][0] -1; // Birincinin satir sayisi | |
col = matrix[1][0][1] -1; // ikinci matrisin sutun sayisi | |
break; | |
case 6: | |
row = matrix[0][0][1] - 1; | |
col = matrix[0][0][0] - 1; | |
break; | |
} | |
matrix[2] = allocateMatrix(row, col); | |
} | |
void add(){ | |
int i,j; | |
// buraya geldiğimde toplanacak matrislerin degerlerinin bilinmesi | |
// ve sonuc matrisi için yer ayrılmıs olması lazım | |
calSizesOfResultMatrix(1); // toplama | |
for( i=1; i<matrix[0][0][0]; i++ ){ | |
for( j=1; j<matrix[0][0][1]; j++ ){ | |
matrix[2][i][j] = matrix[0][i][j] + matrix[1][i][j]; | |
} | |
} | |
} | |
void sub(){ | |
int i,j; | |
// hesapla ve yer ayir. | |
calSizesOfResultMatrix(2); // cikarma | |
for( i=1; i<matrix[0][0][0]; i++ ){ | |
for( j=1; j<matrix[0][0][1]; j++ ){ | |
matrix[2][i][j] = matrix[0][i][j] - matrix[1][i][j]; | |
} | |
} | |
} | |
void transpose(){ | |
// sunuc matrisinin boyutu : transpoze alınırken row ve col sayısı degısır. | |
int i,j; | |
calSizesOfResultMatrix(6); | |
for( i=1; i<matrix[0][0][0]; i++ ){ | |
for( j=1; j<matrix[0][0][1]; j++ ){ | |
matrix[2][j][i] = matrix[0][i][j]; | |
printf("matrix[2][%d][%d] : %d\n", j,i,matrix[2][j][i]); | |
} | |
} | |
} | |
void mulWithConstant(){ | |
int i,j,con; | |
calSizesOfResultMatrix(3); | |
printf("\nEnter constant > "); | |
scanf("%d", &con); | |
for( i=1; i<matrix[0][0][0]; i++ ){ | |
for( j=1; j<matrix[0][0][1]; j++ ){ | |
matrix[2][i][j] = matrix[0][i][j] * con; | |
} | |
} | |
} | |
void multiple(){ | |
int i,j,k; | |
calSizesOfResultMatrix(5); | |
for( i=1; i<matrix[0][0][0]; i++ ){ | |
for( j=1; j<matrix[1][0][1]; j++ ){ | |
for( k=1; k<matrix[0][0][1]; k++ ){ | |
matrix[2][i][j] = matrix[2][i][j] + ( matrix[0][i][k] * matrix[1][k][j] ); | |
} | |
} | |
} | |
} | |
int determinant(int** theMatrix, int derinlik){ | |
int det=0,isaret= -1; | |
int newSat,newSut=1; | |
int sut,sat,i,j; | |
// base case | |
if( theMatrix[0][0] == 3 ){ | |
// 2x2 lık matrisin determinantı | |
det = theMatrix[1][1] * theMatrix[2][2] - theMatrix[2][1] * theMatrix[1][2]; // det = a*d - c*b | |
return det; | |
}else{ // recursive case | |
// Determinantı birinci satira göre alalim | |
sat = 1; | |
// Alt matrislerin tutulacagı bolgelerin alikasyonu | |
derinlik++; | |
// 3x3luk matriste 2x2lık alt matrisler olusur, bir de allocateMatrix fonk. artırımdan dolayı -1 = -2 | |
matrix[derinlik] = allocateMatrix(theMatrix[0][0]-2,theMatrix[0][1]-2); | |
for( sut=1; sut<theMatrix[0][1]; sut++ ){ // ilk satirdaki elemanların sırasıyla islenmesi | |
newSat=0; // Alt matrislerin satir sayisi | |
// Ana matristen alt matrislerin olusturulması | |
for( i=2; i<theMatrix[0][0]; i++ ){ // Det. birinci satire göre alındıgı ıcın 2 den basla | |
newSat++; | |
newSut = 1; // Aynı alt matris icin bir sonraki satir | |
for( j=1; j<theMatrix[0][1]; j++ ){ | |
if( sut == j ){ | |
continue; // det alınan satırdaki elemanların sutunların üstü ciziliyor.Alt matrise katmıyoruz. | |
} | |
matrix[derinlik][newSat][newSut] = theMatrix[i][j]; // Ana matristen alt matrisine eleman aktarımı | |
newSut++; | |
} | |
} | |
// Olusan her alt matrisi ekrana yazdirmak istersek : | |
// Matris boyutuna göre gidilecek derinliği görmek istiyorsak | |
// alta yorumlanmıs iki satirdan // kaldirilabilir. | |
//printf("Derinlik : %d \n", derinlik); | |
//printMatrix(matrix[derinlik]); | |
det = det + theMatrix[sat][sut] * isaret * determinant(matrix[derinlik], derinlik); // recursive call | |
isaret = isaret * (-1); // bir artı bir eksi olacak. | |
} // Determinant aldiğimiz satirin elemanlarını donderen for un sonu | |
return det; | |
} // matris boyutunu kontrol eden if in sonu | |
} | |
void freeAll(){ | |
int i; | |
for(i=0; i<5; i++){ | |
free(matrix[i]); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment