C++ Matriz类代码示例

bool Matriz::eMatrizOrtagonal()const {
    try {
        if(this->quantidadeDeLinhas != this->quantidadeDeColunas) throw (5);//verifica se e quadrada.

        Matriz *matTrans = new Matriz(this->quantidadeDeLinhas,this->quantidadeDeColunas);
        Matriz *matResult = new Matriz(this->quantidadeDeLinhas,this->quantidadeDeColunas);

        matTrans = this->matrizTransposta();//matriz transposta temporaria recebendo valores

        *matResult = (*matTrans) * (*this);//matriz resultado da multiplicacao da transposta com original

        delete matTrans;

        bool ret = matResult->eMatrizIdentidade();//verifica se resultado e igual identidade
        delete matResult;
        return ret;


    } catch(int valorErro) {
        throw valorErro;
    }
    catch(std::bad_alloc&) {
        throw (0);
    }
}

void graf_bib::grafo::num_componentes (void){
    int componentes=0;
    int vertice=0;
    set<int> verticesDoComponente;//TODO: inicializar
    // Lista para vertices que nao verificou vertices adjacentes
    list<int> verticesNaoVerificados;//TODO: inicializar
    for (vertice=0; vertice < numVertices; vertice++) {
        verticesNaoVerificados.push_back(vertice);
    }
    //Matriz de adjacencias
    Matriz *ret = new Matriz(matrizRep);
    Matriz::iterator linha = ++(ret->begin());

    while(!verticesNaoVerificados.empty()) {
        for(Linha::iterator it = linha->begin(); it != linha->end(); ++it) {//itera nos vertices adjacentes
            if (*it ==1) {
                verticesDoComponente.insert(it - (linha->begin()));
            }
        }
        verticesNaoVerificados.remove(linha-(ret->begin()));
        if (!verticesDoComponente.empty()) {
            linha = ret->begin() + *(++verticesDoComponente.begin());
        } else {
            componentes++;
        }
    }
}

Matriz* Matriz::operator *(Matriz const * const mat)const{ //CERTO
    if( quantidadeDeColunas  != mat->getQuantidadeDeLinhas() )throw QString("Nao e possivel fazer a multiplicacao das matrizes");
    try{
        Matriz *aux = new Matriz(quantidadeDeLinhas, mat->getQuantidadeDeColunas());
        int a=0,b;
        for(int i=0; i<quantidadeDeLinhas; i++){
            b=0;
            for(int j=0; j<mat->getQuantidadeDeColunas(); j++){
                int valor=0;
                for (int k=0;k<quantidadeDeColunas;k++){
                    valor += this->getElemento(i,k)*mat->getElemento(k,j);
                }
                aux->setElemento(valor,a,b++);
            }
            a++;
        }
        return aux;
    }
    catch(std::bad_alloc&){
        throw QString("Vai comprar memoria");
    }
    catch(QString &erro){
        throw QString("Matriz auxiliar nao Criada nao podemos adicionar as matrizes");
    }
}

int main(){
	Matriz A, B ;
	cout<<"numero de filas de Matriz 1 \n";
	cin>>A.fila;
	cout<<"numero de columnas de Matriz 1 \n";
	cin>>A.columna;
	A.crear_matriz();
	A.imprimir_matriz();
	system("cls");

	cout<<"numero de filas de Matriz 2 \n";
	cin>>B.fila;
	cout<<"numero de columnas de Matriz 2 \n";
	cin>>B.columna;
	B.crear_matriz();
	B.imprimir_matriz();
	system("cls");
	
	cout<<"El producto matriz de ambas matrices es \n";
	int mP[dim][dim];
	productMatrix(mP, A.matriz, A.fila , A.columna, B.matriz, B.fila, B.columna);
	Matriz Resultado;
	Resultado.fila=A.fila;
	Resultado.columna=B.columna;
	Resultado.copiar_matriz(mP);
	Resultado.imprimir_matriz();
	system("pause");
	return 0;
}

int main(){
//    int matriz[5][5];
//     int num;
//     for(int i=0; i<5; ++i){
//          for(int j=0; j<5; ++j){
//               cin >> num;
//               matriz[i][j] = num;
//          }
//     }
//     printMatriz(matriz);
//     return 0;
     int filas, columnas;
     Matriz matriz;
     cout << "cantidad de filas:\n";
     cin >> filas;
     cout << "cantidad de columnas:\n";
     cin >> columnas;
     Array arr(columnas);     
     for(int i=0; i<filas; ++i){
          for(int j=0; j<columnas; ++j){
               cin >> arr[j];
          }
          matriz.push_back(arr);
     }
     printVector(matriz);
     return 0;
}

double metodoPotencia(Matriz& A, vector<double>& x) {
  int length = x.size();
  vector<double> y(length, 0.0);
  int k = 0;
  double c2;

  A.multiplicarVectorDer(x, y);

  double c1 = maxAbs(y);
  double aux = c1;

  do {
    c1 = aux; // La primera vez esto no surte efecto

    for (size_t i = 0; i < length; ++i) // Normalizo vector
      x[i] = y[i] / c1; 

    Matriz::cerearVector(y); // Reseteo el vector y

    A.multiplicarVectorDer(x, y);

    c2 = maxAbs(y);
    aux = c2;

    ++k;
  
  } while(!igualdadConTolerancia(c1, c2) && k < 15000); // Experimentar con metodo de corte Y Epsilon para la tolerancia

  if (k >= 15000)
    std::cout << "estoy devolviendo fruta" << std::endl;

  return c2;

}

//*****************************************************************************
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

void calcular_base_ortonormal(Matriz& matriz, Matriz& matriz_ortonormal, int alfa){ //deja en matriz_ortonormal una matriz de alfa columnas
  double autovalor;
  int m = matriz_ortonormal.dimensionColumnas();

  for (int i = 0; i < alfa; ++i) { //repito alfa veces (hay que experimentar con dicho valor)

    vector<double>& aux = matriz_ortonormal[i];

    Matriz::cargarVector(aux);

    matriz.mostrar2();

    autovalor = metodoPotencia(matriz, aux); //calculo el i-ésimo autovalor, en aux queda el autovector
    std::cout << "autovalor: " << i << " vale: " << std::scientific << autovalor << std::endl;

    /* Deflación */
    Matriz auxiliar(m, m);
    std::cout << "-----------------------------------" << std::endl;

    normalizar(aux);

    auxiliar.multiplicarVectoresDameMatriz(aux, aux);
    auxiliar.multiplicarEscalar(autovalor);
    matriz.menos(auxiliar);

    matriz.mostrar2();

    while (true) {}
  } 
  /* Tengo en matriz_ortonormal la matriz con base de autovectores de matriz */
}

 Matriz<4,1> applyPersp(Matriz<4,1> _LoL)
 {
    Matriz<4,1> t;
    float r = 1/DISTANCE_PERSPECTIVE;
    Matriz<4,4> Tp;
    Tp.setZero();
    Tp(0,0) = 1;
    Tp(1,1) = 1;
    if(tipo_de_projecao == 1){
       Tp(3,2) = -r;
    }else if(tipo_de_projecao == 2){
       Tp(3,2) = -r;
       Tp(3,1) = r;
    }else if(tipo_de_projecao == 3){
       Tp(3,1) = r;
       Tp(3,0) = r;
       Tp(3,2) = -r;
    }
    t = Tp*_LoL;
    if(t(0,0) != 0.f)
       t(0,0) = t(0,0)/t(3,0);
    if(t(1,0) != 0.f)
       t(1,0) = t(1,0)/t(3,0);
    t(2,0) = 0;
    t(3,0) = 1;
    return (t);
 }

Matriz *Persistencia::recuperar(std::string const &nomeDoArquivoNoDisco)const{

	std::ifstream arquivoMatriz(nomeDoArquivoNoDisco.c_str());

	try{

		if(!arquivoMatriz.is_open()) throw(4);//arquivo nao pode ser aberto
		int linha, coluna,a;
		arquivoMatriz>>linha;
		arquivoMatriz>>coluna;
		Matriz *matriz = new Matriz(linha,coluna);
		for(int i=0; i<linha; i++)
			for(int j=0; j<coluna; j++){
				arquivoMatriz>>a;
				matriz->setElemento(i,j,a);
			}
		arquivoMatriz.close();
		return matriz;

	}catch(int valorErro){
		if(valorErro != 4)
		arquivoMatriz.close();
		throw valorErro;
	}catch(std::bad_alloc&){
		arquivoMatriz.close();
		throw(0);
	}


}

void PCAMethod(Matriz& matriz, Matriz& res, Matriz& m_ortonormal, int alfa, std::ofstream& filewrite){
  int n = matriz.dimensionFilas();
  int m = matriz.dimensionColumnas();

  Matriz X(n, m);
  calcular_matriz_X(matriz, X);

  Matriz Xt(m, n);
  X.trasponer(Xt);

  Matriz m_covarianza(m, m); //revisar dimensiones

  std::cout << "antes de entrar a multiplicar" << std::endl;
  Xt.multiplicarMatrices(X, m_covarianza); //crear matriz covarianza
  std::cout << "after" << std::endl;

  /* Reducción de la dimensión */
  calcular_base_ortonormal(m_covarianza, m_ortonormal, alfa); //deja en matriz_ortonormal una matriz de alfa filas

  /* Transformación característica */
  Matriz m_ortonormal_traspuesta(m, alfa);
  m_ortonormal.trasponer(m_ortonormal_traspuesta);

  /* Transformación característica */
  matriz.multiplicarMatrices(m_ortonormal_traspuesta, res); // Chequear esto en caso de que no ande
}

void CurvaBezier::getPoints(int n, Punto *puntos)const
//Devuelve n puntos sobre la curva en puntos[]
//mediante el método de las diferencias avanzadas
{

	float L = 1.0/(n-1);
	float L2 = L*L, L3 = L*L*L;
	Matriz E = Matriz(Real4(0, 0, 0, 1),
					  Real4(L3, L2, L, 0),
					  Real4(6*L3, 2*L2, 0, 0),
					  Real4(6*L3, 0, 0, 0));
	Matriz D = E*C;

	puntos[0] = D.row(0);
	Punto P = puntos[0];
	Vector inc1, inc2, inc3;
	inc1 = D.row(1);
	inc2 = D.row(2);
	inc3 = D.row(3);
	for(int i=1; i<n; ++i){
		P = P + inc1;
		puntos[i] = P;
		inc1 = inc1 + inc2;
		inc2 = inc2 + inc3;
	}
};

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

Matriz Bloque::layer(int k)const
//Devuelve la capa k como una matriz
{
	Matriz m;
	for(int i=0; i<4; i++)
		for(int j=0; j<4; j++) m.setelem(i,j,e[i][j][k]);
	return m;
}

Transformacion Transformacion::translation(Real4 d)
//Acumula la traslacion propuesta
{
	Matriz t;
	int i;
	for (i=0;i<3;i++) t.setelem(i,3,d.elem(i));
	return append(t);
}