示例#1
0
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);
    }
}
示例#2
0
Matriz *Matriz::potenciaMatriz(int exp)const {
    try {
        if(exp < 0) throw(6);
        Matriz *mat = new Matriz(this->quantidadeDeLinhas,this->quantidadeDeColunas);


        for(int linha=0; linha<quantidadeDeLinhas; linha++)
            for(int coluna=0; coluna<quantidadeDeColunas; coluna++)
            {
                mat->setElemento(linha,coluna,this->getElemento(linha,coluna));   // copia MAT = THIS;
            }


        if(exp == 0) { //expoente igual a zero todos valores sao iguais a 1
            for(int linha=0; linha<quantidadeDeLinhas; linha++)
                for(int coluna=0; coluna<quantidadeDeColunas; coluna++)
                    mat->setElemento(linha,coluna,1);
        }
        else {
            for(int cont=1; cont < exp; cont++) //limite e o expoente
                *(mat) = (*(mat)) * (*(this));

        }

        return mat;

    } catch(int valorErro) {
        throw valorErro;
    }
    catch(std::bad_alloc&) {
        throw(0);
    }
}
示例#3
0
bool Matriz::eMatrizAntiSimetrica()const {
    try {

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

        matTrans = this->matrizTransposta();

        for(int linha=0; linha<quantidadeDeLinhas; linha++)
            for(int coluna=0; coluna<quantidadeDeColunas; coluna++) {
                int inverso = this->getElemento(linha,coluna)*-1;
                matOposta->setElemento(linha,coluna,inverso);//calcula oposta
            }

        bool ret= *matTrans == *matOposta;//compara transposta com oposta
        delete matTrans;
        delete matOposta;

        return ret;

    } catch(int valorErro) {
        throw valorErro;
    }
    catch(std::bad_alloc&) {
        throw(0);
    }
}
示例#4
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++;
        }
    }
}
示例#5
0
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");
    }
}
示例#6
0
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;
}
示例#7
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;
}
示例#8
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;

}
示例#9
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
示例#10
0
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);
 }
示例#12
0
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);
	}


}
示例#13
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
示例#14
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;
	}
};
示例#16
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
示例#17
0
graf_bib::Matriz graf_bib::grafo::completarGrafo(void) {

    Matriz *ret = NULL;

    if(!completo()) {

        ret = new Matriz(matrizRep);

        for(Matriz::iterator linha = ret->begin();
                linha != ret->end();
                ++linha) {

            for(Linha::iterator it = linha->begin();
                    it != linha->end();
                    ++it) {

                if(*it == 0 &&
                    (linha - ret->begin()) != (it - linha->begin()) )
                    *it = 1;

                else
                    *it = 0;
            }
        }
    }

    return *ret;
}
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);
}
 Matriz<4,1> apllyOrto(Matriz<4,1> _LoL)
 {
    Matriz<4,4> t;
    t.setZero();
    t(0,0) = 1;
    t(1,1) = 1;
    t(3,3) = 1;
    return t*_LoL;
 }
Matriz<3,3> Scale2D1(float xi)
{
   Matriz<3,3> ret;
   ret.setZero();
   ret(0,0) = xi;
   ret(1,1) = xi;
   ret(2,2) = 1;
   return ret;
}
示例#22
0
bool Matriz::operator==(const Matriz& M){
	if (GetFilas()!=M.GetFilas() || nc!=M.nc)
		return false;
	int f=GetFilas();
	for (int i = 0; i < f; ++i)
		for (int j = 0; j < nc; j++)
			if (Get(i,j)!=M.Get(i,j))
				return false;
		}
Transformacion Transformacion::scale(float sx,float sy,float sz, Punto centro)
//Acumula el escalado sobre un punto generico
{
	Matriz s;
	translation(centro);
	s.setelem(0,0,sx); s.setelem(1,1,sy); s.setelem(2,2,sz);
	append(s);
	return translation(centro.negated());
}
示例#24
0
文件: Matriz.cpp 项目: nlasso/metodos
Matriz* Matriz::Identidad(const unsigned int n){

    Matriz* res = new Matriz(n,n,0,0);
    for(int i =0;i<n;i++){

        res->cambiarValor(i,i,1);
    }
    return res;
}
示例#25
0
void muestraMatriz(Matriz<T> &m){
	//Aqui mostraremos la matriz
	for(int i=0; i<m.filas(); i++){
		for(int j=0; j<m.columnas(); j++ ){
			cout << m[i][j] << "\t";
		}
		cout << endl;
	}

}
示例#26
0
void calcular_media(Matriz& matriz, vector<double>& v) { //ver si se pierde precisión con la división
  int n = matriz.dimensionFilas();
  int m = matriz.dimensionColumnas();

  for (int j = 0; j < m; ++j) {
    for (int i = 0; i < n; ++i) {
      v[j] = (v[j] + matriz[i][j]); //acumulo
    }
    v[j] = v[j] / (double)n; //calculo promedio final
  }
}
示例#27
0
Matriz* Matriz::matrizTransp()const{ //CERTO
    Matriz *aux = new Matriz(quantidadeDeColunas,quantidadeDeLinhas);
    for(int i=0;i<getQuantidadeDeLinhas();i++){
            for(int j =0;j<getQuantidadeDeColunas();j++){
                int valor=this->getElemento(i,j);
                aux->setElemento(valor,j,i);

            }
        }
    return aux;
}
示例#28
0
文件: Matriz.cpp 项目: nlasso/metodos
Matriz* Matriz::operator+(Matriz* B){

    Matriz* res = new Matriz(*B,_p,_q);
    for(int i=0; i< _fil;i++){
        for(int j=0; j<_col;j++){
            double newVal = elem(i,j) + (*B).elem(i,j);
				res->cambiarValor(i,j,newVal);
            }
        }
    return res;
}
Matriz<3,3> rotation2D(float graus)
{
   Matriz<3,3> ret;
   ret.setZero();
   ret(0,0) = cos(graus);
   ret(0,1) = -sin(graus);
   ret(1,0) = sin(graus);
   ret(1,1) = cos(graus);
   ret(2,2) = 1;
   return ret;
}
示例#30
0
bool Matriz::ortogonal()const{ //CERTO
    Matriz *aux = new Matriz(quantidadeDeLinhas, quantidadeDeColunas);
    aux = (*this)*this->matrizTransp();
    if(aux->matrizIdentidade() == true){
        return true;
        delete aux;
    }
    else{
        return false;
        delete aux;
    }
}