Fatorial de 1.000.000 no Raspberry Pi , será que a plaquinha aguenta ?

Olá , grandes Senhoras e Senhores embaixadores da Verdade Embarcada, Mestras e Mestres dos Bits e dos Bytes.

Já faz um certo tempo que estava querendo fazer um post sobre programação de “Big Numbers”, ou seja, como fazer um fatorial de 1.000.000 (um milhão ) no bom e velho gcc, usando umas das minhas plaquinhas e a coitada do momento foi a Raspberry Pi 2 (essa sofre …).

Mas qual a vantagem disso ?Vocês devem estar se perguntando ! Aprendizado minhas amigas e amigos , muito aprendizado.

Bom esse post abre uma nova série de programação aqui no site, inicialmente irei postar o básico e ir avançando para assunos mais complexos , iremos utilizar linguagens como C, Prolog e Python, tirando o Prolog tanto C como Python são muito utilizadas em programação embarcada, sendo que o Python vem embarcado em muitas distribuições para Raspberry Pi.

Antes de iniciarmos é bom verificarmos, se temos todos os programas e bibliotecas instalados .

Digite o seguinte no seu terminal do linux:
gcc --version // verifica se temos o gcc esta instalado
Agora temos que saber se as bibliotecas libgmp estão instaladas , para isso digite:
dpkg --get-selections | grep libgmp* // irá mostrar se temos as bibliotecas como mostra o texto abaixo.

libgmp_instalada

Caso você não tenha essa sorte toda (alguns usuários Raspibian Jessie tem …), faça a instalação da seguinte forma:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install libgmp10 libgmp-dev // Usuarios Raspibian Jessie tem por default a libgmp10 logo instalem apenas a outra

Agora vamos colocar a mão na massa, com o nosso programinha sobre o fatorial de um big number.

Iremos utilizar a biblioteca gmp.h que foi instalada no passo anterior , para mais detalhes de como trabalhar com a mesma acesse AQUI

Caso ainda não saiba como calcular o fatorial de um número acesse esse link AQUI.

Nosso Programinha ficou com a seguinte cara :

// Programinha para calcular o fatorial de números gigantes.
// Licença exclusiva Use & Abuse.
// Mostra também o tempo de processamento que levou para calcular o número.

#include   // "Chuxa" na tela
#include  // Alocação da memória e coisas mais sinistras
#include  // Paranauês do tempo
#include  //  Biblioteca com as funcoes de big num a serem usadas

// Vamos então ao nosso programinha legal, pois programar é bom e te deixa contente
// mamãe vai ficar sorridente . :)

void Fat_Poretao(mpz_t K,int numero_fatorial){ // função para o cálculo     do Big Num
      unsigned int i;
      mpz_t temporario;
      mpz_init(temporario);
      mpz_set_ui(K,1);
      for(i=1;i <=numero_fatorial; i++){
          mpz_set_ui(temporario,i);
          mpz_mul(K,K,temporario);
       }
       mpz_clear(temporario);
}

int main(void){

    int nfat;
    double tempinho;
    printf("Entre o fatorial desejado\n");
    scanf("%d", nfat);

    clock_t Inicio=clock(); // cálculo do tempo de processamento
    mpz_t r;
    mpz_init(r);
    Fat_Poretao(r,nfat);
    gmp_printf("%Zd\n",r);
    mpz_clear(r);

    clock_t Fim=clock(); //Fim do cálculo do tempo de processamento
    tempinho = (double)(Fim -Inicio)/ CLOCKS_PER_SEC;
    printf("\n\nDemorouuuuu tudo isso pra rodar  %.4lf segundos\n",tempinho);
    return 0;
}


Agora que já escrevemos o nosso programinha que tal compilarmos o mesmo e vermos o resultado na nossa plaquinha.

gcc fatorial.c -lgmp -o fatorial //Realiza a compilação
./fatorial // executa o programa

Eu adicionei no final do programa uma maneira de saber quanto tempo demorou pra rodar nosso código.

Mas no Linux , existe uma função chamada time que faz a mesma coisa infelizmente não é tão precisa, mas para testar a mesma faça assim:
time ./fatorial
Usando a função time ela mostra três resultados , sendo o primeiro o tempo de entrada(real), o segundo é o tempo de processamento e o terceiro o tempo do sistema operacional.

Caso queira também pode fazer os mesmos testes em Python, ele já trás toda a implementação de Big Numbers pronta para uso sem a necessidade bibliotecas, etc. Essa implementação nativa existe desde a versão 2.5.

Uma implementação possível em Python para esse programinha seria :

#!/usr/bin/python

          import sys;
          import timeit; 
          def Fatorial_Cobra(n): fat=1
          for x in range(1,n): fat = fat * x 
          return fat;<br />          n=int(input("Numero a ser fatorado: "))<br />          print Fatorial_Cobra(n)

Como podem ver em Python a quantidade de linhas para o mesmo programa é bem menor mas isso tem um preço alto que é a questão do processamento e tempo de execução, dizem as más linguas …
Valeu , tomorrow tem more , se Moore permitir ; )

Que tal nos encontrar no SeuTubo para ver dicas, tutoriais e Reviews de placas? Canal Sistemas Embarcados

Que tal na página do Facebook?

Ou Instagram?

Quem sabe Google Plus?

Que tal no Pinterest?

Ou talvez nos encontrar no Twitter para receber as ultimas noticias quentinhas: @SEmbarcados

E não esqueça que também tem o email, contato@sistemasembarcados.org

Conheça também nossos grupos do Facebook:
Arduino BR – https://www.facebook.com/groups/microcontroladorarduinobr/
Raspberry Pi BR – https://www.facebook.com/groups/raspberrybr/
Orange Pi BR – https://www.facebook.com/groups/OrangePiBR/
Odroid BR – https://www.facebook.com/groups/odroidBR/
Sistemas Embarcados BR – https://www.facebook.com/groups/SistemasEmbarcadosBR/
MIPS BR – https://www.facebook.com/groups/MIPSBR/
Do Bit ao Byte – https://www.facebook.com/groups/dobitaobyte/
Visitem nossos Sites Parceiros:
Do Bit ao Byte
Douglas Zuqueto

Forte abraço e até o próximo embarcado.