示例#1
0
文件: Matriz.cpp 项目: mtulio/kb
//*****************************************************************************
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
示例#2
0
文件: Matriz.cpp 项目: mtulio/kb
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
示例#3
0
文件: Matriz.cpp 项目: mtulio/kb
//*****************************************************************************
//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
示例#4
0
文件: Matriz.cpp 项目: mtulio/kb
//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