Beispiel #1
0
//*****************************************************************************
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
Beispiel #2
0
//*****************************************************************************
//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
Beispiel #3
0
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
Beispiel #4
0
//*****************************************************************************
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 
Beispiel #5
0
//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