Método Iterativo de Gauss-Jacobi

Atravéz de uma aproximação inicial, o Método de Gauss-Jacobi consiste em obter uma seqüência, por meio da relação recursiva.
O processo iterativo utiliza somente estimativas da iteração anterior.

O método gera uma seqüência convergente para a solução do sistema dado, independentemente da escolha da aproximação inicial.

Fórmula Matricial do Método Gauss-Jacobi

Decompõe-se a matriz de coeficientes A em:

A = L + D + U

Onde:

L – Matriz Triangular Inferior

D – Matriz Diagonal

U – Matriz Triangular Superior

Abaixo tem um algoritmo em C para o calculo deste método linear:

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

#define tam 3

main()
{
    int t, j, i, k; 
    bool pare=false;
    float a[tam][tam], b[tam], x[tam], x0[tam], x2[tam], e, norma=0, soma=0,soma2=0;
   
    // inserindo os elementos na matriz A
     printf("\nInserindo elementos da matriz A:");
     for(i=0; i<tam; i++)
     {
              for(j=0; j<tam; j++)
              {
                       printf("\nInsira o elemento a[%i,%i]:",i+1,j+1);
                       scanf("%f",&a[i][j]);
              }
     }
    
     printf("\n");
    
     // inserindo os elementos da matriz dos termos independentes B
     printf("Inserindo os termos independentes B:");
     for(i=0; i<tam; i++)
     {
              printf("\nInsira o elemento b[%i]:",i+1);
              scanf("%f",&b[i]);
     }
    
    // inserindo os elementos do vetor x0 inicial
    printf("Entrando com os valores do vetor x0 (inicial)\n");
    for(i=0; i<tam; i++)
    {
             printf("x0[%i]= ",i+1);
             scanf("%f",&x0[i]);
    }  

    //imprimindo a matriz
     printf("\nMatriz A:\n");
      for(i=0; i<tam; i++)
      {
             for (j=0;j<tam;j++)
             {
                 printf ("%.0f",a[i][j]);
                 if(j==2)
                 {
                          printf("\n");
                 }
                 else
                 {
                      printf("\t");
                 }
             }
    } 
    printf("\n\n");

   //imprimindo a matriz de termos
    printf("\nMatriz B:\n");
    for (j=0;j<tam;j++)
    {
                 printf ("%.0f",b[j]);
                 if(j==2)
                 {
                      printf("\n");
                 }
                 else
                 {
                      printf("\t");
                 }
     }      
     printf("\n\n");
   
    //imprimindo o vertor x
    printf("\nMatriz X:\n");
    for (j=0;j<tam;j++)
    {
                 printf ("%.0f",x0[j]);
                 if(j==2)
                 {
                      printf("\n");
                 }
                 else
                 {
                      printf("\t");
                 }
     }      
     printf("\n\n");

    printf("Entre com a precisao: ");
    scanf("%f", &e);

    while (!(pare))
    {
       
        for (i=0; i<tam; i++)
        {
            //calculando o valor do primeiro somatório.
            for (j=0; j<i; j++ )
            {
                soma=soma+a[i][j]*x0[j];
            }           
            //calculando o valor do somatório.
            for (j=i+1; j<tam; j++ )
            {           
                soma2 = soma2 + a[i][j]*x0[j];
            }
            x[i]=(b[i]-soma-soma2)/a[i][i];
            printf("x%i=%f\n",i,x[i]);
            soma=0;
            soma2=0;

        }

        for (t=0; t<tam; t++)
        {
            x2[t] = x[t]-x0[t];
        }
        norma = (sqrt((x2[0]*x2[0])+(x2[1]*x2[1])+(x2[2]*x2[2])))/sqrt((x[0]*x[0])+(x[1]*x[1])+(x[2]*x[2]));
        printf ("norma = %f", norma);
        printf("\nPressione p/ continuar\n\n");
        getch();

        if (norma <= e)
        {           
            pare = true;
        }
        else
        {
            for (t=0; t<tam; t++)
            {           
                x0[t] = x[t];
            }           
            k++;
        }

    }
getch();
}

Ler números de trás para frente em C

          Esse código foi implementado para ler 20 numeros float e imprimi-los de trás para frente, de forma bem simples, utilizando um vetor de 20 números. No primeiro "for" ele lê os numeros e armazena no vetor usando o contador de forma positiva com "i++", já no segundo "for" ele lê e imprime o vetor de trás pra frente com o "i--".

#include<stdio.h> //inclui bilbiotecas
#include<conio.h> //definição de constantes, de novos de tipos, de novas estruturas

main()
{
    float num[20];
    int i;
    for (i=0; i<20; i++)
    {
        printf("Entre com o numero %i:",i+1);
        scanf("%f",&num[i]);
    }
    for (i=19; i>=0; i--)
    {
        printf("%.2f\n",num[i]);
      
    }
    getch();

}

Fatorial em C

      Fatorial é um código bem simples, mas cada um tem seu modo de fazer. Mas mestraremos um com função, no bloco main recebe o número e passa para a função fatorial e através do bloco for calcula-se o fatorial, retorna-se o valor encontrado e imprime-se na tela.

Vamos ao código:

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

int fatorial(int num) // recebe o nuúmero
{
    int fat=1,controle;
//calcula o fatorial
    for(controle=1;controle<=num;controle++)
    {
        fat=fat*controle;
    }
    return fat;
}   
main()
{
    int x;
    printf("Informe o numero: ");
    scanf("%i",&x);
    printf("O fatorial de %i e: %i",x,fatorial(x)); //passa o numero por parâmetro e depois recebe e imprime
    getch();
}

Fibonacci em C

      Esse código mostra uma sequencia de Fibonacci, onde você escolhe a quantidade de termos a ser mostrado em tela. Neste código é usado função. No bloco main é lido o número e passado para a função, onde é calculado por meio do bloco de repetição While até o valor especificado pelo usuário.

#include <stdio.h>
#include <conio.h>
int fibonacci(int num)//recebe o número
{
   int soma, a=0, b=1,i=1;
    printf("%i  ", a);
    printf("%i  ", b);            
    while (i<=num-2) //Calcula a seu^qncia de fibonacci
    {     
      soma=a+b;
      a=b;
      b=soma;
      i++;
      printf("%i  ",soma);
     }
}
main()
{
   int n;
   printf(" Digite a quantidade de termos: ");
   scanf("%d", &n);
   printf("\nA sequencia e: \n");
   fibonacci(n); //passa o número por parâmetro
   getch();
}

C com threads

Um exemplo de algoritmo em C multiplicando matriz usando threads.

#include <cstdlib>
#include <stdio.h>
#include <pthread.h>
//using namespace std

pthread_t thread_1;
pthread_t thread_2;
pthread_t thread_3;

int a[3][2] = {{1, 4}, {2, 5}, {3, 6}};
int b[2][3] = {{7, 8, 9}, {10, 11, 12}};
int c[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};

void* tarefa_1(void *p)
{
      //----------Região critica
      printf("\nThread1\n");
      for (int col = 0; col < 3; col++) {
            // Multiplica a linha de A pela coluna de B.
            for (int i = 0; i < 2; i++) {
                c[1][col] += a[1][i] * b[i][col];
            }
            printf("%i\t",c[1][col]);
            printf("\n");
      }
}

void* tarefa_2(void *p)
{
      //----------Região critica
      printf("\nThread2\n");
      for (int col = 0; col < 3; col++) {
            // Multiplica a linha de A pela coluna de B.
            for (int i = 0; i < 2; i++) {
                c[2][col] += a[2][i] * b[i][col];
            }
            printf("%i\t",c[2][col]);
            printf("\n");
      }
     
}
void* tarefa_3(void *p)
{
      //----------Região critica
      printf("\nThread3\n");
      for (int col = 0; col < 3; col++) {
            // Multiplica a linha de A pela coluna de B.
            for (int i = 0; i < 2; i++) {
                c[3][col] += a[3][i] * b[i][col];
            }
            printf("%i\t",c[3][col]);
            printf("\n");
      }
     
}

int main()
{
   printf("Inicio das Threads...\n");
   
    // inicia as duas threads, passando como parametroa thread e a função que cada uma deve executar
   
    pthread_create(&thread_1, NULL, tarefa_1, NULL);
    pthread_create(&thread_2, NULL, tarefa_2, NULL);
    pthread_create(&thread_3, NULL, tarefa_3, NULL);
   
    // faz com que a thread principal espere a thread 1 e a thread 2 acabarem;
   
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    pthread_join(thread_3, NULL);
   
    system("PAUSE");
    return EXIT_SUCCESS;
}

Achar matriz inversa em C

Este é um código em C para multiplicar matrizes, achando a matriz inversa. Você pode notar que eu comentei todo o código, então fica mais fácil de entender, e posso garantir que funciona.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main()
{
    int i, j, l = 0, c = 0, k = 0;

    printf("\n Digite o numero de variaveis: \n");//Define o tamanho da matriz A
    scanf("%i",&l);

    c = l;//coluna recebe o valor da linha ex: 3x3

    float A[l][c], ident[l][c], pivo = 0, p = 0, m = 0;

    //Definindo a Matriz Identidade
    for(i = 0; i < l; i++)
    {
        for(j = 0; j < c; j++)
        {
            if(i == j)
            {
                ident[i][j] = 1;
            }
            else
            {
                ident[i][j] = 0;
            }
        }
    }
   
    //Inserindo valores na matriz A
    printf("\n Digite os valores para os coficientes da Matriz A: \n");
    for (i = 0; i < l; i++)
    {
        for (j = 0; j < c; j++){
            printf("\n Digite o valor do termo a(%i,%i):",i+1,j+1);
            scanf("%f",&A[i][j]);
        }
    }
    printf("\n Matriz A: \n");
   
    //Mostrando a Matriz
    for(i = 0; i < l; i++)
    {
        for (j = 0; j < c; j++)
        {
            printf ("%.2f",A[i][j]);
            if(j < c - 1) printf("\t");
            else printf("\n");
        }
    }
   
    //Calculando a Matriz Inversa
    for(j = 0; j < c; j++)
    {
        pivo = A[j][j];
        p = pivo/pivo;
        for(k = j; k < c; k++)
        {
            A[j][k] = (A[j][k])/(pivo);
            ident[j][k] = (ident[j][k])/(pivo);
        }
       
        for(i = 0; i < l; i++)
        {
             if(i != j)
             {
                  m = A[i][j]/p;
                 
                  for(k = 0; k < c; k++)
                  {
                      A[i][k] = (A[i][k]) - (m * A[j][k]);
                      ident[i][k] = (ident[i][k]) - (m * ident[j][k]);
                  }
              }
        }
    }

    //Resultado das Matrizes Identidade e Inversa
     printf("\n Matriz Identidade A: \n");
    for(i = 0; i < l; i++)
    {
        for (j = 0; j < c; j++)
        {
            printf ("%.2f",A[i][j]);
            if(j < c - 1) printf("\t");
            else printf("\n");
        }
    }
    printf("\n Matriz Inversa: \n");
    for(i = 0; i < l; i++)
    {
        for (j = 0; j < c; j++)
        {
            printf ("%.2f",ident[i][j]);
            if(j < c - 1) printf("\t");
            else printf("\n");
        }
    }
    getch();
}