Trabalho sobre iterações de gauss-seidel

Ulti.disciplina · 2 de junho de 2011

Estou a terminar o meu curso e só tenho duas cadeiras de programação...

Preciso de ajuda a terminar o meu projecto final que pretende fazer calculo de equações pelo método de iterações gauss-seidel...

O trabalho começa por ter de fazer um algoritmo que faz álgebra de números complexos, que julgo ter conseguido, pelo menos efectuar a álgebra com o seguinte código

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

class complexo
{
private:
    float re, im;
public:
    complexo(){re=0;im=0;}
    complexo( float r, float i = 0 ){re=r;im=i;}
    complexo( const complexo& c ){re=c.re;im=c.im;}
    float modulo()const{return sqrt(re*re+im*im);}
    float argumento(){return 180.0*atan2(im, re)/M_PI;}
    complexo conjugado()const{complexo res(re,-im);return res;}
    complexo simetrico(){complexo res(-re,im);return res;};
    complexo operator+( const complexo& c ){return complexo(re+c.re,im+c.im);}
    complexo operator-( const complexo& c ){return complexo(re-c.re,im-c.im);}
    complexo operator*( const complexo& c ){return complexo(re*c.re-im*c.im,re*c.im+im*c.re);}
    complexo operator/( const complexo& c ){complexo conj=c.conjugado();complexo numerador=*this*conj;float mod=c.modulo();return numerador*(1.0/mod*mod);}
    complexo potencia( float exp ){return complexo ((pow(modulo(),exp)*cos(exp*argumento()))+(pow(modulo(),exp)*sin(exp*argumento())));}
    complexo operator*( float f ){return complexo(re*f,im*f);}
    complexo operator/( float f ){return complexo(re/f,im/f);}
    float parteReal(){return re;}
    float parteImaginaria (){return im;}
    void imprimir();
}
void main()
{
     complexo z;
     complexo c1(3,2);
     complexo c2(4,1);
     complexo u(c1);
     complexo c3(c1);
     z = c1.conjugado();
     u = c1.operator+(c2);
     z = c1+(c2-c3);
     z = c1.operator+(c2.operator-(c3));
     u = c2*c3;
     z= c1/c2;
     z=c3.conjugado();
     printf("\n\n\n");
     system("pause");

Não consigo imprimir os valores no ecrán =(... (não percebo muito disto ainda). Depois um algoritmo que faz álgebra de matrizes com números naturais e números complexos (aproveitando o algoritmo anterior)...

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

#define N 1000

int matriz_1[N][N],matriz_2[N][N],matriz_3[N][N],lin_1,lin_2,col_1,col_2;

void criar_matriz_1(){

     int i,j;
     system("cls");
     printf("Coloque a quantidade de linhas da matriz 1: ");
     scanf("%d",&lin_1);
     printf("Coloque a quantidade de colunas da matriz 1: ");
     scanf("%d",&col_1);
     system("cls");
     for(i=0;i<lin_1;i++){
           for(j=0;j<col_1;j++){
               printf("Coloque o elemento %d,%d ",i+1,j+1);
               scanf("%d",&matriz_1[i][j]);
       }
     }
     system("cls");
}
void criar_matriz_2(){

     int i,j;
     system("cls");
     printf("Coloque a quantidade de linhas da matriz 2: ");
     scanf("%d",&lin_2);
     printf("Coloque a quantidade de colunas da matriz 2: ");
     scanf("%d",&col_2);
     system("cls");
     for(i=0;i<lin_2;i++){
           for(j=0;j<col_2;j++){
               printf("Coloque o elemento %d,%d ",i+1,j+1);
               scanf("%d",&matriz_2[i][j]);
       }
     }
     system("cls");
}

void pode_Somar(){
     if((col_1 != col_2) && (lin_1 != lin_2)) {
        printf("So pode haver soma se a matriz tiver o mesmo numero de linhas e o mesmo numero de colunas");
        return;
    }}

void soma_duas_matrizes(){

     system("cls");
     int i,j;

     for(i=0;i<lin_1;i++){
         for(j=0;j<col_1;j++){

                      matriz_3[i][j] = matriz_1[i][j] + matriz_2[i][j];

       }
     }

     for(i=0;i<lin_1;i++){
                     printf("| ");
                     for(j=0;j<col_1;j++){
                                      printf("%d ",matriz_3[i][j]);
                                      }
                     printf("|\n");
     }

     printf("Soma das matrizes \n\n\n");


system("pause");

}

void pode_multiplicar(){
     if(col_1 != lin_2) {
        printf("So pode haver multiplicacao se col_1 = lin_2");
        return;
    }}

void multiplica_duas_matrizes(){
     int i,j,k;
     system("cls");
     for(i = 0; i < lin_1; i++) {
     for(j = 0; j < col_2; j++) {                           
     for(k = 0; k < col_1; k++) {
                 matriz_3[i][j] += matriz_1[i][k] * matriz_2[k][j];
     }
     }
     }           
for(i=0;i<lin_1;i++){
                     printf("| ");
                     for(j=0;j<col_1;j++){
                                      printf("%d ",matriz_3[i][j]);
                                      }
                     printf("|\n");}
    printf("Multiplicacao das matriz \n\n\n");
    system("pause");}

void creditos(){

        system("cls");
        printf("+-----------------------------------------------------------+\n");
        printf("|Programa Desenvolvido Por:      *******                    |\n");
        printf("+-----------------------------------------------------------+\n\n\n");

} 

void opcao(){

    int x;
    system("cls");

    do{
       system("cls");
       printf("Escolha uma das opções para execucao do programa.\n");
       printf("+------------------------------------------------------------------------------+");
       printf("|                                                                              |");
       printf("|                                                                              |");
       printf("|1)Criar matrizes.                                 linha x coluna              |");
       printf("|2)Somar as duas matrizes                                                      |");
       printf("|3)Multiplicar as duas matrizes                                                |");
       printf("|4)Autoria do trabalho                                                         |");
       printf("|                                                                              |");
       printf("+------------------------------------------------------------------------------+");

       scanf("%d",&x);
    }
    while(x < 1 || x > 6);

        switch(x){

            case 1:{
                 criar_matriz_1();
                 criar_matriz_2();
                 opcao();
            break;
            }

            case 2:{
                 pode_Somar();
                 soma_duas_matrizes();
                 opcao();
            break;
            } 
            case 3:{
                 pode_multiplicar();
                 multiplica_duas_matrizes();
                 opcao(); 
                 }
            case 4:{
                 creditos();
            break;
            }
      }
}

void menu(){

        system("cls");

        int x;
        printf("+--------------------------------------------------------+\n");
        printf("|        Bem vindo ao Programa Soma da Matriz            |\n");
        printf("|                                                        |\n");
        printf("|        Escolha a opcao:                                |\n");
        printf("|                                                        |\n");
        printf("|        1)Usar o operador                               |\n");
        printf("|        2)Ver Autoria e Sair                            |\n");
        printf("|                                                        |\n");
        printf("|                                                        |\n");
        printf("+--------------------------------------------------------+\n");

        do{
                       scanf("%d",&x);
        }

        while(x < 1 || x > 2);
                if(x == 1)opcao();

        else creditos();

  getch();

}

int main(){

     menu();

return(0);
}

não consegui usar a classe complexo para, agradecia que me ajudassem nesse aspecto pois não sei como ligar os dois algoritmos...

AGORA... as iterações gauss-seidel, isso é durissimo e não sei mesmo como fazer

Pedia a vossa ajuda porque a situação está muito preocupante... queria mesmo acabar o curso agora e este trabalho está no meu caminho =S

fabriciocarraro · 2 de junho de 2011

Dá uma olhada nesse tópico, pode te ajudar:

http://forum.clubedohardware.com.br/como-fazer-esse/936530

Ulti.disciplina · 3 de junho de 2011

Muito obrigado... mas este trabalho só está habilitado a fazer iterações com números naturais... Eu precisava que também o fizesse com números complexos, alguem me dpode dar umas luzes sobre isso!!?