Jump to content
Sol

Classes Combinadas

Recommended Posts

Sol

Ola! Preciso de ajuda com meu programa. Por favor!

Tenho 3 Classes: Complexo: que faz operações entre números complexos, Matriz: cria matriz de complexos e faz operações entre matrizes Por ultimo, criei a Classe sistema que possui métodos para calcular a resolução de um sistema linear pelo método iterativo de Gauss, sendo os elementos da Matriz (Sistema) todos complexos. Até ai ok.

O meu bug esta a ser em manipular as coisas no Main.cpp
Preciso: primeiro verificar convergencia(), depois se convergir faço o calculo pelo metodo Gauss(). Por ultimo exibir a solução dada pelo metodo resultados(). Com duas classes fui até bem. Com tres já estou a misturar as coisas.

Main.cpp

#define _CRT_SECURE_NO_WARNINGS

    #include<stdio.h>
    #include"Complexo.h"
    #include"Matriz.h"
    #include"Sistema.h"

   `insira o código aqui`int main()
    {



Matriz AB,X;
Sistema Y;


AB.lerMatriz();
AB.escreverMatriz();

Y = AB;

// verificar convergencia da matriz A

if (Y.convergencia())
{
    printf("\nSistema pode ser calculado pelo metodo iterativo de Gauss-Siedel\n");
}

// se convergencia ok calcular gauss

  }
Complexo.h

#pragma once  
class Complexo
{
private:
   float re, im;
public:
   Complexo();   // Construtor cria um número nulo  
Complexo(float r, float i);

void atribuir(float r, float i);
void lerComplexo();  // ler complexo do teclado  
void imprimir();   // escrever complexo para o monitor  

float real() { return re; } // devolve coeficiente real  
float imaginario() { return im; } // devolve coeficiente imaginário  
float modulo();  // devolve módulo do número  
float argumento(); // devolve argumento do número  
Complexo conjugado();  // devolve o conjugado do número  
Complexo simetrico();  // devolve o simétrico do número 
Complexo potencia(float exp);  // devolve potência do número 

// operações entre 2 complexos  
Complexo operator +(const Complexo& c); // adição   
Complexo operator -(const Complexo& c); // subtração  
Complexo operator *(const Complexo& c); // multiplicação  
Complexo operator /(const Complexo& c); // divisão 


// operações entre um complexo (operador da esquerda) e um real (operador da  // direita)  
Complexo operator *(float f);
Complexo operator /(float f);

};
Complexo.cpp

#define _CRT_SECURE_NO_WARNINGS

#include "Complexo.h"
#include<stdio.h>
#include<math.h>
Complexo::Complexo()
{
	re = 0;
	im = 0;
}

Complexo::Complexo(float r, float i)
{
	re = r;
	im = i;
}

void Complexo::atribuir(float r, float i)
{
	float novo_re = r;
	float novo_im = i;
}

void Complexo::lerComplexo()
{
	printf("Parte real:");
	scanf("%f", &re);
	printf("\n");
	printf("Parte imaginaria:");
	scanf("%f", &im);
	printf("\n");

}

void Complexo::imprimir()   // escrever complexo para o monitor  
{
	printf("%.1f +%.1fi\t", re, im);
}


float Complexo::modulo()  // devolve módulo do número 
{
	float m;
	m = float(sqrt(pow(re, 2) + pow(im, 2)));
	return m;
}
float Complexo::argumento() // devolve argumento do número 
{
	float arg;
	arg = float(atan2(im, re));
	return arg;
}

Complexo Complexo::conjugado()  // devolve o conjugado do número  
{
	Complexo c;
	c.re = re;
	c.im = -im;
	return c;
}
Complexo Complexo::simetrico()  // devolve o simétrico do numero
{
	Complexo s;
	s.re = re * (-1);
	s.im = im * (-1);
	return s;
}
Complexo Complexo::potencia(float exp)  // devolve potência do número
{
	Complexo p;
	float mod;
	mod = float(pow(modulo(), exp));
	p.re = float(mod * cos(exp * argumento()));
	p.im =float( mod * sin(exp * argumento()));
	return p;
}

// operações entre 2 complexos  
Complexo Complexo::operator +(const Complexo& c) // adição   
{
	Complexo res;
	res.re = re + c.re;
	res.im = im + c.im;
	return res;

}
Complexo Complexo::operator -(const Complexo& c) // subtração  
{
	Complexo res;
	res.re = re - c.re;
	res.im = im - c.im;
	return res;
}
Complexo Complexo::operator *(const Complexo& c) // multiplicação 
{
	Complexo res;
	res.re = re * c.re - im * c.im;
	res.im = re * c.im + im * c.re;
	return res;
}
Complexo Complexo::operator /(const Complexo& c) // divisão    
{
	Complexo num, den, res;
	num = Complexo(re, im);
	den = c;
	num = *this * den.conjugado();
	den = den * den.conjugado();
	return Complexo(num.re / den.re, num.im / den.re);
}


// operações entre um complexo (operador da esquerda) e um real (operador da  // direita)  

Complexo Complexo::operator *(float f)
{
	Complexo res;
	res.re = re * f;
	res.im = im * f;
	return res;

}
Complexo Complexo::operator /(float f)
{
	Complexo res;
	res.re = re / f;
	res.im = im / f;
	return res;

}
Matriz.h

#pragma once  
 #include "complexo.h"  
 class Matriz 
 {
  friend class Sistema;
  private:
  Complexo** elems;               // elementos da matriz  
  int nlin, ncol;               // número de linhas e colunas
  public:

void inicia();                    // função para iniciar matriz
void delete_matriz();             // função para apagar matriz

Matriz();                       //um construtor por omissão(a ordem da matriz é definida posteriormente)
Matriz(int lin, int col);      //um construtor que recebe a ordem da matriz e cria uma matriz com elementos a zero
Matriz(const Matriz& m2);    //um construtor por cópia
~Matriz();                  // Um destrutor para eliminar os dados dinâmicos da classe

void lerMatriz();
void escreverMatriz();

bool podeSomar(const Matriz& m2);
bool podeMultiplicar(const Matriz& m2);

Matriz& operator=(const Matriz& m2);
Matriz operator+(const Matriz& m2);
Matriz operator*(const Matriz& m2);
};
Matriz.cpp

#define _CRT_SECURE_NO_WARNINGS

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "Matriz.h"
#include"Sistema.h"

void Matriz::inicia()
{
	elems = new Complexo * [nlin];

	for (int i = 0; i < nlin; i++) {
		elems[i] = new Complexo[ncol];
	}
}
void Matriz::delete_matriz()
{
	for (int i = 0; i < nlin; i++) {
		delete[] elems[i];
	}
	delete[] elems;

}

Matriz::Matriz() //um construtor por omissão(a ordem da matriz é definida posteriormente)
{
	nlin = 1;
	ncol = 1;
	inicia();
}
Matriz::Matriz(int lin, int col)    //um construtor que recebe a ordem da matriz e cria uma matriz com elementos a zero
{
	delete_matriz();
	nlin = lin;
	ncol = col;
	inicia();
}
Matriz::Matriz(const Matriz& m2)    //um construtor por cópia
{
	nlin = m2.nlin;
	ncol = m2.ncol;
	inicia();
	for (int i = 0; i < nlin; i++)
		for (int j = 0; j < ncol; j++)
			elems[i][j] = m2.elems[i][j];
}
Matriz::~Matriz()                  // Um destrutor para eliminar os dados dinâmicos da classe
{
	delete_matriz();
}
void Matriz::lerMatriz()
{
	delete_matriz();
	printf("Digite a ordem da Matriz Aumentada. Numero de linha e numero de colunas respectivamente\n\n");
	printf("OBS: O numero de linhas da matriz aumentada corresponde ao numero de esquacoes do sistema\n");
	printf("O numero de colunas = numero de linhas +1\n");
	scanf("%d %d", &nlin, &ncol);
	inicia();


	for (int i = 0; i < nlin; i++)
	{

		for (int j = 0; j < ncol; j++)
		{
			printf("\nDigite a posicao %dx%d da Matriz AB\n", i + 1, j + 1);
			elems[i][j].lerComplexo();
		}
	}
}

void Matriz::escreverMatriz()
{
	printf("\n");
	for (int i = 0; i < nlin; i++)
	{

		for (int j = 0; j < ncol; j++)
		{
			elems[i][j].imprimir();
		}
		printf("\n");
	}
}


bool Matriz::podeSomar(const Matriz& m2)
{
	return (nlin == m2.nlin && ncol == m2.ncol);

}

bool Matriz::podeMultiplicar(const Matriz& m2)
{
	return (ncol == m2.nlin);

}




Matriz& Matriz::operator = (const Matriz& m2)// Operador Igual
{
	delete_matriz();
	nlin = m2.nlin;
	ncol = m2.ncol;

	inicia();
	for (int i = 0; i < nlin; i++) {
		for (int j = 0; j < ncol; j++) {
			elems[i][j] = m2.elems[i][j];
		}
	}
	return *this;
}


Matriz Matriz::operator + (const Matriz& m2)
{
	Matriz mat(nlin, ncol);

	for (int i = 0; i < nlin; i++) {
		for (int j = 0; j < ncol; j++) {
			mat.elems[i][j] = elems[i][j] + m2.elems[i][j];
		}
	}
	return mat;
}

Matriz Matriz::operator*(const Matriz& m2)
{
	Matriz mat(nlin, m2.ncol);

	for (int i = 0; i < nlin; i++) {
		for (int j = 0; j < m2.ncol; j++) {
			for (int k = 0; k < ncol; k++) {
				mat.elems[i][j] = mat.elems[i][j] + (elems[i][k] * m2.elems[k][j]);
			}
		}
	}
	return mat;
}
Sistema.h

#pragma once
#include "Complexo.h"
#include "Matriz.h"


class Sistema
{
friend class Matriz;
private:

int ordem;
public: 
Sistema() { Matriz(); }
Matriz Matriz_AB;// matriz aumentada
Matriz X; // vetor de icognitas
void gauss();
bool convergencia();
void resultados();
};
Sistema.cpp

#define _CRT_SECURE_NO_WARNINGS
#define max_iter 100 //número máximo de iterações admissível
#define tol 0.0001 //erro máximo admitido

#include<stdio.h>
#include "Sistema.h"
#include "Matriz.h"
#include "Complexo.h"
#include <math.h>


void Sistema::gauss()
{
	Matriz X(ordem, 1);//vector das incógnitas na iteração actual 
	Complexo x_antigo; //valor da incógnita na iteração anterior
	Complexo soma;
	float erro_x = 0; // erro_x - o erro da incógnita 
	float erro_iter = 0; //erro_iter - erro da iteração
	int niter = 0; //numero de iteracoes

	do {
		niter++;
		float erro_iter = 0;

		for (int i = 0; i < ordem; i++)
		{
			x_antigo = X.elems[i][0];
			//soma =0
			for (int j = 0; j < ordem; j++)
			{
				if (j != i)
					soma = soma + (Matriz_AB.elems[i][j] * X.elems[j][1]);
			}
			X.elems[i][1] = (Matriz_AB.elems[i][ordem]) - (soma) / Matriz_AB.elems[i][i];
			erro_x = (X.elems[i][0] - x_antigo).modulo();
			if (erro_x > erro_iter)
				erro_iter = erro_x;
		}

	} while (erro_x > tol && niter < max_iter);//ver erro x
	return X;
}



bool Sistema::convergencia()
{
	Complexo soma;
	for (int i = 0; i < ordem; i++)
	{
		for (int j = 0; j < ordem; j++)
		{
			if (j != i)
				soma = soma + Matriz_AB.elems[i][j];

		}
		if (Matriz_AB.elems[i][i].modulo() > soma.modulo())
			return true;
		else
			return false;

	}
}

void Sistema::resultados()
{
	for(int i=0;i<ordem;i++)
	X.elems[i][1].imprimir();
}

 

Share this post


Link to post
Share on other sites
M6

Qual é o teu bug? O que é que dá e o que devia dar?

Tens de ser claro e concreto nas dúvidas que colocas.


10 REM Generation 48K!
20 INPUT "URL:", A$
30 IF A$(1 TO 4) = "HTTP" THEN PRINT "400 Bad Request": GOTO 50
40 PRINT "404 Not Found"
50 PRINT "./M6 @ Portugal a Programar."

 

Share this post


Link to post
Share on other sites
Sol
11 horas atrás, M6 disse:

Qual é o teu bug? O que é que dá e o que devia dar?

Tens de ser claro e concreto nas dúvidas que colocas.

Ola! Não estou a ter um bug no programa. Realmente nao fui clara. Eu criei a classe Sistema. Preciso de no main.cpp, chamar o metodo Gauss() que pertence a classe Sistema de forma a fazer os calculos com a matriz AB que é inserida pelo usuario. A matriz AB, é um objeto do tipo Matriz. Eu nao posso fazer coisas do tipo: AB.gauss(). Preciso chamar o metodo Gauss passando AB como parametro. Não sei como fazer isso. Tambem tentei criar um objeto do tipo Sistema, ex: Sistema Y. E tentei coisas do tipo: Y=AB e daí fazer Y.gauss(). Porem ao igualar os dois objetos da erro. Nao verdade o programa nao bugou ainda, fui eu. 

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.