Você está na página 1de 38
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS Mestrado em Engenharia Elétrica THAÍSA RODRIGUES LOBACK

CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS

Mestrado em Engenharia Elétrica

DE MINAS GERAIS Mestrado em Engenharia Elétrica THAÍSA RODRIGUES LOBACK DURÃES 1 a LISTA DE

THAÍSA RODRIGUES LOBACK DURÃES

1 a LISTA DE EXERCÍCIOS:

Erros e Sistemas Lineares

Belo Horizonte 07 de abril de 2015

1.

Introdução

A solução computacional de um dado problema é desenvolvida através das

técnicas de cálculo numérico. Para que a aplicação desses técnicas seja possível, deve-se

seguir a sequência de quatro etapas: definição do problema, modelagem matemática,

solução numérica e análise dos resultados. Ao definir um problema, espera-se chegar a uma determinada solução através da manipulação matemática das variáveis que influenciem essa solução. Nessa primeira etapa, são, então, identificadas essas variáveis e os possíveis resultados para a solução do problema.

A modelagem matemática consiste em se obter equações que relacionem as

variáveis conhecidas com os resultados possíveis. Já a solução numérica, começa pela escolha do método numérico mais apropriado para as condições do problema. Passa-se, então, para a sua descrição computacional através da elaboração de um algoritmo, que, por sua vez é implementado numa das linguagens de programação existentes. Finalmente, o programa é editado em um arquivo e executado pelo computador. Através da análise dos resultados é possível verificar se houve adequação da solução numérica ao problema real, anteriormente definido. Observa-se também, nessa etapa, os possíveis erros que a modelagem matemática e sua implementação pode incorrer. Este relatório tem o objetivo de introduzir alguns métodos na solução computacional de problemas de álgebra linear. Procura-se a implementação de algoritmos práticos, com baixo custo computacional e com menor infringência de erros. Utiliza-se a linguagem de programação C++ para elaboração dos algoritmos e sua compilação pelo programa DEV C/C++. Para melhor segurança em relação ao uso das técnicas apresentadas, comparou-se alguns resultados com os obtidos pelo programa Matlab.

2. Exercícios Propostos

1) Desenvolva um algoritmo em C para realizar a multiplicação de duas matrizes. Não se esqueçam de verificar se a multiplicação é possível antes de realizá-la. Teste os resultados obtidos com aqueles gerados pelo MATLAB. Considerar precisão simples e precisão estendida. Para comparar os resultados calcule a norma 2 da matriz resultado. Comente!

2) Desenvolva um algoritmo em C para resolver sistemas lineares triangulares (Superior e Inferior). Teste os resultados obtidos com aqueles gerados pelo MATLAB. Considerar precisão simples e precisão estendida. Para comparar os resultados calcule a norma 2 da matriz resultado. Comente!

3) Desenvolva um algoritmo em C para resolver sistemas lineares utilizando eliminação de Gauss com pivoteamento. Como subproduto calcule o determinante da matriz. Considerar precisão simples e precisão estendida. Para comparar os resultados calcule a norma 2 da matriz resultado. Comente!

4) Apresente uma pesquisa sobre aplicação de sistemas lineares nas seguintes áreas: Eletromagnetismo, controle, SEP, modelagem de sistemas. Apresente no mínimo 4 aplicações por área, faça uma breve descrição de cada uma delas

destacando as características das matrizes e os métodos utilizados para a solução

do sistema.

3.

Resolução

1º Exercício:

A forma geral de representação de um número na atimética de ponto flutuante

tem a seguinte notação científica:

onde os

’s são os dígitos da parte fracionária, tais que

B é o valor da base (geralmente 2, 10 ou 16), é o número de dígitos e é um expoente inteiro. Deste modo, um número de ponto flutuante tem três partes: o sinal, a parte fracionária (chamada de significando ou mantissa) e o expoente. Essas três partes têm um comprimento total fixo que depende do computador e do tipo de número: precisão simples, dupla ou estendida.

A Tabela 1 mostra formato proposto pelo IEEE (Insitute of Electrical and

Electronics Engineers), utilizado pela maioria dos computadores do mundo:

Tabela 1: Formato IEE de ponto flutuante

   

Precisão

Propriedade

Simples

Dupla

Estendida

Comprimento total

32

64

80

Bits na mantissa

23

52

64

Bits no expoente

8

11

15

Base

2

2

2

Expoente máximo

127

1023

16383

Expoente mínimo

-126

-1022

-16382

Maior número

     

Menor número

     

Dígitos decimais

7

16

19

Neste primeiro exercício proposto, o objetivo é verificar se é possível a multiplicação de duas matrizes dadas pelo usuário, realizar a multiplicação dessas matrizes, tanto na precisão simples, quanto na estendida, calcular a norma-2 da matriz para os dois casos e comparar os resultados com aqueles obtidos no Matlab.

Para que a multiplicação de matrizes seja possível, basta que o número de colunas da primeira matriz seja igual ao número de linhas da segunda matriz. O método utilizado para o cálculo foi com base na relação das posições dos elementos de cada matriz e suas equações para a obtenção da matriz resultante.

O algoritmo desenvolvido para a multiplicação de matrizes na precisão simples é mostrado a seguir:

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

int main ()

{

//Variaveis com numeros de linhas e colunas da matriz 1 short int numeroLinhaMatriz1 = 0; short int numerocolunasMatriz1 = 0;

//Variaveis com numeros de linhas e colunas da matriz 2 short int numeroLinhaMatriz2 = 0; short int numerocolunasMatriz2 = 0;

//Entrada de dados com os numero de linhas e colunas das matrizes printf ("****** Primeira Matriz ******\n"); printf ("Entre com o numero de linhas da matriz 1 (maximo 10): "); scanf ("%hd", &numeroLinhaMatriz1);

printf ("Entre com o numero de colunas da matriz 1 (maximo 10): ");

scanf ("%hd", &numerocolunasMatriz1);

printf ("\n****** Segunda Matriz ******\n"); printf ("Entre com o numero de linhas da matriz 2 (maximo 10): "); scanf ("%hd", &numeroLinhaMatriz2);

printf ("Entre com o numero de colunas da matriz 2 (maximo 10): "); scanf ("%hd", &numerocolunasMatriz2); if (numerocolunasMatriz1 == numeroLinhaMatriz2)

{

//Numero de elementos da matriz resultante short int numeroElementosMatrizResultante = numeroLinhaMatriz1 * numerocolunasMatriz2; printf ("\n\nNumero de elementos da matriz resultante: %hd\n", numeroElementosMatrizResultante);

//Alocando a primeira matriz float matriz1[10][10];

//Alocando a segunda matriz float matriz2[10][10];

int contLinha, contColuna; float valor; //Preenchedo a matriz 1 printf ("\n****** Entre com os valores da primeira matriz ******\n"); for (contLinha=0; contLinha<numeroLinhaMatriz1; contLinha++)

{

for (contColuna=0; contColuna<numerocolunasMatriz1; contColuna++)

{

valor = 0; printf ("Linha %d coluna %d: ", contLinha, contColuna); scanf ("%10f", &valor); matriz1[contLinha][contColuna] = valor;

}

}

//Iniciando variaveis contadoras

contLinha = 0; contColuna = 0; //Preenchedo a matriz 2

printf ("\n****** Entre com os valores da segunda matriz ******\n"); for (contLinha=0; contLinha<numeroLinhaMatriz2; contLinha++)

{

for (contColuna=0; contColuna<numerocolunasMatriz2; contColuna++)

{

valor = 0; printf ("Linha %d coluna %d: ", contLinha, contColuna); scanf ("%10f", &valor); matriz2[contLinha][contColuna] = valor;

}

}

//Define numero de linhas e colunas da matriz resultante int numeroLinhaMatrizResultante = numeroLinhaMatriz1; int numerocolunasMatrizResultante = numerocolunasMatriz2;

//Alocando a matriz resultante float matrizResultante[10][10];

//Iniciando variaveis contadoras contLinha = 0; contColuna = 0; int contQuebra = 0; printf ("\n****** Resultado da multiplicacao das matrizes ******\n");

//Multiplicando matriz1 com a matriz2 for(contLinha = 0; contLinha < numeroLinhaMatriz1; contLinha++)

{

 

for(contColuna = 0; contColuna < numerocolunasMatriz2; contColuna++)

{

float soma = 0;

for(contQuebra = 0; contQuebra < numerocolunasMatriz1; contQuebra++)

{

soma = soma + matriz1[contLinha][contQuebra] * matriz2[contQuebra][contColuna];

}

matrizResultante[contLinha][contColuna] = soma;

}

}

contLinha = 0; contColuna = 0;

for(contLinha = 0; contLinha < numeroLinhaMatrizResultante; contLinha++)

{

for(contColuna = 0; contColuna < numerocolunasMatrizResultante; contColuna++)

{

printf ("Linha %d coluna %d: %10f \n", contLinha, contColuna, matrizResultante[contLinha][contColuna]);

}

}

float soma = 0; float normaMatriz = 0;

for(int w=0;w<numeroLinhaMatrizResultante;w++)

{

for(int z = 0;z<numerocolunasMatrizResultante;z++)

{

soma=soma+pow(matrizResultante[w][z],2);

}

}

//sqrt(parameter) function for square root, declared in math.h

normaMatriz=sqrt(soma);

printf("\n Norma da Matriz: %f\n",normaMatriz); system("pause");

}

else

{

printf ("\n\n!!!! Erro\n"); printf ("ERRO!!!! Não é possível multiplicar:\n Numero de colunas da primeira matriz diferente do numero de linhas da segunda matriz\n\n"); system("pause");

}

}

return 0;

Coloca-se como observação que tanto o algoritmo anterior, como o que vêm a seguir, declaram matrizes correspondentes a sistemas de ordem máxima igual a 10. Para sistemas de ordem superiores, basta trocar as declarações das matrizes para as da ordem desejada. Além disso, o algoritmo para o cálculo da norma 2 está incluso no algoritmo acima. A seguir apesenta-se o mesmo algoritmo na precisão estendida (única diferença do algoritmo anterior). O código da norma 2, embora tenha sido implementado na próxima rotina computacional, foi omitido para evitar vãs repetições.

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

int main ()

{

//Variaveis com numeros de linhas e colunas da matriz 1 int numeroLinhaMatriz1 = 0; int numerocolunasMatriz1 = 0;

//Variaveis com numeros de linhas e colunas da matriz 2 int numeroLinhaMatriz2 = 0; int numerocolunasMatriz2 = 0;

//Entrada de dados com os numero de linhas e colunas das matrizes printf ("****** Primeira Matriz ******\n"); printf ("Entre com o numero de linhas da matriz 1 (maximo 10): "); scanf ("%d",&numeroLinhaMatriz1);

printf ("Entre com o numero de colunas da matriz 1 (maximo 10): "); scanf ("%d", &numerocolunasMatriz1);

printf ("\n****** Segunda Matriz ******\n");

printf ("Entre com o numero de linhas da matriz 2 (maximo 10): ");

scanf ("%d", &numeroLinhaMatriz2);

printf ("Entre com o numero de colunas da matriz 2 (maximo 10): "); scanf ("%d", &numerocolunasMatriz2);

if (numerocolunasMatriz1 == numeroLinhaMatriz2)

{

//Numero de elementos da matriz resultante int numeroElementosMatrizResultante = numeroLinhaMatriz1 * numerocolunasMatriz2; printf ("\n\nNumero de elementos da matriz resultante: %d\n", numeroElementosMatrizResultante);

//Alocando a primeira matriz long double matriz1[10][10];

//Alocando a segunda matriz long double matriz2[10][10];

int contLinha, contColuna;

long double valor;

//Preenchedo a matriz 1 printf ("\n****** Entre com os valores da primeira matriz ******\n"); for (contLinha=0; contLinha<numeroLinhaMatriz1; contLinha++)

{

for (contColuna=0; contColuna<numerocolunasMatriz1; contColuna++)

{

valor = 0; printf ("Linha %d coluna %d: ", contLinha, contColuna); scanf ("%Lf", &valor); matriz1[contLinha][contColuna] = valor;

}

}

//Iniciando variaveis contadoras contLinha = 0; contColuna = 0; //Preenchedo a matriz 2

printf ("\n****** Entre com os valores da segunda matriz ******\n"); for (contLinha=0; contLinha<numeroLinhaMatriz2; contLinha++)

{

for (contColuna=0; contColuna<numerocolunasMatriz2; contColuna++)

{

valor = 0;

printf ("Linha %d coluna %d: ", contLinha, contColuna); scanf ("%Lf", &valor);

matriz2[contLinha][contColuna] = valor;

}

}

//Define numero de linhas e colunas da matriz resultante int numeroLinhaMatrizResultante = numeroLinhaMatriz1; int numerocolunasMatrizResultante = numerocolunasMatriz2;

//Alocando a matriz resultante long double matrizResultante[10][10];

//Iniciando variaveis contadoras contLinha = 0; contColuna = 0; int contQuebra = 0; long double soma = 0;

printf ("\n****** Resultado da multiplicacao das matrizes ******\n");

for(contLinha = 0; contLinha < numeroLinhaMatriz1; contLinha++)

{

for(contColuna = 0; contColuna < numerocolunasMatriz2; contColuna++)

{

soma = 0;

for(contQuebra = 0; contQuebra < numerocolunasMatriz1; contQuebra++)

{

soma = soma + (matriz1[contLinha][contQuebra]*matriz2[contQuebra][contColuna]) ;

}

matrizResultante[contLinha][contColuna] = soma;

}

}

contLinha = 0; contColuna = 0;

for(contLinha = 0; contLinha < numeroLinhaMatrizResultante; contLinha++)

{

for(contColuna = 0; contColuna < numerocolunasMatrizResultante; contColuna++)

{

printf ("Linha %d coluna %d: %Lf\n", contLinha, contColuna, matrizResultante[contLinha][contColuna]);

}

}

}

else

{

printf ("\n\n!!!! Erro\n");

printf ("ERRO!!!! Não é possível multiplicar:\n Numero de colunas da primeira matriz diferente do numero de linhas da segunda matriz\n\n"); system("pause");

}

}

return 0;

2º Exercício:

O algoritmo elaborado para esse exercício pede que o usuário escolha se o sistema será triangular inferior ou superior. Para o sistema triangular inferior, os elementos cuja posição da linha tem valor menor que a posição da coluna são automaticamente preenchidos com zeros e o sistema é solucionado pela expressão a seguir:

x

i

  

l

l

l

11

21

n

1

l

l

0

22

n

2

0

0

.,.

l

nn

 

.

x  

1

x

x

2

n

c

i

i 1

j 1

l

ij

x

j

l ij

,

i

.

c  

cn

1

c

2

1,2,

,

n

.

Para o sistema triangular superior, ocorre o contrário, os elementos cuja posição da linha é superior à da coluna é que são preenchidos com zero. Esse sistema é, por sua vez, solucionado a partir das seguintes equações:

x

i

u

11 12

0

0

u

22

0

u

u

u

.,.

u

1 n

2 n

nn

 

.

x

1

x

x

2

n

.

d

1

d

d

2

n

d

i

n

ij

l

j 

i

1

x

j

u

ii

, ,

i

n n

1,

,1.

A seguir são apresentados os algoritmos desenvolvidos para a resolução de sistemas triangulares superior e inferior, respectivamente, na precisão simples e estendida. Da mesma forma que no exercício anterior, a rotina para o cálculo da norma 2 é mostrada apenas no primeiro algoritmo e as matrizes declaradas corespondem a sistemas de ordem máxima igual a 10. Para sistemas de ordem superiores, basta trocar as declarações das matrizes para as da ordem desejada.

#include<stdio.h> #include<stdlib.h> #include<math.h> int main () { int ordemDoSistema = 0; char

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

int main ()

{

int ordemDoSistema = 0; char seSuperiorOuInferior;

//Ordem do sistema printf ("Digite a ordem do sistema (maximo 10): "); scanf ("%d", &ordemDoSistema);

//Verifica se o sistema e triangular superior ou inferior printf ("\n\nO Sistema e triangular superior ou inferior?\n (Digite S para superior ou I para inferior): "); scanf(" %c", &seSuperiorOuInferior);

//Entra com a matriz dos termos independentes printf ("\n\n Entre com a matriz dos termos independentes\n");

float matrizTermosIndependentes[10];

float coeficiente;

for (int a = 0; a < ordemDoSistema; a++)

{

coeficiente = 0; printf ("Termo %d: ", a); scanf ("%f", &coeficiente); matrizTermosIndependentes[a] = coeficiente;

}

int contLinha, contColuna; //Alocando a matriz float matriz[10][10]; float valor; //Preenchedo a matriz dos coeficientes

figure(2)

printf ("\n****** Entre com os valores da matriz dos coeficientes******\n");

subplot(3,2,1);

plot(t1A,p1A);

for (contLinha=0; contLinha<ordemDoSistema; contLinha++)

gridon

{

xlabel'Tempo (s)';

ylabel'Potência (W)';

title'Potência Ativa 1a noite';

for (contColuna=0; contColuna<ordemDoSistema; contColuna++)

subplot(3,2,2);

{

plot(t1A,q1A);

gridon

if(seSuperiorOuInferior == 'S' || seSuperiorOuInferior == 's')

xlabel'Tempo (s)';

ylabel'Potência (VAr)';

{

title'Potência Reativa 1a noite';

if(contLinha>contColuna)

plot(t2A,p2A);

subplot(3,2,3);

{

gridon

matriz[contLinha][contColuna]=0;

xlabel'Tempo (s)';

}

ylabel'Potência (W)'; title'Potência Ativa 2a noite';

else

{

xlabel 'Tempo (s)' ; } ylabel 'Potência (W)' ; title 'Potência Ativa 2a noite' ; else

valor = 0;

printf ("Linha %d coluna %d: ", contLinha, contColuna); scanf ("%f", &valor); matriz[contLinha][contColuna] = valor;

}

}

else

{

 

if(seSuperiorOuInferior == 'S' || seSuperiorOuInferior == 's')

{

if(contLinha<contColuna)

{

matriz[contLinha][contColuna]=0;

}

else

{

valor = 0; printf ("Linha %d coluna %d: ", contLinha, contColuna); scanf ("%f", &valor);

matriz[contLinha][contColuna] = valor;

}

}

else

{

printf("ERRO!!! ESSE SISTEMA NÃO É TRIANGULAR);

}

}

}

}

float matrizResultado[10]; float numerador; float denominador; int count = 0;

//Se for superior

if(seSuperiorOuInferior == 'S' || seSuperiorOuInferior == 's')

{

 

for (int i = ordemDoSistema-1; i >= 0; i--)

{

numerador = 0; denominador = 0; numerador = matrizTermosIndependentes[i];

for(int j = 0; j < count; j++)

{

numerador -= matriz[i][i+j+1] * matrizResultado[i +j+ 1];

}

denominador = matriz[i][i];

matrizResultado[i] = numerador / denominador; count = count + 1;

}

}

else

{

if(seSuperiorOuInferior == 'I' || seSuperiorOuInferior == 'i')

{

 

for (int w = 0; w < ordemDoSistema; w++)

{

numerador = 0;

denominador = 0; numerador = matrizTermosIndependentes[w]; for(int j = 0; j < count; j++)

{

numerador -= matriz[w][w - j -1] * matrizResultado[w - j - 1];

}

denominador = matriz[w][w]; matrizResultado[w] = numerador / denominador; count = count + 1;

}

}

}

//Imprime matriz resultado printf ("\n******Resultado******\n");

for (int k=0; k < ordemDoSistema; k++)

{

printf ("%f\n", matrizResultado[k]);

}

// Cálculo da norma 2 float adiciona = 0; float normaMatriz = 0;

for(int w=0;w<ordemDoSistema;w++)

{

adiciona=adiciona+pow(matrizResultado[w],2);

}

//sqrt(parameter) function for square root, declared in math.h normaMatriz=sqrt(adiciona); printf("\n Norma da Matriz: %f\n",normaMatriz); system("pause");

}

Para a precisão estendida, tem-se:

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

int main ()

{

int ordemDoSistema = 0; char seSuperiorOuInferior;

//Ordem do sistema

printf ("Digite a ordem do sistema (maximo 10): "); scanf ("%d", &ordemDoSistema);

//Verifica se o sistema e triangular superior ou inferior printf ("\n\nO Sistema e triangular superior ou inferior?\n (Digite S para superior ou I para inferior): "); scanf(" %c" &seSuperiorOuInferior);

//Entra com a matriz dos termos independentes printf ("\n\n Entre com a matriz dos termos independentes\n");

float matrizTermosIndependentes[10]; float coeficiente;

for (int a = 0; a < ordemDoSistema; a++)

{

coeficiente = 0; printf ("Termo %d: ", a); scanf ("%f", &coeficiente); matrizTermosIndependentes[a] = coeficiente;

}

int contLinha, contColuna;

//Alocando a matriz

float matriz[10][10];

float valor;

//Preenchedo a matriz dos coeficientes printf ("\n****** Entre com os valores da matriz dos coeficientes******\n"); for (contLinha=0; contLinha<ordemDoSistema; contLinha++)

{

 

for (contColuna=0; contColuna<ordemDoSistema; contColuna++)

{

if(seSuperiorOuInferior == 'S' || seSuperiorOuInferior == 's')

{

if(contLinha>contColuna)

{

matriz[contLinha][contColuna]=0;

}

else

{

valor = 0;

printf ("Linha %d coluna %d: ", contLinha, contColuna);

scanf ("%f", &valor); matriz[contLinha][contColuna] = valor;

}

}

else

{

if(seSuperiorOuInferior == 'S' || seSuperiorOuInferior == 's')

{

if(contLinha<contColuna)

{

matriz[contLinha][contColuna]=0;

}

else

{

valor = 0; printf ("Linha %d coluna %d: ", contLinha, contColuna);

}

}

scanf ("%f", &valor); matriz[contLinha][contColuna] = valor;

}

else

{

}

printf("ERRO!!! ESSE SISTEMA NÃO É TRIANGULAR");

}

}

}

}

float matrizResultado[10]; float numerador; float denominador; int count = 0;

//Se for superior

if(seSuperiorOuInferior == 'S' || seSuperiorOuInferior == 's')

{

 

for (int i = ordemDoSistema-1; i >= 0; i--)

{

numerador = 0; denominador = 0;

numerador = matrizTermosIndependentes[i];

for(int j = 0; j < count; j++)

{

numerador -= matriz[i][i+j+1] * matrizResultado[i +j+ 1];

}

denominador = matriz[i][i];

matrizResultado[i] = numerador / denominador;

count = count + 1;

}

}

else

{

if(seSuperiorOuInferior == 'I' || seSuperiorOuInferior == 'i')

{

for (int w = 0; w < ordemDoSistema; w++)

{

numerador = 0; denominador = 0; numerador = matrizTermosIndependentes[w];

for(int j = 0; j < count; j++)

{

numerador -= matriz[w][w - j -1] * matrizResultado[w - j - 1];

for(int j = 0; j < count; j++)

{

numerador -= matriz[w][w - j -1] * matrizResultado[w - j - 1];

}

denominador = matriz[w][w]; matrizResultado[w] = numerador / denominador; count = count + 1;

}

}

}

//Imprime matriz resultado

printf ("\n******Resultado******\n"); for (int k=0; k < ordemDoSistema; k++)

{

printf ("%f\n", matrizResultado[k]);

}

float soma = 0; float normaMatriz = 0;

for(int z = 0;z<ordemDoSistema;z++)

{

soma=soma+pow(matrizResultado[z],2);

}

//sqrt(parameter) function for square root, declared in math.h normaMatriz=sqrt(soma);

printf("\n Norma da Matriz: %d\n",normaMatriz);

}

system("pause");

return 0;

3º Exercício:

.O método da eliminação de Gauss consiste em transformar o sistema linear original num outro sistema linear equivalente com matriz dos coeficientes triangular superior, pois estes são de resolução imediata. Dizemos que dois sistemas lineares são equivalentes quando possuem a mesma solução. O determinante de sistemas lineares equivalentes são iguais.

Com (n − 1) passos o sistema linear

Ax = B é transformado num sistema

triangular equivalente: Ux= C, o qual se resolve facilmente por substituições.

Obtêm-se a solução de Ax= B em três etapas:

1ª etapa: Matriz Completa

Consiste em escrever a matriz completa ou aumentada do sistema linear original.

2ª etapa: Triangulação

Consiste em transformar a matriz A numa matriz triangular superior, mediante uma seqüência de operações elementares nas linhas da matriz.

3ª etapa: Retro-substituição

Ax= B, a partir da

solução do último componente (x n ), e então o substitui regressivamente nas equações anteriores.

Consiste no cálculo dos componentes x 1 ,

x 2 ,

, x n , solução de

Teorema: Seja Ax = B um sistema linear. Aplicando sobre as equações deste sistema uma seqüência de operações elementares escolhidas entre:

i) Trocar a ordem de duas equações do sistema;

ii) Multiplicar uma equação do sistema por uma constante não nula;

iii) Adicionar um múltiplo de uma equação a uma outra equação;

obtemos um novo sistema Ux= C e os sistemas Ax= B e Ux= C são equivalentes.

O algoritmo para o método de eliminação de Gauss requer o cálculo dos

multiplicadores:

a cada etapa

do processo. Sendo o coeficiente

chamado de pivô.

Se o pivô for nulo ou se o pivô estiver próximo de zero uma atenção especial de

ve ser tomada, pois é impossível trabalhar com um pivô nulo. E trabalhar com um pivô

próximo de zero pode resultarem resultados totalmente imprecisos. Isto porque em qualquer calculadora ou computador os cálculos são efetuados com precisão finita, e pivôs próximos de zero são origem a multiplicadores bem maiores que a unidade que, por sua vez, origina uma ampliaçãodos erros de arredondamento.

Para

se

contornar

esses

problemas

deve-se

adotar

uma

estratégia

de

pivoteamento, ou seja, adotar um processo de escolha da linha e/ou coluna pivotal.

Esta estratégia consiste em:

i) no início da etapa k da fase de escalonamento, escolher para pivô o elemento de maior

módulo entre os coeficientes:

.

ii) trocar as linhas k e

se for necessário.

A seguir são apresentados os algoritmos desenvolvidos para a resolução de

sistemas lineares pelo método de Gauss com pivotamento, na precisão simples e estendida respectivamente. Para a resolução do sistema triangular superior resultante,

utilizou-se os algoritmos já implementados no exercício anterior e obteve-se a norma 2, cuja rotina já foi evidenciada nos exercícios anteriores, para os dois tipos de precisão.

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

int main ()

{

//Variaveis com numeros de linhas e colunas da matriz unsigned int ordem; //Escolha da ordem do sistema printf ("****** Ordem do Sistema ******\n"); printf ("Entre com a ordem do sistema (maximo 10): "); scanf ("%d", &ordem);

//Alocando as matrizes dos coeficientes e dos termos independentes float mcoeficientes[10][10]; float mindependentes[10];

char S; unsigned int x, y;

float valor;

//Preenchedo as matrizes do sistema printf ("\n****** Entre com os valores da matriz dos coeficientes ******\n"); for (x=0; x<ordem; x++)

{

for (y=0; y<ordem; y++)

{

valor = 0; printf ("Linha %d coluna %d: ", x, y); scanf ("%10f", &valor); mcoeficientes[x][y] = valor;

}

}

printf ("\n****** Entre com os valores da matriz dos termos independentes ******\n"); for (y=0; y<ordem; y++)

{

 

valor = 0; printf ("Coluna %d: ", y);

scanf ("%10f", &valor);

mindependentes[y] = valor;

}

printf("\n");

// Pivoteamento float pivo, a; float guardapivo[10], novaindependentes[10], X[10]; float triangsuperior[10][10], m[10][10], b[10][10]; unsigned int linhapivo, k, j; int pospivo[10]; unsigned int novaordem=ordem;

for (x=0; x<ordem; x++)

{

linhapivo=0;

a=fabs(mcoeficientes[0][0]);

// Identifica o pivô e sua posição for (y=0; y<novaordem; y++)

{

if(fabs(mcoeficientes[y][x])>a)

{

a=fabs(mcoeficientes[y][x]);

pivo=mcoeficientes[y][x];

linhapivo=y;

}

}

// Índices das linhas pivotais pospivo[x]=linhapivo;

// Valores da matriz triangular superior for (j=0; j<ordem; j++)

{

if(x <= j)

{

triangsuperior[x][j] = mcoeficientes[linhapivo][j];

}

else

{

triangsuperior[x][j] =0;

}

}

novaindependentes[x] = mindependentes[linhapivo];

// Cálculo dos multiplicadores for (k=0; k<novaordem; k++)

{

 

if(k!=linhapivo)

{

m[k][x]= 0 - (mcoeficientes[k][x]/pivo); printf("\nmultiplicador %d%d: %f\n", k, x, m[k][x]);

for (j=0; j<ordem; j++)

{

mcoeficientes[k][j]= (m[k][x]*mcoeficientes[linhapivo][j])+ mcoeficientes[k][j];

}

mindependentes[k]= (m[k][x]*mindependentes[linhapivo])+ mindependentes[k];

}

}

// Modificação de Ordem

if(x==0)

{

novaordem = ordem - 1;

}

else

{ novaordem = novaordem - 1; } } printf("\n\n************* MATRIZ TRIANGULAR SUPERIOR ******************\n");
{
novaordem = novaordem - 1;
}
}
printf("\n\n************* MATRIZ TRIANGULAR SUPERIOR ******************\n");
for (x=0; x<ordem; x++)
{
for (y=0; y<ordem; y++)
{
printf ("Linha %d coluna %d: %10f \n", x, y, triangsuperior[x][y] );
}
}
printf("\n\n************* MATRIZ DOS TERMOS INDEPENDENTES ****************\n");
// Imprime a nova matriz dos termos independentes
for (j=0; j<ordem; j++)
{
printf("Termo %d: %f\n", j, novaindependentes[j]);
printf("Posicao do pivo: %d\n", pospivo[j]);
}
system("pause");
}

RESULTADOS

1º Exercício:

O algoritmo rodado em Dev C++, com precisão simples, apresentou o seguinte resultado:

****** Primeira Matriz ******

Entre com o numero de linhas da matriz 1: 5

Entre com o numero de colunas da matriz 1: 2

****** Segunda Matriz ******

Entre com o numero de linhas da matriz 2: 2

Entre com o numero de colunas da matriz 2: 7

Numero de elementos da matriz resultante e igual a: 35

****** Entre com os valores da primeira matriz ******

Linha 0 coluna 0: 3.145

Linha 0 coluna 1: 0.234

Linha 1 coluna 0: 0.002

Linha 1 coluna 1: 10.42

Linha 2 coluna 0: 8.44

Linha 2 coluna 1: 0.03

Linha 3 coluna 0: 6.12

Linha 3 coluna 1: 0.15

Linha 4 coluna 0: 0.014

Linha 4 coluna 1: 12

****** Entre com os valores da segunda matriz ******

Linha 0 coluna 0: 2.35

Linha 0 coluna 1: 6.36

Linha 0 coluna 2: 0.179

Linha 0 coluna 3: 0.098

Linha 0 coluna 4: 0.432

Linha 0 coluna 5: 9.32

Linha 0 coluna 6: 7.77

Linha 1 coluna 0: 4.32

Linha 1 coluna 1: 8.43

Linha 1 coluna 2: 0.086

Linha 1 coluna 3: 3.75

Linha 1 coluna 4: 0.734

Linha 1 coluna 5: 8.95

Linha 1 coluna 6: 7.33

****** Resultado da multiplicacao das matrizes ******

Linha 0 coluna 0: 8.401629

Linha 0 coluna 1: 21.974821

Linha 0 coluna 2: 0.583079

Linha 0 coluna 3: 1.185710

Linha 0 coluna 4: 1.530396

Linha 0 coluna 5: 31.405699

Linha 0 coluna 6: 26.151869

Linha 1 coluna 0: 45.019104

Linha 1 coluna 1: 87.853325

Linha 1 coluna 2: 0.896478

Linha 1 coluna 3: 39.075195

Linha 1 coluna 4: 7.649144

Linha 1 coluna 5: 93.277641

Linha 1 coluna 6: 76.394142

Linha 2 coluna 0: 19.963598

Linha 2 coluna 1: 53.931297

Linha 2 coluna 2: 1.513340

Linha 2 coluna 3: 0.939620

Linha 2 coluna 4: 3.668100

Linha 2 coluna 5: 78.929298

Linha 2 coluna 6: 65.798698

Linha 3 coluna 0: 15.029999

Linha 3 coluna 1: 40.187698

Linha 3 coluna 2: 1.108380

Linha 3 coluna 3: 1.162260

Linha 3 coluna 4: 2.753940

Linha 3 coluna 5: 58.380898

Linha 3 coluna 6: 48.651897

Linha 4 coluna 0: 51.872902

Linha 4 coluna 1: 101.249046

Linha 4 coluna 2: 1.034506

Linha 4 coluna 3: 45.001373

Linha 4 coluna 4: 8.814049

Linha 4 coluna 5: 107.530479

Linha 4 coluna 6: 88.068779

A norma da Matriz é: 289.776093

Pressione qualquer tecla para

Pelo Matlab obtem-se os seguintes resultados para o resultado da multiplicação e sua norma:

A =

3.1450

0.2340

0.0020

10.4200

8.4400

0.0300

6.1200

0.1500

0.0140

12.0000

B =

2.3500

6.3600

0.1790

0.0980

0.4320

9.3200

7.7700

4.3200

8.4300

0.0860

3.7500

0.7340

8.9500

7.3300

Resultado =

8.4016

21.9748

0.5831

1.1857

1.5304

31.4057

26.1519

45.0191

87.8533

0.8965

39.0752

7.6491

93.2776

76.3941

19.9636

53.9313

1.5133

0.9396

3.6681

78.9293

65.7987

15.0300

40.1877

1.1084

1.1623

2.7539

58.3809

48.6519

51.8729 101.2490

1.0345

45.0014

8.8140 107.5305

88.0688

norma =

287.1871

>>

Não houve diferenças significativas da precisão simples para a dupla. Observou- se que com uma maior precisão, o comprimento da matriz fica levemente inferior.

2º Exercício:

O algoritmo rodado em Dev C++, com precisão simples, apresentou o seguinte resultado para um sistema triangular superior:

Digite a ordem do sistema (maximo 10): 3

O Sistema e triangular superior ou inferior?

(Digite S para superior ou I para inferior): S

Entre com a matriz dos termos independentes

Termo 0: 1.4142135

Termo 1: 3.1415926

Termo 2: 1.7320508

****** Entre com os valores da matriz dos coeficientes******

Linha 0 coluna 0: 3.1415926

Linha 0 coluna 1: 2.7182818

Linha 0 coluna 2: 1.4142135

Linha 1 coluna 1: 1.4142135

Linha 1 coluna 2: 1.7320508

Linha 2 coluna 2: 2.7182818

******Resultado******

-1.083555

1.441051

0.637186

Norma da Matriz: 1.9112257

Press any key to continue

A mesma implementação feita em Matlab (precisão double):

>> A

A =

3.1416

2.7183

1.4142

0

1.4142

1.7321

0

0

2.7183

>> B

B =

1.4142

3.1416

1.7321

>> c=inv(A)*B

c =

-1.0836

1.4411

0.6372

>> norm(c)

ans =

1.9123

Para esse exemplo, observa-se que a precisão simples obtem praticamente os mesmos valores que a precisão double. O resultado para um sistema triangular inferior com precisão simples é apresentado a seguir:

Digite a ordem do sistema (maximo 10): 3

O Sistema e triangular superior ou inferior?

(Digite S para superior ou I para inferior): I

Entre com a matriz dos termos independentes

Termo 0: 1.4142135

Termo 1: 3.1415826

Termo 2: 1.7320508

****** Entre com os valores da matriz dos coeficientes******

Linha 0 coluna 0: 3.1415926

Linha 1 coluna 0: 2.7182818

Linha 1 coluna 1: 1.4142135

Linha 2 coluna 0: 1.4142135

Linha 2 coluna 1: 1.7320508

Linha 2 coluna 2: 2.7182818

******Resultado******

0.450158

1.356178

-0.461151

Norma da Matriz: 1.501507

Press any key to continue

A implementação do mesmo sistema triangular inferior, feita em Matlab

(precisão double):

A=[3.1415926 0 0; 2.7182818 1.4142135 0; 1.4142135 1.7320508 2.7182818] A = 3.1416 0 0 2.7183
A=[3.1415926 0 0; 2.7182818 1.4142135 0; 1.4142135 1.7320508 2.7182818]
A =
3.1416
0
0
2.7183
1.4142
0
1.4142
1.7321
2.7183
>> B=[1.4142135; 3.1415826;1.7320508]
B =
1.4142
3.1416
1.7321
>> C=inv(A)*B
C =
0.4502
1.3562
-0.4612
>> norma=norm(C)
norma =
1.5015

Mais uma vez os resultados da precisão simples e dupla foram os mesmos.

3º Exercício:

O método de Gauss com pivoteamento foi rodado e apresentou os seguintes

resultados para precisão simples:

****** Ordem do Sistema ******

Entre com a ordem do sistema (maximo 10): 3

****** Entre com os valores da matriz dos coeficientes ******

Linha 0 coluna 0: 1

Linha 0 coluna 1: -3

Linha 0 coluna 2: 2

Linha 1 coluna 0: -2

Linha 1 coluna 1: 8

Linha 1 coluna 2: -1

Linha 2 coluna 0: 4

Linha 2 coluna 1: -6

Linha 2 coluna 2: 5

****** Entre com os valores da matriz dos termos independentes ******

Coluna 0: 11

Coluna 1: -15

Coluna 2: 29

multiplicador 00: -0.250000

multiplicador 10: 0.500000

multiplicador 01: 0.300000

************* MATRIZ TRIANGULAR SUPERIOR ******************

Linha 0 coluna 0:

4.000000

Linha 0 coluna 1: -6.000000

Linha 0 coluna 2:

5.000000

Linha 1 coluna 0:

0.000000

Linha 1 coluna 1:

5.000000

Linha 1 coluna 2:

1.500000

Linha 2 coluna 0:

0.000000

Linha 2 coluna 1:

0.000000

Linha 2 coluna 2:

1.200000

************* MATRIZ DOS TERMOS INDEPENDENTES ****************

Termo 0: 29.000000

Termo 1: -0.500000

Termo 2: 3.600000

******************* VALOR DO DETERMINANTE *************************

Valor do determinante: -24.000000

Press any key to continue

Digite a ordem do sistema (maximo 10): 3

O Sistema e triangular superior ou inferior?

(Digite S para superior ou I para inferior): S

Entre com a matriz dos termos independentes

Termo 0: 29

Termo 1: -0.5

Termo 2: 3.6

****** Entre com os valores da matriz dos coeficientes******

Linha 0 coluna 0: 4

Linha 0 coluna 1: -6

26

Linha 0 coluna 2: 5

Linha 1 coluna 1: 5

Linha 1 coluna 2: 1.5

Linha 2 coluna 2: 1.2

******Resultado******

2.000000

-1.000000

3.000000

Norma da Matriz: 3.741657

Press any key to continue

4º Exercício: Pesquisa sobre aplicação de sistemas lineares nas áreas de Eletromagnetismo, SEP, controle e modelagem de sistemas

4.1. Eletromagnetismo

Método das Diferenças Finitas

O Método das Diferenças Finitas apresenta soluções diretas para campos elétricos e magnéticos nos pontos de uma malha regular formada pela discretização de uma superfície ou volume de um objeto. Para tanto, divide-se o domínio de cálculo em diversos pontos calcula-se o campo elétrico correspondente a cada ponto a partir dos valores de pontos adjacentes.

Essa técnica numérica possibilita resolver situções que abrangem equações diferenciais parciais (EDPs), que são equações envolvendo uma função de variáveis independentes e suas derivadas. Assim, essa viabilidade permite resolver equacções como as de Poisson e as de Laplace, delimitando-se um domínio por condições de contorno e/ou condições iniciais. Para se determinar o campo elétrico ou potencial elétrico, em muitos casos, são utilizados a Lei de Coulomb, ou a Lei de Gauss quando a distribuição de cargas é conhecida, ou utilizar a equação que relacion intensidade do campo elétrico à direção contrária do divergente do potencial, quando esse é conhecido em uma região. No entanto, na maioria das situações práticas, tais parâmetros não são conhecidos. Então para essas situações, onde são apenas conhecidas as condições eletrostáticas em algumas fronteiras numa determinada região, em que se deseja obter o campo elétrico e o potencial elétrico ao longo de toda a região em questão, são

utilizados usualmente a Equação de Poisson ou a de Laplace ou, ainda, o metodo das imagens. A idéia básica é discretizar as equações de Maxwell no espaço e no tempo, obtendo-se os campos a partir da resolução contínua das mesmas, com base nos valores dos campos adquiridos em iterações anteriores de maneira alternada.

O sistema de equações vetoriais de Maxwell é mostrado a seguir:

O sistema de coordenadas cartesianas é utilizado para expandir o sistema em seis equações a derivadas espaciais e temporais:

(

)

(

)

(

)

(

)

(

)

(

)

As técnicas de diferenças finitas no domínio do tempo (FDTD) são baseadas em aproximações numéricas, permitindo transformar equações diferenciais em equações por diferenças finitas. A obtenção destas equações é efetuada a partir da expansão em séries de Taylor. Na prática, a série é truncada, o que implica na inserção de um erro de aproximação.

Considera-se,

por

exemplo,

uma

função

qualquer

dentro

de

um

espaço

cartesiano

discretizado

 

,

discretizada

também

no

tempo

:

, o

número da iteração. Pode-se utilizar a aproximação mostrada abaixo, que é demonstrada

na figura 4.1.

Onde:

são incrementos espaciais;

é o incremento temporal; e

(

)

(

)

espaciais; é o incremento temporal; e ( ⁄ ) ( ⁄ ) Figura 4. 1: Aproximação

Figura 4. 1: Aproximação por diferenças finitas. Fonte: Silveira, Jony L., UFSC, 2002

Têm-se, portanto:

 

⁄ *

(

)

(

)+ ⁄

⁄ *

(

)

(

)+ ⁄

⁄ *

(

)

(

)+ ⁄

Onde:

é o erro introduzido por truncagem.

E para o tempo:

 
 

*

+ ⁄

Para aplicar as equações 4.5 e 4.6 tem-se que discretizar a região com elementos regulares. O sistema de coordenadas pode ser cartesiano ou polar, e os elementos quadrados, retangulares ou hexagonais. A figura 4.2 ilustra a célula introduzida por Yee para discretização tridimensional.

Figura 4. 2: Disposição dos campos E e H na célula de Yee. Fonte: Silveira,

Figura 4. 2: Disposição dos campos E e H na célula de Yee. Fonte: Silveira, Jony L., UFSC, 2002

É importante observar que além de estarem defasados no espaço as componentes sw campo elétrico e magnético serão, por força da equação 4.6, calculadas em passos de temmpo alternados. Assim, o campo magnético será calculado a cada ( ) ”, enquanto o campo elétrico calculado a cada “ ”.

Para a resolução de uma equação de Laplace ou de Poisson, deve-se dividir o domínio em uma grade de maneira similar ao cubo de Yee. Os nós da grade da extremidade da região são prefixados pela condição de contorno e são chamados de nós fixos,enquanto os nós internos sao denominados de pontos livres. Em seguida, obtém-se as aproximações por diferencas finitas para equacao diferencial de Poisson, pela qual é possível determinar o potencial o potencial em todos os pontos livres. Abaixo, mostra-se a aplicação das equações 4.5 e 4.6 na célula de Yee para a compontente “ ” do campo magnético (Eq. 4.7) e elétrico (Eq. 4.8). Encontra-se as demais componentes de forma análoga, pela mesma aplicação da aproximação por diferenças finitas às outras equações 4.2.

(

)

)+

(

(

)

*

(

)

(

)

(

)

(

)

[

 

(

)

(

)

]

(

)

(

)

O método de diferenças finitas permite realizar cálculos em geometrias complexas e materiais com configurações não homogêneas lineares e não lineares. No entanto, existem alguns inconvenientes ligados a esta técnica:

Para garantir a estabilidade do método devemos garantir que:

,

onde: é a máxima velocidade de fase;

As condições de fronteira devem ser usadas convenientemente para simular a extensão da solução no infinito.

Existem, porém,várias técnicas aplicáveis às fronteiras de modo a simular o espaço aberto. O método das diferenças finitas é um método de resolução de problemas que englobam equações diferenciais parciais. Tais problemas são definidos univocamente por três características: seja por uma equação diferencial parcial, como é o caso das equações de Laplace ou de Poisson; seja pela delimitação de um domínio; ou até mesmo por condições de contorno e/ou por condições iniciais. O método de diferenças finitas é um dos mais populares na análise de problemas no domínio do tempo. Dentre as várias aplicações do método, em engenharia elétrica, destacam-se:

Obtenção das características de espalhadores (scattering);

Análise de antenas e microstrips;

Avaliação dos efeitos da radiação de microondas em organismos vivos;

Análise de problemas de interferência eletromagnética (EMI);

Análise de propagação em cavidades ressonantes, guias de onda;

Análise da propagação eletromagnética em fibras opticas, etc.

Como aplicação do método descreve-se apenas a obtenção das característias de espalhadores. O fenômeno de espalhamento eletromagnético pode ser entendido como o campo gerado a partir da interação entre uma onda eletromagnética viajante e um obstáculo que a intercepta. Caracteriza-se pela influência dos campos elétrico e magnético incidentes (E i ,H i ) em um corpo, designado objeto espalhador ou, simplesmente,e spalhador, nele induzindo correntes em sua superfície ou volume. As correntes no espalhador variam no tempo e o faz, por sua vez, exercer o papel de uma antena que irradia campos eletromagnéticos espalhados (E s ,H s ) . Dessa forma, o

campoeletromagnético total (E t ,H t ) se torna uma composição de campos espalhados e campos incidentes, conforme mostrado a seguir:

A equação 4.9 mostra que o campo elétrico total é dado pela soma do campo elétrico incidente com o campo elétrico espalhado. Da mesma forma, por meio da equação 4.10, tem-se que o campo magnético total é a soma dos campos magnéticos incidente e espalhado. Em uma situação em que o espaço é destituído de corpos, tem-se que toda medida de campo realizada, em qualquer que seja o ponto desse espaço, indica um valor de campo igual ao campo original produzido pela antena. Entretanto, em situações em que um espalhador esteja presente, o objeto é iluminado pelos campos eletromagnéticos incidentes e há interação entre estes campos e os campos espalhados, caracterizando assim, o fenômeno do espalhamento eletromagnético. Assim, tem-se que duas entidades distintas estão envolvidas neste fenômeno: os campos eletromagnéticos e o espalhador. Considerando-se uma região fonte de campo eletromagnético e outra onde se situa um objeto espalhador, o fenômeno de espalhamento ocorre nessa segunda região. As influências dos campos incidentes sobre o espalhador são computadas por meio de expressões analíticas para os campos incidentes originais. Dessa maneira, para o cálculo do campo eletromagnético total, é necessário somente encontrar a parcela do campo espalhado. Tem-se, também, que as ondas eletromagnéticas geradas pela fonte propagam-se pelo espaço livre Ω0 e que a geometria do espalhador e seu material podem ser considerados arbitrários. O espalhamento eletromagnético pode ser modelado matematicamente através

das equações de campo eletromagnético e das condições de contornos inerentes ao problema tratado. As equações de campo, elétrico e magnético, são obtidas através das equações de Maxwell, conforme demonstrado na explicação do Método das Diferenças Finitas.

Método Sem Malhas

Diferentemente dos métodos baseados em malhas, os métodos sem malha são caracterizados pelo uso de um conjunto de nós espalhados pelo domínio do problema, ao invés de uma malha ou grid. Um dos gargalos computacionais desses métodos é o processamento dos nós, cujo tempo é muito grande quando comparado, por exemplo, com o Método de Elementos Finitos (FEM). Apesar disso, o processamento de cada nó pode ser feito de maneira independente, tornando o processo facilmente Cada nó contribui com uma linha do sistema, não interferindo na contribuição dos demais nós.

Embora existam vários tipos de métodos sem malha, discute-se aqui em maiores detalhes o MLPG (Meshless Local Petrov Galerkin method) para a resolução de problemas eletromagnéticos, principalmente problemas estáticos (eletrostáticos e magnetostáticos). Esse método foi escolhido por ser um método bastante flexível e por ser considerado um método verdadeiramente sem malha.

O conjunto de equações simplificadas para os casos eletrostático e

magnetostático combinadas com as condições de contorno são denominados forma forte para os problemas eletrostáticos e magnetostáticos.

Como não existe uma malha para dar conectividade aos nós, um desafio para esse método é determinar com eficiência quais nós pertencem à vizinhança de um determinado nó. Para resolver esse problema, utiliza-se uma árvore de busca denominada kd-tree. Outra dificuldade dos métodos sem malha está na imposição das condições de contorno de Dirichlet quando as funções de forma não apresentam a propriedade do delta de Kronecker, o que é o caso para funções de forma construídas a partir do método de míınimos quadrados móveis (MLS).

No FEM, o processo de geração da malha pode ser extremamente custoso e não

apresenta a facilidade de ser paralelizado. Além disso, métodos com malha nem sempre

são apropriados para quaisquer tipos de problemas, como aqueles em que a configuração espacial muda com o tempo (e.g. fluidos) ou problemas em que a presença de elementos degenerados são comuns.

Apesar do grande avanço de métodos tradicionais baseados em malha, existem casos em que se justifica a utilização de métodos sem malha e a paralelização de tais métodos os torna mais competitivos.

O MLPG se difere de outros métodos sem malha baseados no método de

Galerkin, pois a abordagem Petrov-Galerkin permite que as funções de teste e de forma sejam diferentes. Esse procedimento torna possível a solução do problema global através de integrações de vários subdomínios locais, ao invés de se resolver uma única integração sobre todo o domínio, como acontece no EFG (Element Free Galerkin). Cada subdomínio pode ter qualquer tamanho ou forma geométrica e o conjunto de subdomínios deve cobrir completamente o domínio global.

Nos métodos sem malha, a função de aproximação pode ser definida usando diferentes abordagens, como o método de Mínimos Quadrados Móveis (MLS), Reproducing Kernel Particle Method (RKPM), Funções de Base Radial (RBF), aproximações polinomiais, entre outras.

A abordagem Petrov-Galerkin, utilizada no MLPG, permite que as funções de

teste e de peso sejam diferentes. Para ilustrar o conceito do MLPG, considere um domínio arbitrário descrito por um conjunto de nos dispostos em seu interior e ao

longo de seu contorno . Considera-se como válida em a seguinte forma fraca:

∫ (

)

(

)

, um parâmetro utilizado pelo método das penalidades para forçar o valor de ser igual ao valor conhecido em um contorno com condições de Dirichlet. O valor da função em um nó k é definido por:

é a função de peso, α é

onde

é o valor da função ao longo do contorno

Onde

é a função de forma do nó

e

k que são usadas para calcular a aproximação.

é o número de nós da vizinhança do nó

O suporte compacto da função de peso W define um subdomínio fechado redor de cada nó, como ilustrado na figura a seguir:

ao

redor de cada nó, como ilustrado na figura a seguir: ao Figura 4. 2: Representação do

Figura 4. 2: Representação do domínio. Fonte: Fonseca, Alexandre R. et al., UFMG, 2008

Conseqüentemente, a equação inicial pode ser resolvida localmente em cada

subdomínio

, pela seguinte expressão:

∫ (

)

(

)

Nos metodos sem malha, a função de aproximação (2) pode ser definida usando diferentes abordagens, como o método de Minimos Quadrados Moveis (MLS), Reproducing Kernel Particle Method (RKPM), Funcoes de Base Radial (RBF), aproximações polinomiais, entre outras.

Algumas possíveis funções que podem ser usadas para definir W, como a função degrau de Heaviside ou a função de peso MLS. Assume-se que W é definido pela função de Heaviside, i.e. W = 1, o que leva a:

∫ (

)

(

)

A função de Heaviside permite a simplificação da função da forma fraca local, eliminando a necessidade de integrações no interior dos subdomínios, o que simplifica o método e diminui o custo computacional. Substituindo (2) em (4), aplicando o teorema da divergência e uma identidade vetorial, obtem-se o sistema linear Kx = f, onde x é o vetor de incognitas, e as matrizes Ke f são dadas por:

̂

Resolvendo o sistema, obtêm-se os valores de V em qualquer ponto dentro do

domínio através de (2).

4.2. SEP

Análise de Redes Elétricas

Os sistemas elétricos de potência nos tempos atuais são, na maioria das vezes,

sistemas complexos, formados a partir de sistemas regionais de médio porte,

interligados uns aos outros, resultando numa grande rede elétrica, que pode conter

milhares de barras trifásicas e equipamentos, tais como geradores síncronos,

transformadores, autotransformadores, linhas de transmissão e cargas.

Para tratar esses equipamentos de uma forma interligada e dirigida para sistema

será de grande porte, eles devem ser representados por seus modelos de circuito, no

domínio das fases ou das componentes simétricas, resultando em matrizes de

impedância ou admitância primitivas. A interligação destes equipamentos de maneira a

formar a rede elétrica é tratada através de matrizes de incidência, que descrevem como

cada um dos elementos está disposto na rede elétrica, dando total informação sobre a

sua topologia. Elas são essenciais para, entre outras funções, se determinar as

formulações nodal e de laço de redes elétricas.

Na formulação nodal, existe a matriz de incidência elemento-nó ̃ , que é uma

matriz de

de um grafo orientado. Seus elementos

linhas e

colunas que descreve como os elementos

são tais que:

{

estão ligados aos nós

Já na formulação de laço, existe a matriz de incidência elemento-laço ̃ , que é

uma matriz cujo número de linhas é o número de malhas possívesi de se obter em um

determinado grafo. Esta matriz possui colunas e descreve como os elementos de um

grafo estão dispostos numa determinada malha ou laço . Assim, seus elementos são

tais que:

{

As relações tensão-corrente ou equações primitivas dos elementos de

circuito podem ser apresentadas no formato de impedância como:

̅

̅

̃

̅

em que ̅ é a diferença de potencial entre os terminais da linha, ̅

representa a soma das tensões das fontes existentes na linha, ̅é a corrente da

linha e ̃ é a matriz de impedâncias primitiva, que descreve os parâmetros da

linha. As formulações para a resolução do sistema linear matricial são mostradas

a seguir:

̃

̃

̃

[ ̃

̃

̃

]

 

̅ ̃

 
 

̅

̅

̃

̅

̃

̅

 

̅

 

̃

 

̅ ̅

̅

Na forma de admitância, as relações tensão-corrente são:

̅ ̅

̃

̅

Que, ao invés da somas das tensões das fontes, são somadas as correntes

das fontes e os parâmetros da linha são representados pela matriz admitância ̃ .

As formulações para a resolução do sistema linear matricial são mostradas a

 

seguir:

 

̃ ̃

 
 

̃

 

̃ [ ̃

 

̃

 

̅

̃

 

̃

̅

̅

̃

̅

̅

4.

Conclusões

̃

]

̅

̅

Esse trabalho propiciou o amadurecimento das técnicas de métodos numéricos para sistemas lineares, bem como da programação na linguagem C++. Avaliou-se os erro susceptíveis, diferentes tipos de a precisão e verificou-se um alto custo computacional dessa linguagem para precisões maiores.

5. Referências Bibliográficas

CORREA, Sonia M. B. B. (2003). Probabilidade e Estatística. Segunda Edição. Belo Horizonte MG. Puc Minas Virtual. 116p.

BOLDRINI, C. (1986). Álgebra Linear. 3ª ed. Editora Harbra.

PEREIRA, Clever (2012). Redes Elétricas no domínio da frequência. UFMG. Belo Horizonte, MG.

SILVEIRA, Jony Laureano (2002). Modelagem numérica 3D de problemas de compatibilidade eletromagnética utilizando o método TLM-TD. Tese de doutorado. UFSC. Florianópolis, SC.

YEE K. S. Numerical solution of initial Boundary Value Problems involving Maxwell’s Equations in Isotropic Media. IEEE Trans. on Antennas and Propagation, New York, v. 14, n. 3, p. 302-307, May 1966.

AZEVEDO, Rayann P. de Alencar; ARAÚJO, Icaro B. de Queiroz; SANTOS, Eliel P. dos; FONSECA SILVA, Paulo H. da. Aplicação do método das diferenças finitas para solução das equações de Laplace e Poisson para

linhas de microfitas acopladas. Instituto Federal de Educacao, Ciência e Tecnologia da Paraiba. João Pessoa, PB.

FONSECA, Alexandre Ramos ; MENDES, Miguel Lima ; MESQUITA, Renato Cardoso ; SILVA, Elson José da . Programação Paralela em Métodos sem Malha Aplicados a Problemas Eletromagnéticos. In: MOMAG 2008 - 13 Simpósio Brasileiro de Microondas e Optoeletrônica - 8 Congresso Brasileiro de Eletromagnetismo, 2008, Florianópolis. Anais do MOMAG 2008 - 13 Simpósio Brasileiro de Microondas e Optoeletrônica - 8 Congresso Brasileiro de Eletromagnetismo., 2008. p. 632-635.

FONSECA, Alexandre Ramos. Algoritmos eficientes em Métodos sem Malha. Tese de doutorado. UFMG. Belo Horizonte, MG.