A sequência de Fibonacci é dada pela seguinte ordem  Fibonacci = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 . . .. O algoritmo para o cálculo do enésimo elemento é dado por:  N = N - 1 + N - 2 , ou seja, o enésimo elemento é igual à soma dos dois dois elementos anteriores a ele, por exemplo:

Dada a sequência de Fibonnaci  0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55. . . calcule o 3º elemento da sequência:

Sempre levamos em consideração o valor dos dois primeiros termos, tais que X = 0 (primeiro elemento) e Z = 1. Então o terceiro elemento da sequência será igual à soma dos dois elementos anteriores, nesse caso  N = X + Z , N = 0 + 1 , N = 1.

Progrma em linguagem C que calcula o enésimo termo da sequência de Fibonacci:

Gerador online de CNPJ válido. Para gerar um novo CNPJ clique em “Gerar CNPJ” logo abaixo:

O CNPJ é composto por quatorze algarismos e é validado da mesma forma que o CPF, tendo a única diferença nos vetores padrões. São os dois últimos dígitos que validam todos os 12 algarismos anteriores, confira o algoritmo: http://masterdaweb.com/artigos/algoritmo-para-geracao-de-cnpj/.

O CNPJ (Cadastro Nacional da Pessoa Jurídica) é um número único composto por quatorze algarismos que identifica uma pessoa jurídica junto à Receita Federal brasileira (órgão do Ministério da Fazenda), necessário para que a pessoa jurídica tenha capacidade de fazer contratos e processar ou ser processada.

O CNPJ é validado da mesma forma que o CPF, tendo a única diferença nos vetores padrões. São os dois últimos dígitos que validam todos os 12 algarismos anteriores.

Para o algoritmo abaixo usaremos como exemplo o seguinte CNPJ: 44.038.188/0001-32.

 

Algoritmo para Geração de CNPJ:

 

  • Cálculo do primeiro dígito verificador:

Tomamos um vetor  a E R^12 cujos componentes são os 12 primeiros dígitos que compõem o número do CNPJ. Para o CNPJ que será utilizado neste exemplo (44.038.188/0001-32) teremos o seguinte vetor:

 a = (4, 4, 0, 3, 8, 1, 8, 8, 0, 0, 0, 1)

Determinamos o produto escalar desse vetor com o vetor padrão:

 b = (5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2)

OBS: O vetor padrão, como o próprio nome diz, será sempre o mesmo quando for calculado o digito verificador.

 a.b = a = (4, 4, 0, 3, 8, 1, 8, 8, 0, 0, 0, 1) . b = (5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2) = 20 + 16 + 0 + 6 + 72 + 8 + 56 + 48 + 0 + 0 + 0 + 2 = 228

Agora tomamos o resto da divisão do produto escalar por 11, ou seja, 228 dividido por 11 teremos resto inteiro igual à 8. O primeiro dígito verificador é dado pela subtração  11 - resto e teremos como resultado o número 3.

 

  • Cálculo do segundo dígito verificador:

Tomamos um vetor  c E R^13 cujos componentes são os 12 primeiros dígitos que compõem o número do CNPJ mais o primeiro dígito verificador 3, calculado anteriormente:

 c = (4, 4, 0, 3, 8, 1, 8, 8, 0, 0, 0, 1, 3)

Determinamos o produto escalar desse vetor com o vetor padrão:

 d = (6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2)

OBS: No segundo vetor padrão deve-se adicionar o número 6 no primeiro componente do vetor.

 c.d = (4, 4, 0, 3, 8, 1, 8, 8, 0, 0, 0, 1, 3) . (6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2) = 24 + 20 + 0 + 9 + 16 + 9 + 64 + 56 + 0 + 0 + 0 + 3 + 6 = 207

Agora tomamos o resto da divisão do produto escalar por 11, ou seja, 207 dividido por 11 teremos resto inteiro igual à 9. O segundo dígito verificador é dado pela subtração  11 - resto e teremos como resultado o número 2.

Completando nosso CNPJ 44.038.188/0001-xx com os dois dígitos verificadores calculados teremos 44.038.188/0001-32.

No Brasil, cada pessoa física possui um único e definitivo número de inscrição no CPF (Cadastro de Pessoas Físicas), que o identifica perante a secretaria da Receita Federal. Tal número de inscrição é constituído de 9 dígitos, agrupados de 3 em 3. Por exemplo, 313.402.809-30.

O CPF é validado através dos dígitos verificadores, são eles os 2 últimos os digitos do CPF, ou seja, a partir dos 2 últimos digitos do CPF se sabe se os 9 algarismos anteriores são válidos.

 

Algoritmo para Geração de CPF:

 

  • Cálculo do primeiro dígito verificador:

Tomamos um vetor  a E R^9 cujos componentes são os dígitos que compõem o número do CPF na ordem dada. Para o CPF citado como exemplo no inicio deste artigo, 313.402.809-30, temos o vetor:

 a = (3, 1, 3, 4, 0, 2, 8, 0, 9)

Determinamos o produto escalar desse vetor com o vetor (padrão)

 b = (10, 9, 8, 7, 6, 5, 4, 3, 2)

isto é,

 a . b = (3, 1, 3, 4, 0, 2, 8, 0, 9) . (10, 9, 8, 7, 6, 5, 4, 3, 2) = 30 + 9 + 24 + 28 + 0 + 10 + 32 + 0 + 18 = 151

A seguir tomamos o resto da divisão inteira desse produto escalar por 11. Se o resto desta divisão inteira é 0 ou 1, então o primeiro dígito verificador é 0. Caso o contrário (resto entre 2 e 10), o primeiro dígito verificador é dado por 11 – resto.

Para o exemplo em questão, a divisão inteira de 151 por 11 resulta em quociente 13 e resto 8. Sendo assim, o primeiro dígito verificador é  11 - 8 = 3 .

 

  • Cálculo do segundo dígito verificador:

Tomamos um vetor  c E R^10 cujos nove primeiro componentes são os dígitos que compõem o número do CPF na ordem dada, e o último componente é o primeiro dígito verificador encontrado. Para o exemplo em questão temos:

 c = (3, 1, 3, 4, 0, 2, 8, 0, 9, 3)

Determinamos o produto escalar desse vetor com o vetor (padrão)

 d = (11, 10, 9, 8, 7, 6, 5, 4, 3, 2) ,

isto é,

 c . d = (3, 1, 3, 4, 0, 2, 8, 0, 9, 3) . (11, 10, 9, 8, 7, 6, 5, 4, 3, 2) = 33 + 10 + 27 + 32 + 0 + 12 + 40 + 0 + 27 + 6 = 187

A seguir tomamos o resto da divisão inteira desse produto escalar por 11. Se o resto desta divisão inteira é 0 ou 1, então o segundo dígito verificador é 0. Caso o contrário (resto entre 2 e 10), o segundo dígito verificador é dado por 11 – resto.

Para o exemplo em questão, a divisão inteira de 187 por 11 resulta em quociente 17 e resto 0. Sendo assim, o segundo dígito verificador é 0.

 

Bibliografia: Geometria Analítica – Fabiano José dos Santos e Silvimar Fábio Ferreira.

 

Logo abaixo um exmplo de programa base em OpenGL, tendo como resultado uma janela com um triângulo vermelho no centro.

[c]

#include <stdlib.h>
#include <GL/glut.h>
//Funçao de Call Back
void desenha (void)
{
//Define a cor de fundo da Janela
glClear Color(1,1,1,0);
//Limpa a Tela
glClear (GL_COLOR_BUFFER_BIT);
//Define a cor do desenho
glColor3i(1,0,0);
glBegin(GL_TRIANGLES);
//Define a posição do ponto do vértice
glVertex2i(-5,-5);
glVertex2i(0,5);
glVertex2i(5,-5);
glEndl();
//Desenha os itens definidos anteriormente
glFlush();
}

void teclado(unsingned char key,int x,int y)
{
if(key==27)
{ exit(0); }
}
void inicializa()
{
//define a janela de visualização 2d
glMatrixMode(GL_PROJECTION)
glOrtho2d(-15,15,-15,15);
glMatrixMode(GL_MODELVIEW);
}
int main(void)
{
//define o modo de operaçao da glut
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
//especifica tamanho da janela
glutInitWindowSize(400,400);
//cria a janela e insere o titulo
glutCreateWindow(“Primeiro Programa”);
//registra CallBack de desenho
glutDisplayFunc(desenha);
//registra a funçao de teclado
glutKeyboardFunc(teclado);
inicializa();
//Ativa funçoes de callback
glutMainLoop();
return 0;
}
[/c]___________________________________________________________________________

 

___________________________________________________________________________
Padrão de Nomes de Funções
Para facilitar o uso, dos nomes das funções da biblioteca OPENGL segue um padrão.                    O padrão adotado é simples a primeira parte do nome representa a biblioteca representante. A segunda parte é o nome do comando. A quarta parte represneta o tipo de parâmetro da função e a terceira parte o numero de parâmetros.

Exemplo:

___________________________________________________________________________
Tipos de dados aceitos
___________________________________________________________________________
Argumento                                             Tipo
s                                                                     Short
i                                                                    Integer
f                                                                     Float
d                                                                  Double
uc                                                           Unsigned Char
us                                                           Unsigned Short
ui                                                           Unsigned Int
___________________________________________________________________________

Padrão de nomes de funções

Outros exemplos :

gl Load Identity();
gl Vertex3f(1.0,2.3,0.5);
gl Vertex2i(1,2);
gl Vertex2f(2.3,0.5);
glut Solid Cube(30);

Gerador online de CPF válido. Para gerar um CPF clique em “Gerar CPF” logo abaixo:

O CPF é composto de 11 algarismos sendo os 2 últimos os digitos verificadores, são eles que validam o CPF, ou seja, a partir dos 2 últimos digitos do CPF se sabe se os 9 algarismos anteriores são válidos.

Segundo [Scheiner,2004], a OpenGL fornee um conjunto de comandos muito importantes para a modelagem e visualização de objetos geométricos. Porém, esses comandos são muito primitivos,no sentido que fornecem um baixo nível para a elaboração de desenhos deve ser implementada utilizando tais comandos. Além disso, como a OpenGL não contém funções para gerenciamento de janelas, também seria nescessário trabalhar com o sistema de janelas disponível no ambiente do  Sistema Operacional.

Para facilitar o desenvolvimento das aplicações gráficas, foram criadas algumas bibliotecas que fornecem uma maior abstração, alem de prover funções para a criação de janelas e gerenciamento de eventos. Entre as várias bibliotecas e toolkits existentes hoje, pode-se considerar que as mais utilizadas são a GLU.h e a GLUT.h.

A GLUT é adequada para aprender a programar em OpenGL e para construir aplicações pequenas. Para o desenvolvimento de programas mais complexos, que nesseitam de uma interfae mais elaborada, torna-se nescessário trabalhar com o sistema de janelas do ambiente operacional ou utilizar um outro toolkit mais completo.

 

INSTALANDO A GLUT NO DEV-C++

Download  DEV-C++;

Download GLUT;

Logo após efetuarem os downloads:

  • Instalem o compilador Dev-C++;
  • Vá no menu Ferramentas/Atualizações;

  • Clique na janela WebUpdate;
  • Selecione o servidor devpaks.org;
  • Clique em Check for updates;
  • Irá aparecer na tela uma lista de pacotes disponíveis;
  • Selecione o grupo OpenGL (em Groups)
  • Marque a linha contendo a glut;

Pronto! Agora começaremos a criar nossa aplicação.

Abra o Dev-C++, abra o menu Arquivo e selecione a opção Novo/Projeto, irá surgir uma janela , clique na aba Multimedia, a seguir, ícone glut, defina um nome para o projeto e selecione a linguagem a ser usada (escolha C++).

Clique em OK.

A seguir,o Dev-C++ solcita o nome do arquivo que irá guardar as informações do projeto. Defina um nome e salve o arquivo no diretório que desejar. Feito tudo isso com sucesso, será criado o ambiente Dev-C++.

Testando a Bliblioteca:

  • Clique no “+” localizado no canto superior esquerdo;

  • Agora vamos compilar o main;
  • Clique no botão colorido como na imagem abaixo:

  • Logo irá aparecer:
  • Se apareceu esta janela em seu ecrã a instalação foi um secesso.

Neste momento vocês devem estar pensando o motivo do segundo download postado por mim, se por acaso você não conseguir fazer o download da biblioteca por meio da opção de atualização do próprio Dev-C++, você deverá copiar os arquivos dentro da pasta que baixou e colar no diretório onde o Dev-C++ foi instalado;

Ex: C:\Dev-Cpp

Você poderá subistituir os arquivos existentes.

 

Bibliografia

Isabel Harb Manssour -OpenGL-Uma Abordagem Prática e Objetiva

Variáveis globais são variáveis declaradas fora de uma função, ao contrário das locais que são declaradas dentro de uma função.

Quando uma variável é declarada dentro de uma função, ela só poderá ser usada dentro da mesma, no exemplo acima a variável ‘a’ só poderá ser usada dentro função MAIN, caso o contrário será dada como inexistente. Já as globais, como o próprio nome diz, podem ser usadas por toda parte do programa.

Apesar de certas facilidades que as variáveis globais nos trazem elas também tem suas desvantagens. Quando declarada como global ela ocupará memória até que o programa seja finalizado, por isso deve ser usada apenas quando necessário. As variáveis locais só ocupam memória enquanto aquela função for executada, ao término dessa função ela é destruída.

Existem três maneiras de se reservar espaço de memória para
o armazenamento de informações:

Uso de variáveis globais – o espaço reservado existe enquanto
o programa estiver sendo executado.
Uso de variáveis locais – o espaço reservado existe apenas
enquanto a função que declarou a variável está sendo
executada.
Reservar um espaço na memória dinamicamente: requisitar ao
sistema, em tempo de execução, um espaço de um
determinado tamanho.

A função malloc:

 

  • Recebe como parâmetro o número de bytes que se deseja alocar.
  • Retorna o endereço inicial da área de memória alocada.

Alocação dinâmica de um vetor de inteiros com 10 elementos, exemplo:

Se a alocação for bem sucedida, ‘v’ armazenará o endereço inicial de uma área contínua de memória suficiente para armazenar 10 valores inteiros.

Operador sizeof(tipo) retorna o número de bytes que um
dado tipo ocupa na memória.

Exemplo esquemático do que ocorre na memória:

Se não houver espaço livre suficiente para realizar a alocação,
a função malloc retorna um endereço nulo (NULL).

A liberação do espaço alocado dinamicamente é feito através do uso da função ‘free()’, que recebe como parâmetro o ponteiro da memória a ser liberada.

OBS:

  • Só devemos passar para a função free um endereço de memória que tenha sido alocado dinamicamente.

 

  • Uma vez liberado o espaço de memória alocado, o mesmo não pode mais ser acessado.
  • Enquanto a função free não for utilizada, o espaço alocado dinamicamente permanecerá válido mesmo após o término de uma dada função.