//*****************************************************************************
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
bool Matriz::operator!=(Matriz const &matriz)const
{
try{
if ((obterQuantidadeLinhas() != matriz.obterQuantidadeLinhas() )
|| (obterQuantidadeColunas() != matriz.obterQuantidadeColunas() ) ){
return false;
}//fim if
for(unsigned int linha=0; linha<obterQuantidadeLinhas(); linha++) {//for 1
for(unsigned int coluna=0; coluna<obterQuantidadeColunas(); coluna++){//for 2
int elemento, elementoM;
elemento = obterElementoMatriz(linha, coluna);
elementoM = matriz.obterElementoMatriz(linha, coluna);
//verificando cada elemento se eh igual
if(elemento == elementoM) return false;
}//fim for 2
}//fim for 1
return true;
}//fim try
catch(std::string msg){
throw msg;
}
catch(int idException){
throw idException;
}
}//fim do metodo diferente
//*****************************************************************************
//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
//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
