Matrizes Completo em C - Rotaciona90,Espelhamento,Media Vizinhos, Multiplica,Soma

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

/* 
 * File: main.cpp
 * Author: joao
 * Ex 1-
 * a- Escreva uma função que recebe como parâmetros uma matriz real Anxm, 
 * e uma posição (i,j) da matriz, e calcula a média aritmética dos vizinhos de (i,j), 
 * ou seja, a média entre A[i-1][j], A[i+1][j], A[i][j-1] e A[i][j+1]. 
 * Desconsidere os vizinhos que não pertencem a matriz (por exemplo, os vizinhos de (0,0) 
 * são somente (0,1) e (1,0)).
 * b- Escreva uma função que recebe como parâmetro uma matriz real Anxm e devolve uma matriz Amédia, 
 * onde A média[i][j] é a média aritmética dos vizinhos de (i,j). Para isto, utilize a função do item anterior.
 * Ex 2-
 * a. vetor com os elementos da diagonal principal;
 * b. vetor com os elementos da diagonal secundária;
 * c. Matriz dos elementos acima da diagonal principal;
 * d. Matriz dos elementos abaixo da diagonal principal;
 * e. Matriz dos elementos acima da diagonal secundária;
 * f. Matriz dos elementos abaixo da diagonal secundária;
 * g. Rotacionar a MAtriz em 90°
 * h. Espelhamento da Matriz
 * i. Multiplicação de duas matrizes
 * j. Soma de duas matrizes
 * 
 */
#include <stdlib.h>
#include <stdio.h>
#include<math.h>
#include<time.h>
#define M 20
#define N 20
using namespace std;
//----------------------------------
void rotarcionar90(int matA[M][N], int matB[N][M], int m, int n) {
 int i, j, k = 0;
 for (j = n - 1; j >= 0; --j) {
 for (i = 0; i < m; ++i) {
 matB[k][i] = matA[i][j];
 }
 k++;
 }
}
//----------------------------------
void espelhar(int matA[M][N], int matB[M][N], int m, int n) {
 int i, j, k;
 for (i = 0; i < m; ++i) {
 k = n - 1;
 for (j = 0; j < n; ++j) {
 matB[i][k--] = matA[i][j];
 }
 }
}
//----------------------------------
void diagonalPrincipalUp(int matA[M][N], int matB[M][N], int m, int n) {
 int i, j;
 for (i = 0; i < m; i++) {
 for (j = i + 1; j < n; j++) {
 matB[i][j] = matA[i][j];
 }
 }
}
//----------------------------------
void diagonalSecundariaUp(int matA[M][N], int matB[M][N], int m, int n) {
 int i, j;
 for (i = 0; i < m; i++) {
 for (j = 0; j < n; j++) {
 if (j <= n - i - 2) {
 matB[i][j] = matA[i][j];
 }
 }
 }
}
//----------------------------------
void diagonalSecundariaDown(int matA[M][N], int matB[M][N], int m, int n) {
 int i, j;
 for (i = 0; i < m; i++) {
 for (j = 0; j < n; j++) {
 if (j >= n - i) {
 matB[i][j] = matA[i][j];
 }
 }
 }
}
//----------------------------------
void diagonalPrincipalDown(int matA[M][N], int matB[M][N], int m, int n) {
 int i, j;
 for (i = 0; i < m; i++) {
 for (j = 0; j < n; j++) {
 if (j < i)
 matB[i][j] = matA[i][j];
 }
 }
}
//----------------------------------
void preencheMatriz(int mat[M][N], int m, int n) {
 int randon;
 for (int i = 0; i < m; i++) {
 for (int k = 0; k < n; k++) {
 mat[i][k] = (rand() % ((15 - 1) + 1)) + 1;
 }
 }
}
//----------------------------------
void zerarMatriz(int mat[M][N], int m, int n) {
 for (int i = 0; i < m; i++) {
 for (int k = 0; k < n; k++) {
 mat[i][k] = 0;
 }
 }
}
//----------------------------------
int mediaDosVizinhos(int mat[M][N], int m, int n, int i, int j) {
 int cont = 0, soma = 0;
 // Soma o valor da posição à esquerda
 if ((j - 1) >= 0) {
 cont += 1;
 soma += mat[i][j - 1];
 }
 // Soma o valor da posição à direita
 if ((j + 1) < n) {
 cont += 1;
 soma += mat[i][j + 1];
 }
 // Soma o valor da posição acima
 if ((i - 1) >= 0) {
 cont += 1;
 soma += mat[i - 1][j];
 }
 // Soma o valor da posição abaixo
 if ((i + 1) < m) {
 cont += 1;
 soma += mat[i + 1][j];
 }
 return soma / cont;
}
//----------------------------------
void diagonalPrincipal(int mat[M][N], int m, int n, int vet[M]) {
 int k = 0;
 for (int i = 0; i < m; i++) {
 for (int j = 0; j < n; j++) {
 if (i == j) {
 vet[k++] = mat[i][j];
 }
 }
 }
}
//----------------------------------
void diagonalSecundaria(int mat[M][N], int m, int n, int vet[M]) {
 int k = 0;
 for (int i = 0; i < m; i++) {
 for (int j = 0; j < n; j++) {
 if (j == n - i - 1) {
 vet[k++] = mat[i][j];
 }
 }
 }
}
//----------------------------------
void multiplica(int matA[M][N], int matB[M][N], int matC[M][N], int m, int n) {
 int soma = 0;
 for (int i = 0; i < m; i++) {
 for (int j = 0; j < n; j++) {
 soma = 0;
 for (int k = 0; k < n; k++) {
 soma += matA[i][k] * matB[k][j];
 }
 matC[i][j] = soma;
 }
 }
}
void soma(int matA[M][N], int matB[M][N], int matC[M][N], int m, int n) {
 for (int i = 0; i < m; i++) {
 for (int j = 0; j < n; j++) {
 for (int k = 0; k < n; k++) {
 matC[i][j] = matA[i][j] + matB[i][j];
 }
 }
 }
}
//----------------------------------
void matrizMedia(int matA[M][N], int matB[M][N], int m, int n) {
 for (int i = 0; i < m; i++) {
 for (int j = 0; j < n; j++) {
 matB[i][j] = mediaDosVizinhos(matA, m, n, i, j);
 }
 }
}
//----------------------------------
void transporMatriz(int mat[M][N], int vet[M*N], int m, int n) {
 int k = 0;
 for (int i = 0; i < m; i++)
 for (int j = 0; j < n; j++) {
 vet[k++] = mat[i][j];
 }
}
//----------------------------------
void vetToMat(int mat[M][N], int vet[M*N], int m, int n) {
 int k = 0;
 for (int i = 0; i < m; i++)
 for (int j = 0; j < n; j++) {
 mat[i][j] = vet[k++];
 }
}
//----------------------------------
void exibeMatriz(int mat[M][N], int m, int n) {
 printf("\nMatriz\n");
 for (int i = 0; i < m; i++) {
 printf("\n");
 for (int j = 0; j < n; j++) {
 printf("[%4d] ", mat[i][j]);
 }
 }
 printf("\n");
}
//----------------------------------
int main(int argc, char** argv) {
 int cont = 0, m = 3, n = 3;
 int matriz[M][N], matB[M][N], matC[M][N];
 int vet[M * N];
 preencheMatriz(matriz, m, n);
 exibeMatriz(matriz, m, n);
 multiplica(matriz, matriz, matC, m, n);
 exibeMatriz(matC, m, n);
 for (int i = 0; i < 1; i++) {
 printf("\n[%d] - Iteracao \n", i);
 matrizMedia(matC, matB, m, n);
 exibeMatriz(matB, m, n);
 }
 //transporMatriz(matB, vet, m, n);
 //zerarMatriz(matB, m, n);
 //vetToMat(matB, vet, m, n);
 //exibeMatriz(matB, m, n);
 zerarMatriz(matC, m, n);
 zerarMatriz(matriz, m, n);
 espelhar(matB, matC, m, n);
 diagonalPrincipalUp(matB, matriz, m, n);
 exibeMatriz(matriz, m, n);
 diagonalPrincipalDown(matB, matC, m, n);
 exibeMatriz(matC, m, n);
 zerarMatriz(matC, m, n);
 zerarMatriz(matriz, m, n);
 diagonalSecundariaUp(matB, matriz, m, n);
 exibeMatriz(matriz, m, n);
 diagonalSecundariaDown(matB, matC, m, n);
 exibeMatriz(matC, m, n);
 rotarcionar90(matC,matB,m,n);
 rotarcionar90(matB,matC,m,n);
 exibeMatriz(matC, m, n);
}