90
edits
Changes
Jump to navigation
Jump to search
no edit summary
'''''nextpart(%%);'''''
'''''lastpart(4);'''''
==='''4. Probabilidade discreta'''===
Para encontrar a probabilidade de um evento numa amostra de espaço finita, calcula-se o número de vezes que o evento ocorre, e divide-se pelo número total de resultados possíveis (o tamanho do espaço de amostra).
Como no exemplo 4, seção 4.4, nós calculamos a probabilidade de ganhar na loteria, onde precisamos escolher 6 números corretamente de 40 números possíveis. O número total de maneiras de escolher 6 números é:
'''''numbcomb(40,6);'''''
e existe uma combinação vencedora. Portanto a probabilidade é
'''''1/%;'''''
a qual nós podemos ver como uma aproximação de um número real usando a função “evalf” - avaliação como um número de ponto flutuante.
'''''evalf(%);'''''
Nós também podemos forçar uma aproximação decimal do resultado usando 1.0, ou simplesmente 1., para mostrar que nós desejamos trabalhar com decimais em vez da representação racional exata. Por exemplo, se precisarmos escolher de 50 números, a probabilidade é:
'''''1./numbcomb(50,6);'''''
Para outro exemplo do uso do Maple no estudo da probabilidade discreta, permita-nos usar Maple para verificar a asserção no exemplo 144 na página 278 do texto. A afirmação é que o valor esperado do número de sucessos para “n” tentativas Bernoulli, cada uma com a probabilidade “p” de sucesso, é “np”. Nós usaremos “EV” para denotar o valor esperado em Maple. (Nós não podemos usar “E” porque aquele símbolo é reservado para a base do logaritmo natural.) Nós sabemos que
'''''p(X=k) := binomial(n, k) * p^k * (1 - p)^(n - k);'''''
A partir da definição, nós temos
'''''EV(X) := sum(k * p(X=k), k = 1..n);'''''
'''''simplify(%);'''''
==='''5. Gerando combinações e permutações'''===
Aqui está uma implementação do algoritmo para gerar a próxima r-combinação (exemplo 5).
'''''NextrCombination := proc(current, n, r)'''''
'''''local next, i, j;'''''
faça uma cópia que possamos mudar
'''''next := table(current);'''''
'''''i := r;'''''
'''''while next[i] = n - r + i do i := i -1 od;'''''
'''''next[i] := next[i] + 1;'''''
'''''for j from i+1 to r do'''''
'''''next[j] := next[i] + j - i;'''''
'''''od;'''''
'''''[seq( next[i], i=1..r) ]; # return the answer'''''
'''''end:'''''
Teste-a no exemplo.
'''''NextrCombination([1,2,5,6], 6, 4);'''''
'''''NextrCombination(%,6,4);'''''
'''''NextrCombination(%,6,4);'''''
Alguma explicação é necessária. Primeiro, a combinação atual é uma lista, não um conjunto. Isso é porque a lista é ordenada, mas um conjunto é desordenado. Para encontrar a “next” combinação, nós precisamos saber a ordem dos elementos na combinação atual. Mas no Maple, a ordem que digitamos um conjunto e a ordem que aparece dentro do Maple não são necessariamente a mesma coisa.
'''''pear, orange, apple;'''''
Mas ela sempre a mesma para uma lista.
'''''[pear,orange,apple];'''''
O próximo problema é que você não pode, antes da versão 4 do Maple V, atribuir um elemento específico dentro de uma lista.
'''''mylist := [a,b,c,d]:'''''
'''''mylist[2] := e;'''''
Então, a primeira coisa que fazemos nesse algoritmo é fazer uma tabela que contém todos os elementos na combinação. Nós podemos atribuir na tabela, então nosso problema acaba.
'''''mytable := table(mylist);'''''
'''''mytable[2] := e;'''''
'''''print(mytable);'''''
Com o pacote “combstruct”, você pode criar um iterador que vai produzir todos os objetos de um certo tamanho, um por vez.
'''''it := iterstructs(Combination(6),size=4):'''''
'''''nextstruct(it);'''''
'''''nextstruct(it);'''''
'''''nextstruct(it);'''''
Chamando essa função algumas vezes mais, nos leva a:
'''''nextstruct(it);'''''
onde a próxima 4-combinação é então:
'''''nextstruct(it);'''''
pela qual nós podemos ver que esse iterador está usando a mesma lexicografia ordenando como usamos no algoritmo 3.
