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); } }
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); } }
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); } }
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); } }
//***************************************************************************** //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
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
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; }
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()); }
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; }
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; } }
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 } }
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; }
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; }
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; } }