Gerando Números Aleatórios

Transcrição

1 Gerando Números Aleatórios Fernando Henrique Ferraz Pereira da Rosa Vagner Aparecido Pedro Junior MAP-131 Laboratório de Matemática Aplicada Prof. Dr. Eduardo Colli 21 de novembro de 2002

2 1 Introdução A disponibilidade de números aleatórios é extremamente útil em uma variedade de situações, como na simulações de fenômenos físicos (indo desde a física nuclear até engenharia de sistemas), em amostragem de uma população, na programação de computadores, na tomada de decisões ou até mesmo em entretenimento (bingos, loterias ou jogos). Na área de simulação, onsideremos por exemplo, a modelagem do tempo de acesso de um disco rígido, num computador pessoal. Podemos determinar que a duração desse evento irá ficar numa faixa conhecida, digamos de 0 a 200ms, de acordo com caracteristicas físicas inerentes ao próprio disco rigido. Entretanto, o valor real desse evento vai depender de vários fatores, como a posição da cabeça de leitura quando a requisição é feita pelo sistema operacional, detalhes espúrios da implementação do suporte à controladora no sistema e até mesmo da temperatura e outras condições ambientais. Podemos considerar então que esse tempo de acesso é uma variável aleatória seguindo uma distribuição conveniente, e simulamos com o objetivo de ver se nosso modelo adere a realidade. Para fazermos essa simulação precisamos de números aleatórios que sigam essa dada distribuição, e para isso precisamos saber primeiro como gerar esses números aleatórios. Algumas fontes de números aleatórios são o lançamento de dados, a retirada de bolas numeradas de uma urna (com reposição), o uso de uma roleta ou ainda ruído eletrônico cuja saida é quantizada periodicamente [1]. Entretanto na esmagadora maioria das vezes usa-se o que foi convecionado chamar de números pseudo-aleatórios. Isso se dá pois o uso de números realmente aleatórios causa um impecílio nas simulações assim como no desenvolvimento de programas para computador: não se tem como repetir uma dada seqüência de números, com a intenção de verificar a simulação ou tentar corrigir um problema no programa. Além da possibilidade se repetir uma dada seqüência, de [1] temos que e- xistem algumas outras propriedades importantes num bom gerador de números (pseudo)aleatórios, a saber: 1. Os números gerados devem seguir uma distribuição uniforme, pois números aleatórios de verdade seguem essa distribuição. 2. Os números devem ser estatisticamente independentes entre si. O valor de um número na seqüência não deve afetar o valor do próximo (na prática a maioria dos geradores usa seqüências recursivas, então há essa dependência dos valores anteriores, mas isso não é estatisticamente significafivo, dai o destaque para independência estatística). 3. A seqüência não deve se repetir nunca. Isso é teoricamente impossível mas na prática um período de repetição suficientemente grande é o bastante. 4. A geração desses números deve ser rápida, de modo a poupar recursos computacionais para as simulações em si. O uso de um algoritmo para gerar um número aleatório parece violar o princípio básico da aleatoridade, por isso é que se convenciona chamar esses números de sintéticos ou pseudo-aleatórios. Esses números correspondem às propriedades acima mas começam sempre de um valor inicial chamado semente 1

3 (seed) e continuam numa maneira totalmente determinística, por isso deve ser tomado muito cuidado para que a aleatoridade esteja presente. No desenvolvimento do trabalho vamos dar uma olhada nos principais algoritmos para geração de números aleatórios e em seguida vamos estudar também alguns testes de aleatoridade, que nos fornecem um meio objetivo de verificar a aleatoridade de uma seqüência. Vamos também implementar alguns desses métodos, e fazer testes para verificar como eles se comportam. 2

4 2 Algoritmos para geração de números pseudoaleatórios 2.1 Método do quadrado do meio Esse método foi inventado por John von Neumann. Começa-se com uma semente (seed), esse número é então elevado ao quadrado, os dígitos do centro são usados como próximo elemento da seqüência. Caso o número de dígitos que fique a esquerda seja maior que os que fiquem a direita não há problema, simplesmente fixamos para qual lado vamos fazer o corte. Exemplo: começando a partir de x 0 = vamos gerar uma seqüência de números aleatórios de 5 dígitos: x 0 = (44214) 2 = x 1 = (54877) 2 = x 2 = (11485) 2 = x 3 = (19052) 2 = x 4 = (29787) 2 = x 5 = Veja 4.1 para a implementação em c do algoritmo do quadrado do meio (midsquare). Esse algoritmo tem diversas desvantagens. Em primeiro lugar geralmente as seqüências geradas por esse algoritmo se repetem em pouco tempo. Em segundo, sempre que um 0 for gerado todos os números seguintes da seqüência serão 0 também. Exemplo: tomando x 0 = 121: x 0 = 121 (121) 2 = x 1 = 464 (464) 2 = x 2 = 529 (529) 2 = x 3 = 984 (984) 2 = x 4 = 825 (825) 2 = x 5 = 062 (062) 2 = x 6 = 384 (384) 2 = x 7 = 745 (745) 2 = x 8 = 502 (502) 2 = x 9 = 200 (200) 2 = x 10 = 000 (000) 2 = x 11 = Método linear congruente A grande maioria dos geradores de números pseudo-aleatórios hoje em dia são modificações do método linear congruente. Ele é dado através duma relação de recorrência, a saber: x n+1 = (ax n + c) mod m, n 0 (1) O valor inicial x 0 é chamado de semente (seed), a é o multiplicador, c o incremento e m é o módulo. A escolha desses valores afeta drasticamente o 3

5 comprimento do período da seqüência de números aleatórios. É fácil notar que o período será sempre menor que m, e que portanto, para aumentarmos o período devemos usar m o maior possível. Esse algoritmo apesar de extremamente simples é poderossímo, dada uma escolha adequada dos parâmetros a, c e m. Em [2] temos o seguinte Teorema que nos informa qual a escolha ótima desses parâmetros: Teorema A O método linear congruente tem um período m se e somente se: i) c e m são primos entre si. ii) b = a 1 é um múltiplo de p, para todo p primo divisor de m iii) b é um múltiplo de 4, se m é um múltiplo de 4. Uma prova desse Teorema para um caso especial foi dada há pelo menos 100 anos atrás, por M. Greenberger e o caso geral foi dado por Hull e Dobel. Não iremos entrar em detalhes na sua demonstração matemática, que envolve diversos conceitos avançados de Álgebra. Em 4.2 implementamos em c esse algoritmo para geração de números aleatórios. Fizemos algumas modificações e escolhas particulares dos parâmetros a, m e c de modo que o usuário precisa entrar apenas com o número de números aleatórios que ele quer gerar (entre 0 e 1) e opcionalmente uma semente Escolhendo os parâmetros Em primeiro lugar, levamos em consideração o valor de m. Como já foi observado, o período da seqüência na melhor das hipóteses vai ser igual a m (ou seja, a cada m elementos a seqüência vai se repetir). Baseados no número de elementos n que o usuário quer gerar, escolhemos então um valor de m suficientemente maior que n mas não necessariamente sempre grande, de forma a poupar recursos computacionais, tendo m como função de n. Chegamos na seguinte relação: m = (menor primo( 10n)) 2 (2) Onde a função menor primo(x) retorna o maior número primo d, tal que d < x. Com (2) garantimos que m será suficientemente maior que n e ao mesmo tempo que m é da forma m = p 2 com p primo, e logo os únicos divisores de m serão 1, m e p. Convenientemente então, escolhemos a de acordo com a seguinte relação: a = menor primo( 10n) + 1. (3) Seja: q = menor primo( 10n) Por (2) sabemos que q é o único divisor primo de m, e da condição (ii) do Teorema A sabemos que a 1 deve ser múltiplo de p para todo p primo divisor de m. Ora, temos então que a deve ser da forma: a 1 = nq a = nq + 1 (n N) Fazendo n = 1 chegamos na relação (3) acima. 4

6 Escolhemos c aleatório entre 0 e m 10, c diferente de q. Dessa forma completamos a condição (i) do Teorema A. A condição (iii) não precisa ser levada em conta, já que escolhemos m múltiplo apenas de q, q primo. E por fim, caso o usuário não tenha escolhido ele próprio uma semente, escolhemos x 0 aleatório entre 0 e m. Obtivemos resultados excelentes com essa implementação, conseguindo seqüências melhores que de alguns pacotes estatísticos disponíveis. Mais a frente, quando entrarmos na parte de Testes de Aleatoridade vamos falar disso com mais detalhes. 2.3 Outros métodos Claramente, o método linear congruente não é o único meio de se conseguir boas seqüências de números aleatórios. Nessa sessão vamos dar uma olhada em alguns algoritmos outros algoritmos disponíveis. Uma versão quadrática do método linear congruente é dada por: x n+1 = (dx 2 n + ax n + c) mod m. (4) Com a, d e m escolhidos convenientemente, de forma similar que o método linear, também pode-se garantir que a seqüência vai ter período m. Outro método quadrático interessante proposto, foi: x n+1 = x n (x n + 1) mod 2 e, n 0. (5) Com m uma potência de 2 e x 0 mod 4 = 2, também fornece um período longo. Outras generalizações podem ser feitas, obtendo x n+1 a partir de um polinômio que depende de x n, x n 1,..., x k. Aplicam-se aí também regras às constantes e pode-se garantir períodos suficientemente longos. 5

7 3 Testes de Aleatoriedade Nós acabamos de estudar alguns métodos para geração de seqüências que parecem aleatórias. Vimos que seguindo alguns critérios nas escolhas dos algoritmos e parâmetros podemos aumentar o período da seqüência o quanto quisermos, mas somente isso não garante que nossa seqüência será útil para propósitos práticos. Considere a seqüência: 0, 1, 2, 3, 4, 5, 6,..., n 1, n O período pode ficar tão grande quanto quisermos, mas essa seqüência não é aleatória de forma alguma. Qual deve ser o critério de decisão para que possamos concluir com confiança se uma seqüência é aleatória ou não? Se for dada uma caneta e um papel para uma pessoa e pedir-se para essa pessoa escrever uma seqüência de números aleatórios, provavelmente a pessoa não conseguirá escrever uma seqüência satisfatoriamente aleatória. Nós tendemos a evitar coisas que não parecem aleatórias, como dois números repetidos, enquando que estatisticamente se espera que isso ocorra com freqüência. Ao mesmo tempo que se mostrarmos uma tabela de números aleatórios para algúem essa pessoa vai dizer que os números não são aleatórios. Um outro exemplo da nossa errônea intuição é com relação à expansão decimal do número π. Um estatístico diria que é apenas uma seqüência de números aleatórios, enquanto um numerólogo vai encontrar provavelmente toda a história da humanidade ali. Em [3] podemos procurar qualquer seqüência de dígitos em π. Pegando as 4 primeiras notas da primeira prova de MAP-131 e colocando em seqüência: = Obtemos o resultado: The string was found at position counting from the first digit after the decimal point. O que significa que o resultado da prova já estava predestinado por π ou... precisamos de um conceito mais rigoroso de aleatoridade. A seguir veremos os principais testes utilizados para se verificar a aleatoridade de uma seqüência. Em geral supõe-se que a seqüência não é aleatória, e se ela passar satisfatoriamente por uma meia dúzia de testes, consideramos ela satisfatoriamente aleatória. 3.1 Testes de Qui-Quadrado O teste de Qui-Quadrado é provavelmente o teste estatístico mais conhecido, e serve para diversas situações, como teste de homogeneidade de subpopulações, aderência de modelos ou independência de varíaveis. Sua essência se baseia na soma dos resíduos em relação a um modelo esperado, e pode ser esquematizado, de acordo com [4] da seguinte maneira: Dada uma variável X para a qual temos uma amostra de valores, desejamos verificar se essa varíavel se adequa ou não a uma dada distribuição. Dividimos esses valores em k categorias, montando a tabela de freqüência: Categoria k Freq. Observada o 1 o 2 o 3... o k 6

8 A partir do modelo que supomos ser adequado, construímos a tabela de freqüências esperadas de acordo com as categorias acima: Categoria k Freq. Esperada e 1 e 2 e 3... e k Calculamos então uma medida de distância entre os dados observados e o que se esperaria sob a hipótese de que ele segue o modelo que supomos, através da seguinte expressão: k Q 2 (o i e i ) 2 = i=1 Sabe-se que para uma amostra razoavelmente grande, essa quantidade segue uma distribuição de Qui-Quadrado, com k 1 graus de liberdade. Calculamos então: P (χ 2 k 1 > Q 2 obs) (6) Caso esse valor seja muito pequeno ( 0.01) rejeitamos a hipótese de que nossos dados seguem o modelo sugerido. Para testar seqüências de números aleatórios, temos duas aplicações dos testes de Qui-Quadrado. Em primeiro lugar podemos fazer um teste de homogeneidade de subpopulações, dividindo os números aleatórios que geramos em seqüências de m valores e verificando se a distribuição dos números entre esses grupos é homogênea ou não. Outro teste possível é pegar toda a seqüência de números aleatórios, dividíla em k classes, e verificar as freqüências observadas. Supomos então que essa varíavel segue distribuição uniforme contínua, calculamos as freqüências esperadas sob essa hipótese, e verificamos então através de (6) se nossa suposição está correta. 3.2 Testes usando Monte Carlo No trabalho anterior, usamos métodos Monte Carlo para estimar o valor de π. Um dos experimentos consistia em jogar pontos aleatórios numa circunferência circunscrita num quadrado, e fazendo uma razão incluindo as áreas das duas formas geométricas, estimavamos π. Quanto mais aleatoriamente conseguimos jogar os pontos na circunferência, ou em outras palavras, quanto mais aleatórios são os números que conseguimos gerar, melhor vai ser nossa estimativa de π. Para testar a aleatoridade de uma seqüência podemos então fazer o teste do quadrado e ver quão boa é a estimativa de π. 3.3 Teste de Kolmogorov-Smirnov Um outro teste disponível é o teste de Kolmogorov-Smirnov, que pode ajudar a determinar se um dado conjunto de valores provêm de uma dada distribuição ou não. Geramos os números aleatórios, normalmente entre 0 e 1, e verificamos se esse conjunto de dados adere a uma distribuição uniforme no intervalo [0,1]. 3.4 Testes seriais Os testes que vimos até agora verificam a uniformidade de uma seqüencia e suas subseqüências, mas ainda assim, não são capazes de detectar o nível de e i 7

9 dependência entre um número e seu antecessor, para isso temos alguns procedimentos específicos. Um dos testes mais comuns desse gênero é o chamado teste do Poker. Neste teste considera-se n grupos de 5 inteiros sucessivos, e observamos em quais classisficações se encaixam as seqüências: 5 diferentes = todos os números diferentes entre si. 4 diferentes = um par. 3 diferentes = dois pares ou três iguais. 2 diferentes = quatro iguais. 1 diferentes = todos os 5 iguais. Fazemos então um teste de Qui-Quadrado, supondo que o número de casos vai ser equivalente para cada quíntupla. 3.5 Teste de Fernando e Vagner Analisando as seqüências, tivemos a idéia de um outro teste para verificar a dependência entre os números numa seqüência. Dado um vetor num com n elementos, tiramos uma cópia de num em num2, acrescentamos um 0 no final de num e outro 0 no final de num2. Fazemos então a diferença num num2, armazenando isso num vetor residuo. Verificamos então como se comporta a distribuição desses resíduos. Caso não haja uma dependência entre os números, esses resíduos devem se distribuir de forma normal, sem nenhuma tendência específica. Caso haja uma relação forte de dependência, espera-se uma distribuição assimétrica acentuada para um dos lados, assemelhando-se a uma exponencial ou similar. No caso de uma progressão aritmética, como a seqüência proposta no início dessa sessão (0, 1, 2,..n) esse teste descobre na hora que a seqüência não é aleatória, pois todos os resíduos serão iguais, de forma que quando plotarmos o histograma de resíduos todos eles vão estar concentrados numa região só. 3.6 Testando uma seqüência de números aleatórios Por fim, vamos gerar números aleatórios usando nossa implementação do algoritmo linear congruente, e realizar testes para verificar como essa seqüência se comporta. Começamos gerando números entre 0 e 1, com uma semente não especificada. $ numeros tail > num.txt Importamos esses dados no pacote estatístico R: > num <- scan("num.txt") E para fins de controle, geramos mais números aleatorios com distribuição uniforme em [0,1] mas não pela nossa implementação do algoritmo linear congruente e sim pela função equivalente em R: > rnum <- runif(50000,0,1) 8

10 Verificando as estatísticas descritivas observamos que os dados se assemelham: > summary(num) Min. 1st Qu. Median Mean 3rd Qu. Max e e e e e e-01 > summary(rnum) Min. 1st Qu. Median Mean 3rd Qu. Max e e e e e e+00 Verifiquemos os histogramas para essas duas seqüências: 9

11 Realizando um teste de Kolmorov-Smirnov nos dois conjuntos de dados, obtemos: One-sample Kolmogorov-Smirnov test data: num D = , p-value = 1 One-sample Kolmogorov-Smirnov test data: rnum D = , p-value = Indicando que a nossa implementação do método linear congruentes gerou números mais próximos da distribuição uniforme que o próprio gerador do R. Por fim, verifiquemos através do teste que nós implementamos o nível de dependência entre os números subseqüentes. Geramos os vetores auxiliares, calculamos os resíduos, e gerando os histogramas, obtemos: 10

12 O que mostra novamente que a nossa implementação do Algoritmo Linear Congruente foi bem sucedida, gerando a distribuição esperada de resíduos. 11

13 4 Anexos 4.1 Implementação do algoritmo do quadrado do meio /*********************************************************/ /* midsquare.c */ /* Este programa implementa o algoritmo de midsquare */ /* de von Neumann, para geracao de numeros aleatorios */ /* Fernando Henrique Ferraz Pereira da Rosa */ /* Vagner Aparecido Pedro Junior */ /* Data: 12/11/2002 */ /* */ /*********************************************************/ #include <stdio.h> #include <stdlib.h> int conta_digitos(int num); int midcut(int num,int nd); int main(int argc,char **argv) { int seed,nd,next,qtd,i; if (argc!= 3) { printf("uso: \n" " %s semente num, onde semente e um inteiro e \n" " num o numero de numeros aleatorios que voce quer gerar.\n", argv[0]); return(0); sscanf(argv[1],"%d",&seed); sscanf(argv[2],"%d",&qtd); nd = conta_digitos(seed); printf("x[0] = %d\n",seed); for(i=1;i<=qtd;i++) { next = midcut(seed * seed,nd); printf("(%4d)^2 = %10d => x[%3d] = %d\n",seed,seed*seed,i,next); seed = next; return(0); /* conta_digitos: conta o numero de digitos * da representacao decimal de num */ int conta_digitos(int num) { 12

14 int cont; for(cont=1;num%10!= num;cont++) num /= 10; return(cont); /* midcut: retorna o numero que esta no centro * de num, com nd digitos. * o cutpoint e para a esquerda, quando a divisao * nao e exata */ int midcut(int num,int nd) { int i,res,volta; char *string,*midpoint; nd *= 2; res = nd - conta_digitos(num); string = malloc((nd+1) * sizeof(char)); if (res > 0) { for(i=0;i<res;i++) { string[i] = 0 ; midpoint = &string[i+1]; sprintf(midpoint,"%d",num); else sprintf(string,"%d",num); nd /= 2; if (nd % 2 == 0) { /*divisao exata, primeiro tiramos nd/2 elementos do comeco *e depois nd/2 do final*/ for(i=0;i<nd/2;i++) string[i] = ; for(i=3*nd/2;i<2*nd+1;i++) string[i] = ; else { /*como o corte e a esquerda, tiramos nd-nd/2 elementos da esquerda *e nd/2 elementos da direita.*/ for(i=0;i<nd-nd/2;i++) string[i] = ; for(i=2*nd-nd/2;i<2*nd;i++) string[i] = ; sscanf(string,"%d",&volta); return(volta); 13

15 4.2 Implementação do algoritmo linear congruente /*********************************************************/ /* linearcong.c */ /* Este programa implementa o algoritmo linear */ /* congruente. */ /* Fernando Henrique Ferraz Pereira da Rosa */ /* Vagner Aparecido Pedro Junior */ /* Data: 21/11/2002 */ /* */ /*********************************************************/ #include <stdio.h> #include <math.h> #include <stdlib.h> #include <time.h> int verifica_primo(int n); int sorteia_c(unsigned int aux,unsigned int m); int main (int argc,char **argv) { unsigned int n,aux,x0,c,next,m,i,a; srand(time(0)); if (argc!= 2 && argc!= 3) { printf("uso: \n %s n [semente]\n" " com numero o n o numero de numeros aleatorios que voce quer\n" " gerar e opcionalmente uma semente.\n\n",argv[0]); return(0); sscanf(argv[1],"%d",&n); aux = sqrt(n*10); while (verifica_primo(aux) == 0) aux--; m = aux*aux; a = aux+1; c = sorteia_c(aux,m); if (argc == 3) sscanf(argv[2],"%d",&x0); else x0 = ((double)rand()/rand_max)*m; printf("x0 = %d\n" "a = %d\n" "c = %d\n" "aux = %d\n" "m = %d\n",x0,a,c,aux,m); 14

16 for (i=0;i<n;i++) { next = (a*x0 + c) % m; x0 = next; printf("%.20f\n",(double)next/m); return(0); /* verifica_primo: verifica se n e um numero e primo * Pos: retorna 1 se for primo. * retorna 0 caso contrario. */ int verifica_primo(int n) { int i,pausa; pausa = n/2; if (n == 0) return(0); for(i=2;i < pausa;i++) if (n % i == 0) return(0); return(1); /* sorteia_c: acha um valor para c, tal que * c e m sao primos entre si. */ int sorteia_c(unsigned int aux,unsigned int m) { int num; num = ((double)rand()/rand_max)*m/10; while (num == aux) num = ((double)rand()/rand_max)*m/10; return(num); 15

17 Referências [1] GRAYBEAL J.W. e POOCH W. U. Simulation: Principle and Methods. Winthrop Publishers, Inc [2] KNUTH D.E. The Art of Computer Programming vol. 2 : Seminumerical Algorithms. Reading,Mass.: Addilson-Wesley, [3] ANDERSEN G. D. The π Search Page piquery#award. [4] MAGALHÃES. M. N. e LIMA A.C.P. Noções de Probabilidade e Estatística. Edusp, Sobre A versão eletrônica desse arquivo pode ser obtida em net Copyright (c) Fernando Henrique Ferraz Pereira da Rosa. É dada permiss~ao para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentaç~ao Livre GNU (GFDL), vers~ao 1.2, publicada pela Free Software Foundation; Uma cópia da licença em está inclusa na seç~ao intitulada "Sobre / Licença de Uso". 16