Teknoloji Magazin Forumları

arkadaşlar c++ programında resmi ekleyip bu resmi okuyabilen bi program yazmam gerekiyor. bu okuma işlemi de önce resimlerin ebatı bulunacak sonra da matrise dönüştürülecek. yani matris şeklinde okunacak...yardım edebilirseniz çok sevinirim...teşekkürler

necker bilir ona sor

sana sadece matris işlemlerii söyleyebilirim bunu derlemek için biraz fırınlarda doşaıp ekmek yemen lzm gibime geldi )))


Matris ;

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <malloc.h>
#include <time.h>

Bunlar zaten biliosun anlatmama gerek yok ))

degisken boyutlu matris yani dinamik hani ) açmanin en kolay yolu.
normalinde dizileri sabit boyutlu açariz. nah buradaysa dizi
bellekte istenilen boyutta ve tipte açilip, silinebilir.
Örnek:
matrix_allocate(A, m, n, double)
(Not: Satir sonuna noktali virgül konulmamalidir ; yokkkk ; yokk)
Kullanim bilinen dizi sekilinde:
A[i][j]
dizinin bellekten atilmasi istenirse:
free(A[0]);
yazcas



*/
#define matrix_allocate(matrix, hsize, vsize, TYPE) { TYPE *imptr; int _i; matrix = (TYPE **)malloc((vsize)*sizeof(TYPE *)); imptr = (TYPE*)malloc((long)(hsize)*(long)(vsize)*sizeof(TYPE)); if (imptr == NULL) printf("\nNo memory in matrix allocate."); for (_i = 0; _i<vsize; ++_i, imptr += hsize) matrix[_i] = imptr; }




rutin işlemmimiz

C=AxB
matrisin boyuları bunnar:::A(ixj),B(jxk) ve C(ixk)



*/
void matrix_product(double **A,double **B,double **C,int i,int j,int k)
{
int x,y,z;
double sum;

for(x=0;x<i;x++)
for(y=0;y<k;y++)
{
sum=0;
for(z=0;z<j;z++)
sum+=A[x][z]*B[z][y];
C[x][y]=sum;
}
}

#define REAL double
double determ_ref;

/*


Matrisin tersini almayıda yrn yada gece yazarım elim kırıldı )) bunlar doğru ama derledimde yazdım walla )))))))

teşkürler

aferim sana ajanP

mısır?

wer ajan severim mısır ))şindi o mısırın matrisini ters düz edeyimde gör mısırda matris enteresan



#define REAL double
double determ_ref;

/*
mısırın tersi alan rutindir bu ))
Bu kod alıntıdır walla kendi dökümanlarımı bulamadım ama yararlı olur. Mat isimli matrisin tersini alip,
yine Mat içerisine yazar. Boyut mxm olmalidir.
*/
int matrix_inverse(double **Mat, int size)
{
int nrows=size, ncols=size;
double determinant = 1;
const double singularity_tolerance = 1e-35;

// Locations of pivots (indices start with 0)
struct Pivot { int row, col; } * const pivots =
(Pivot*)malloc(ncols*sizeof(Pivot));
bool * const was_pivoted = (bool*)alloca(nrows*sizeof(bool));
for(register int k=0; k<nrows; k++)
was_pivoted[k]=false;

for(register Pivot * pivotp = &pivots[0]; pivotp < &pivots[ncols]; pivotp++)
{
const REAL * old_ppos = 0; // Location of a pivot to be
int prow = 0, pcol = 0; // Pivot's row and column indices
{ // Look through all non-pivoted cols
REAL max_value = 0; // (and rows) for a pivot (max elem)
register const REAL *cp = Mat[0]; // column pointer
for(register int j=0; j<ncols; j++)
if( !was_pivoted[j] )
{ // the following loop would increment
REAL curr_value = 0; // cp by nrows
for(register int k=0; k<nrows; k++,cp++)
if( !was_pivoted[k] && (curr_value = fabs(*cp)) > max_value )
max_value = curr_value, prow = k, pcol = j, old_ppos = cp;
}
else
cp += nrows; // and this branch would too
if( max_value < singularity_tolerance )
{
printf("Matrix turns out to be singular: can't invert\n");
return -1;
}
pivotp->row = prow;
pivotp->col = pcol;
}

REAL * const old_colp = const_cast<REAL*>(old_ppos) - prow;
REAL * const new_colp = ( prow == pcol ? old_colp : Mat[0] + prow*nrows );
if( prow != pcol ) // Swap prow-th and pcol-th columns to
{ // bring the pivot to the diagonal
register REAL * cr = new_colp;
register REAL * cc = old_colp;
for(register int k=0; k<nrows; k++)
{
REAL temp = *cr; *cr++ = *cc; *cc++ = temp;
}
}
was_pivoted[prow] = true;

{ // Normalize the pivot column and
register REAL * pivot_cp = new_colp;
const double pivot_val = pivot_cp[prow]; // pivot is at the diagonal
determinant *= pivot_val; // correct the determinant
pivot_cp[prow] = 1;
for(register int k=0; k<nrows; k++)
*pivot_cp++ /= pivot_val;
}

{ // Perform eliminations
register REAL * pivot_rp = Mat[0] + prow; // pivot row
register REAL * ep = Mat[0]; // sweeps all matrix' columns
for(register int k=0; k<ncols; k++, pivot_rp += nrows)
if( k != prow )
{
const double temp = *pivot_rp;
*pivot_rp = 0;
register const REAL * pivot_cp = new_colp; // pivot column
for(register int l=0; l<nrows; l++)
*ep++ -= temp * *pivot_cp++;
}
else
ep += nrows;
}
}

int no_swaps = 0; // Swap exchanged *rows* back in place
for(register const Pivot * pvp = &pivots[ncols-1];
pvp >= &pivots[0]; pvp--)
if( pvp->row != pvp->col )
{
no_swaps++;
register REAL * rp = Mat[0] + pvp->row;
register REAL * cp = Mat[0] + pvp->col;
for(register int k=0; k<ncols; k++, rp += nrows, cp += nrows)
{
const REAL temp = *rp; *rp = *cp; *cp = temp;
}
}

determ_ref = ( no_swaps & 1 ? -determinant : determinant );
return 0;
}

Matrisi yzdırmak zaten kly ) biraz bkle onuda derliyimde yannışlık çıkmasın maçup olmayalım )))