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;
}
}
