Z2.3: Moj matrix.h

U ovom zadatku cilj je napisati implementaciju funkcija deklariranih u matrix.h datoteci. Njihova implementacija piše se u matrix.c datoteci. Detaljno pročitajte komentare u svim datotekama postavljenim unutar VPL aktivnosti.

//Z1.C

/* U ovom zadatku trebate implementirati funkcije koje su deklarirane u
 * matrix.h datoteci, a koriste se u ovoj main funkciji. Ukoliko ispravno
 * implementirate deklarirane funkcije, kod u main() funkciji ce proci testove
 * bez ikakvog mijenjanja. Svu implementaciju koda pisete u matrix.c
 * datoteku. Kao sto vidite, u main() funkciji su pozivi funkcija koje ce
 * odraditi test caseove. Ima 8 testnih slucajeva i 8 funkcija u kojima je
 * kod prilagodjen za svaki testni slucaj. Funkcija case1() nije zakomentirana,
 * dok su preostale funkcije zakomentirane. Preporucujemo da kako implementirate
 * pojedine funkcije u matrix.c, postepeno odkomentirate i pozive test caseova
 * u main() funkciji, jer vam se tako program nece rusiti zbog jos neimplementiranih
 * funkcija u matrix.c.
 *
 * Ukoliko zelite, sve tri datoteke mozete skinuti i zadatak rijesiti i u nekom
 * drugom kompajleru (Visual Studio, DevCpp ili slicni).
 *
 * U ovom zadatku ne trazi se nikakvo upisivanje podataka u program, svi podaci
 * u matricama generiraju se slucajno. Zbog toga preporuka je program pokretati
 * klikom na RUN tipku, jer tako lakse mozete pratiti izvrsavanje programa.
 *
 * Implementacija NewRandomMatrix funkcije vam je zadana, isto kao i
 * implementacija funkcije za ispis matrice. Sve ostale funkcije trebate vi
 * implementirati.
 */
#include <stdio.h>
#include <stdlib.h>
#include "matrix.h"

/*
1.c matrix.c
*/

//deklaracije funkcija
void case1();
void case2();
void case3();
void case4();
void case5();
void case6();
void case7();
void case8();

int main(void) {
  //gasenje std bufferinga
  setvbuf(stdout, NULL, _IONBF, 0);

/* Odkomentirajte one testcaseove cije ste funkcije u matrix.c implementirali.
 * Kada je sve implementirano, odkomentirajte sve pozive test caseova i program
 * ce proci. U svakom test caseu mozete vidjeti koje se funkcije pozivaju. */

  case1();
  case2();
  case3();
  case4();
  case5();
  case6();
  case7();
  case8();

  return 0;
}

void case1() {
  srand(1000);
  double **M1, **M2;
  puts("->Kreiranje dvije prazne matrice: ");
  M1 = newMatrix(4,4 );
  M2 = newMatrix(4,4 );
  matrixPrint(M1, 4,4);
  matrixPrint(M2, 4,4);
  puts("");
}

void case2() {
  srand(1000);
  //kreiranje dvije random matrice u rasponu <1.0,2.0>
  double **M1, **M2;
  puts("->Kreiranje dvije random matrice: ");
  M1 = newRandomMatrix(4,4, 1.0, 2.0);
  M2 = newRandomMatrix(4,4, 1.0, 2.0);

  matrixPrint(M1, 4,4);
  matrixPrint(M2, 4,4);

  matrixDelete(M1,4,4);
  matrixDelete(M2,4,4);
  puts("");
}

void case3() {
  srand(1000);
  //mnozenje clan-po-clan dvije random matrice
  double **M1, **M2, **M3;
  M1 = newRandomMatrix(4,4, 1.0, 2.0);
  M2 = newRandomMatrix(4,4, 1.0, 2.0);

  puts("->Mnozenje clan po clan dvije matrice");
  puts("->Ulazne matrice:");
  matrixPrint(M1, 4,4);
  matrixPrint(M2, 4,4);

  puts("->Rezultat:");
  M3 = matrixElementwiseMultiply(M1,M2,4,4);
  matrixPrint(M3, 4,4);

  matrixDelete(M1,4,4);
  matrixDelete(M2,4,4);
  matrixDelete(M3,4,4);
  puts("");
}

void case4() {
  srand(1000);
  //zbrajanje dvije random matrice
  double **M1, **M2, **M3;
  M1 = newRandomMatrix(4,4, 1.0, 2.0);
  M2 = newRandomMatrix(4,4, 1.0, 2.0);

  puts("->Zbrajanje dvije matrice:");
  puts("->Ulazne matrice:");
  matrixPrint(M1, 4,4);
  matrixPrint(M2, 4,4);

  puts("->Rezultat:");
  M3 = matrixAdd(M1,M2,4,4);
  matrixPrint(M3, 4,4);

  matrixDelete(M1,4,4);
  matrixDelete(M2,4,4);
  matrixDelete(M3,4,4);
  puts("");
}

void case5() {
  srand(1000);
  //oduzimanje dvije random matrice
  double **M1, **M2, **M3;
  M1 = newRandomMatrix(4,4, 1.0, 2.0);
  M2 = newRandomMatrix(4,4, 1.0, 2.0);

  puts("->Oduzimanje dvije matrice:");
  puts("->Ulazne matrice:");
  matrixPrint(M1, 4,4);
  matrixPrint(M2, 4,4);

  puts("->Rezultat:");
  M3 = matrixSubtract(M1,M2,4,4);
  matrixPrint(M3, 4,4);

  matrixDelete(M1,4,4);
  matrixDelete(M2,4,4);
  matrixDelete(M3,4,4);
  puts("");
}

void case6() {
  srand(1000);
  double **M1, **M2, **Meye;
  M1 = newRandomMatrix(4,4, 1.0, 2.0);

  puts("->Kreiranje nove jedinicne matrice dimenzija 4:");
  puts("->Ulazne matrice:");
  Meye = newEye(4);
  M2 = matrixElementwiseMultiply(M1,Meye,4,4);
  matrixPrint(M1, 4,4);
  matrixPrint(Meye, 4,4);

  puts("->Ispis rezultata:");
  matrixPrint(M2, 4,4);

  matrixDelete(M1,4,4);
  matrixDelete(M2,4,4);
  matrixDelete(Meye,4,4);
  puts("");
}


void case7() {
  srand(1000);
  double **M1, **M2, **M3;
  M1 = newRandomMatrix(2,3, 1.0, 2.0);
  M2 = newRandomMatrix(3,4, 1.0, 2.0);

  puts("->Mnozenje dvije matrice (metoda matricnog mnozenja) - ispravne dimenzije:");
  puts("->Ulazne matrice:");
  matrixPrint(M1, 2,3);
  matrixPrint(M2, 3,4);

  puts("->Ispis rezultata:");
  M3 = matrixMultiply(M1, 2, 3, M2, 3,4);
  matrixPrint(M3, 2,4);

  matrixDelete(M1,2,3);
  matrixDelete(M2,3,4);
  matrixDelete(M3,2,4);
  puts("");
}

void case8(){
  srand(1000);
  double **M1, **M2, **M3;
  M1 = newRandomMatrix(2,4, 1.0, 2.0);
  M2 = newRandomMatrix(3,4, 1.0, 2.0);

  puts("->Mnozenje dvije matrice (metoda matricnog mnozenja) - neispravne dimenzije:");
  puts("->Ulazne matrice:");
  matrixPrint(M1, 2,3);
  matrixPrint(M2, 3,4);

  puts("->Ispis rezultata:");
  M3 = matrixMultiply(M1, 2, 4, M2, 3,4);
  matrixPrint(M3,2,4);
  puts("");
}

//FUNKCIJE
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "matrix.h"

/**** Implementirane funkcije - ove funkcije ne trebate mijenjati ****/
//funkcija print je vec implementirana, nju samo koristite.
void matrixPrint(double **X, int rows, int columns) {
  int i, j;
  printf("Matrix: %dx%d\n", rows, columns);
  if (X == NULL)
    puts("Matrix is NULL!");
  else {
    for (i = 0; i < rows; i++) {
      for (j = 0; j < columns; j++) {
        printf("%.2f\t", X[i][j]);
      }
      printf("\n");
    }
  }
  printf("\n");
}
//buduci da je srand() funkcija izvrsena u mainu, u ovoj funkciji se ne poziva.
//Primjetite kako ova implementacija funkcije koristi NewMatrix() funkciju, pa
//ispravan rad ove funkcije ovisi o ispravnom radu NewMatrix() funkcije.
double** newRandomMatrix( int rows, int columns, double low, double high) {
  double **data;
  int i,j;
  data = newMatrix(rows, columns);
  for (i = 0; i < rows; i++) {
    for (j = 0; j < columns; j++) {
      data[i][j] = (high - low)*((float)rand()/RAND_MAX) + low;
    }
  }
  return data;
}



/**** VAS KOD OVDJE: Sve ostale funkcije u ovom fileu trebate vi implementirati ****/
double** newMatrix(int rows, int columns) {
int i,j;
double **Matrix;

Matrix=(double**)malloc(rows*sizeof(double*));

for(i=0;i<rows;i++)
{
    for(j=0;j<columns;j++)
    {
        *(Matrix+i)=(double*)malloc(columns*sizeof(double));
    }
}

for(i=0;i<rows;i++)
{
    for(j=0;j<columns;j++)
    {
        Matrix[i][j]=0;
    }
}
return Matrix;
}



double** newEye(int n) {

int i,j;
double **IdMatrix;
IdMatrix=newMatrix(n,n);
for(i=0;i<n;i++)
{
    for(j=0;j<n;j++)
    {
        if(i==j)
        IdMatrix[i][j]=1;
    }
}
return IdMatrix;
}


double** newFromSTDIN(int rows, int columns) {
int i,j;
double **inputMatrix;
inputMatrix=newMatrix(rows, columns);
for(i=0;i<rows;i++)
{
    for(j=0;j<columns;j++)
    {
        scanf("%lf",&inputMatrix[i][j]);
    }
}
return inputMatrix;
}


void matrixDelete(double **X, int rows, int cols) {
int i;
    for (i = 0; i < rows; i++){
       free(X[i]);
    }
 free(X);
}


double** matrixMultiply(double** M1, int r1, int c1, double** M2, int r2, int c2) {
int i,j,k;
double **resultMatrix;
resultMatrix=newMatrix(r1,c2);
if(c1!=r2) return NULL;

for(i=0; i<r1; i++)
{
    for(j=0; j<c2; j++)
    {
        for(k=0; k<c1; k++)
        {
            resultMatrix[i][j]+=M1[i][k]*M2[k][j];
        }
    }
}
return resultMatrix;
}


double** matrixElementwiseMultiply(double** M1, double** M2, int rows, int columns) {
    int i,j;
    double **multMatrix;
    multMatrix=newMatrix(rows, columns);

    for(i=0;i<rows;i++)
    {
        for(j=0;j<columns;j++)
        {
            multMatrix[i][j]=M1[i][j]*M2[i][j];
        }
    }
return multMatrix;
}

double** matrixAdd(double** M1, double** M2, int rows, int columns) {
    int i,j;
    double **resultMatrix;
    resultMatrix=newMatrix(rows, columns);

    for(i=0;i<rows;i++)
    {
        for(j=0;j<columns;j++)
        {
            resultMatrix[i][j]=M1[i][j]+M2[i][j];
        }
    }
return resultMatrix;
}

double** matrixSubtract(double** M1, double** M2, int rows, int columns) {
    double **resultMatrix;
    int i,j;
    resultMatrix=newMatrix(rows, columns);

    for(i=0;i<rows;i++)
    {
        for(j=0;j<columns;j++)
        {
            resultMatrix[i][j]=M1[i][j]-M2[i][j];
        }
    }
return resultMatrix;
}

//HEADER
#ifndef MATRIX_H
#define MATRIX_H
// Ovo je potrebno samo za Visual studio
#define _CRT_SECURE_NO_WARNINGS


//Kreira novu matricu dimenzija predanih u parametrima, te vraca adresu
//te matrice. Unutar funkcije potrebno je dinamicki alocirati memoriju za
//podatke u matrici. Postaviti sve elemente matrice na 0.
double** newMatrix(int , int);

//Kreira novu matricu dimenzija predanih u prva dva parametra. Kreiranu matricu
//potrebno je popuniti slucajnim brojevima, gdje druga dva parametra
//predstavljaju minimalnu i maksimalnu vrijednost raspona unutar kojega ce biti
//kreirani slucajni brojevi. Buduci da je funkcija srand() pozvana na
//pocetku svakog testa casea, random generator je inicijaliziran pa ju nemojte
//pozivati u ovoj funkciji. Ako ju pozovete, moguce je da ce se generirani
//slucajni brojevi razlikovati od onih koje generira grader, pa vam nece
//prolaziti test caseovi
double** newRandomMatrix(int, int, double, double);

//Kreira novu jedinicnu matricu koja ce biti dimenzija predanih u parametru.
//Podsjetimo se: jedinicna matrica je kvadratna matrica koja ima sve clanove
//nula, osim onih na glavnoj dijagonali, koji imaju vrijednost 1.
double** newEye(int);

//Kreira novu matricu dimenzija predanih u parametrima, te trazi od korisnika
//upis vrijednosti elemenata matrice sa tipkovnice.
double** newFromSTDIN(int, int);


//Ispisuje predanu matricu na ekran. Implementacija ove funkcije vam je
//zadana u matrix.c, kako bi ispisi bili u obliku koji grader ocekuje.
void matrixPrint(double**, int rows, int cols);

//Oslobadja zauzetu memoriju predane matrice.
void  matrixDelete(double**, int rows, int cols);

//Obavlja mnozenje dvije matrice, te vraca novu matricu u kojoj se nalazi
//rezultat. Mnozenje je matricno, pa je potrebno ovisno o dimenzijama predanih
//matrica odrediti dimenzije matrice koju ce funkcija vratiti. Ukoliko su
//dimenzije predanih matrica takve da se matricno mnozenje ne moze izvrsiti,
//potrebno je vratiti NULL vrijednost.
double** matrixMultiply(double** M1, int r1, int c1, double** M2, int r2, int c2);

//Obavlja mnozenje dvije matrice na nacin da se mnoze medjusobno elementi na
//istim mjestima. To znaci da ce se mnoziti element na (1,1) sa elementom na
//(1,1) itd. Vratiti rezultantnu matricu. Dimenzije matrica moraju
//biti jednake
double** matrixElementwiseMultiply(double** M1, double** M2, int rows, int columns);


//Obavlja zbrajanje dvije matrice na nacin da se zbrajaju medjusobno elementi na
//istim mjestima. To znaci da ce se zbrajati element na (1,1) sa elementom na
//(1,1) itd. Vratiti rezultantnu matricu. Dimenzije matrica moraju
//biti jednake
double** matrixAdd(double** M1, double** M2, int rows, int columns);


//Obavlja oduzimanje dvije matrice na nacin da se oduzimaju medjusobno elementi
//na istim mjestima. To znaci da ce se od elementa na (1,1) oduzeti vrijednost
//elementa na (1,1).  Vratiti rezultantnu matricu. Dimenzije matrica moraju
//biti jednake
double** matrixSubtract(double** M1, double** M2, int rows, int columns);


#endif