//*****************************************************************************
const Matriz * Matriz::eResultanteMultiplicacaoPorK(int k)
// A = |Aij| -> A* = |Aij*k|
{
Matriz *resultanteMultiplicacao;
try{
resultanteMultiplicacao = new Matriz(quantidadeLinhas, quantidadeColunas);
for(unsigned int linha=0; linha<resultanteMultiplicacao->obterQuantidadeLinhas(); linha++){//for 1
for(unsigned int coluna=0; coluna<resultanteMultiplicacao->obterQuantidadeColunas(); coluna++){
int elementoA;//elemento,
elementoA = obterElementoMatriz(linha, coluna);
elementoA = elementoA*k;
resultanteMultiplicacao->atribuirElementoMatriz(linha,coluna,elementoA);
}//fim for 2
}//fim for 1
return resultanteMultiplicacao;
}//fim try
catch(std::string msg){
delete resultanteMultiplicacao;
throw msg;
}
catch(int idException){
delete resultanteMultiplicacao;
throw idException;
}
}//fim do metodo multiplicacao por k
//*****************************************************************************
//calculara a transposta do obj atual e retornara o resultado pelo nome
const Matriz *Matriz::eResultanteDaTransposta()const
// A = Aij -> A^t = Aji
{
//lembrando que estou dentro do objeto com os dados para ser calculados
Matriz *resultanteTransposta;
try{
resultanteTransposta = new Matriz(quantidadeColunas, quantidadeLinhas);
//lendo os elementos e os invertendo dentro do for 2
for(unsigned int linha=0; linha<resultanteTransposta->obterQuantidadeLinhas(); linha++){
for(unsigned int coluna=0; coluna<resultanteTransposta->obterQuantidadeColunas(); coluna++){
int elemento=0;
elemento = obterElementoMatriz(linha, coluna);
//os paramentros linha e coluna realmente sao invertidos para
//criar a tranposta
resultanteTransposta->atribuirElementoMatriz(coluna, linha, elemento);
}//fim for 2
}//fim for 1
return resultanteTransposta;
}//fim
catch(std::string msg){
delete resultanteTransposta;
throw msg;
}
catch(int idException){
delete resultanteTransposta;
throw idException;
}
}//fim do metodo tranposta
const Matriz * const Matriz::operator+(Matriz const &matriz)const
{
//foi criada e nao construida por causo do try
Matriz *matrizAux;
try{
//matriz quadrada
//se a matriz nao for quadrada eh impossivel add
//entao
if((obterQuantidadeLinhas() != matriz.obterQuantidadeLinhas())
|| (obterQuantidadeColunas() != matriz.obterQuantidadeColunas()) ){
int id=2;
throw id;
//std::cout<<" ERRO MT +"<<std::endl;
//throw std::string("Quantidade de Linhas e/ou Quantidade de Colunas diferentes!");
}
unsigned int linhaMatriz,colunaMatriz;
linhaMatriz = obterQuantidadeLinhas();
colunaMatriz = obterQuantidadeColunas();
matrizAux = new Matriz(linhaMatriz,colunaMatriz);
for(unsigned int linha=0;linha<linhaMatriz;linha++)
for(unsigned int coluna=0;coluna<colunaMatriz;coluna++){
int elementoA,elementoB,elementoC;
elementoA = obterElementoMatriz(linha,coluna);
elementoB = matriz.obterElementoMatriz(linha,coluna);
elementoC = elementoA + elementoB;
matrizAux->atribuirElementoMatriz(linha,coluna,elementoC);
}//fim for
return matrizAux;
}//fim try
catch(std::string msg){
//se pedir pra deletar da falha de segmentacao
//delete matrizAux;
//std::cout<<" ERRO PP"<<std::endl;
throw msg;
}//fim catch 1
catch(int idException){
//se pedir pra deletar da falha de segmentacao/
//delete matrizAux;
throw idException;
}//fim catch 2
}//fim add
//*****************************************************************************
const Matriz * const Matriz::operator-(Matriz const &matriz)const
// C = A - B ou C = A +(-B)
{
unsigned int linhaMatriz, colunaMatriz;
Matriz *matrizAux;
try{
//matriz quadrada
//se a matriz nao for quadrada eh impossivel add
//entao
if((obterQuantidadeLinhas() != matriz.obterQuantidadeLinhas())
|| (obterQuantidadeColunas() != matriz.obterQuantidadeColunas()) ){
//throw std::string("Quantidade de Linhas e/ou Quantidade de Colunas diferentes!");
int id=2;
throw id;
}
linhaMatriz=matriz.obterQuantidadeLinhas();
colunaMatriz=matriz.obterQuantidadeColunas();
matrizAux = new Matriz(linhaMatriz, colunaMatriz);
for(unsigned int linha=0; linha<obterQuantidadeLinhas(); linha++) {
for(unsigned int coluna=0; coluna<obterQuantidadeColunas(); coluna++){
int elementoC, elementoA, elementoB;
elementoA=obterElementoMatriz(linha, coluna);
elementoB=matriz.obterElementoMatriz(linha, coluna);
elementoC = elementoA + (elementoB*(-1));
matrizAux->atribuirElementoMatriz(linha, coluna, elementoC);
}//for 2
}//for 1
return matrizAux;
}//fim try
catch(std::string msg){
//se pedir pra deletar da falha de segmentacao
//delete matrizAux;
throw msg;
}//fim catch
catch(int idException){
//se pedir pra deletar da falha de segmentacao
//delete matrizAux;
throw idException;
}
}//fim metodo subtracao
//TESTADO E APROVADO
const Matriz * const Matriz::operator*(Matriz const &matriz)const
{
unsigned int linhaMatriz, colunaMatriz;
Matriz *matrizAux;
//verificando a condicao d existencia da multiplicacao matricial
if(obterQuantidadeColunas()!= matriz.obterQuantidadeLinhas()){
//throw std::string("Quantidade de Colunas diferente da Quantidade de Linhas!");
int id=2;
throw id;
}
try{
linhaMatriz = quantidadeLinhas;
colunaMatriz = matriz.obterQuantidadeColunas();
//construindo a matriz segundo as regras da multiplicacao
matrizAux = new Matriz(linhaMatriz, colunaMatriz);
for(unsigned int linha=0; linha < matrizAux->obterQuantidadeLinhas(); linha++){//for 1
for(unsigned int coluna=0; coluna < matrizAux->obterQuantidadeColunas(); coluna++){//for 2
int soma=0;
for(unsigned int i=0; i<quantidadeColunas; i++){//poderia ser i<matB.obterQuantidadeLinhas() ]
int elementoA, elementoB;
elementoA = obterElementoMatriz(linha, i);
elementoB = matriz.obterElementoMatriz(i, coluna);
soma += (elementoA*elementoB);
}
matrizAux->atribuirElementoMatriz(linha, coluna, soma);
}//2
}//1
return matrizAux;
}//fim try
catch(std::string msg){
delete matrizAux;
throw msg;
}
catch(int idException){
delete matrizAux;
throw idException;
}
}//fim metodo Multiplicacao
