Software gerador de números aleatórios estatisticamente perfeito

O problema de criação de tais programas foi amplamente discutido na literatura matemática em 1965-1975, ao mesmo tempo em que a complexidade deste problema foi observada.

A matemática moderna fez avanços significativos neste assunto.

Eles são acessíveis a especialistas limitados, mas são difíceis de entender e foram removidos da discussão generalizada.

Apresento aqui uma solução simples para este problema, pode não ser digna da atenção de grandes matemáticos, mas é bastante acessível para iniciantes.

Consegui criar um programa que gera uma sequência de caracteres '0' e '1' com excelentes propriedades estatísticas.

O design do programa é simples e fácil de entender.

Uma sequência aleatória de zeros e uns deve ter as seguintes propriedades:

• o número de zeros e uns em todos os fragmentos desta sequência é aproximadamente o mesmo;
• o número de ocorrências dos fragmentos 00, 01, 10 e 11 é sempre aproximadamente o mesmo;
• o mesmo se aplica a todos os tipos de fragmentos de comprimento 3, 4, 5 e assim por diante.
  
  É claro que o programa pode contar o número de ocorrências de tais fragmentos na sequência já formada e gerar o próximo símbolo de forma a suportar as igualdades listadas.

Se você analisar essas igualdades em ordem crescente de comprimento do fragmento, o programa fará um loop rapidamente.

, , .

?

'0' '1' ( ), , .

, .

, ( lenmask).

, lenmask .

.

s0 s1, .

s0 s1 , s0>s1 1, 0 .

s0 s1 , , 0 1 .

, , .

, , , .

JAVA .

.

.

.

.

O número de ocorrências dessas máscaras na sequência gerada é contado.

Como esperado, os resultados do controle demonstram que o número dessas ocorrências depende do comprimento da máscara e quase não depende do seu preenchimento.

É surpreendente que um programa tão elementar permita obter um resultado que parecia inatingível por meios simples.

inscrição

Texto do programa JAVA

//gerase = generator random sequence
//   
//    
package ikojar;
public class gerase {
public static void main(String[] args) {
//  
//,     
//   beg  
//  
int beg=5,
//  
lenrez=2048,
//maxpower      
//     
//    
//   
//   
//   
//     
//      
//   
maxpower=10;

//   
//rs  random symbol,   , 
//       
//     ,  
//   ,       
byte rs=0;
// result     
//  
byte[] result=new byte[lenrez];
// mask    ,  
//   , 
//     
//     , 
//       
byte[] mask=new byte[lenrez];

//   
//   beg
//    beg   
//     result
int p=beg,bp=0;
for(;;)
{//cir raspak
result[bp]=(byte)(p%2);
bp++;
if(p<2)break;
p/=2;
}//cir raspak
//  
String so="  ";
for(int i=0;i<bp;i++)so+=String.valueOf(result[i]);
System.out.println(so);
//  
System.out.println(" ");

//   
for(int pos=bp;pos<lenrez;pos++)
{//circlepos
// hs(hard symbol)  
// ,      
//    
//      , 
//      rs
int hs=0;
//    
//lenmask   
for(int lenmask=pos-2;lenmask>=0;lenmask--)
{//lenmask
//    
//  
for(int i=0;i<lenmask;i++)mask[i]=result[pos+i-lenmask];
//s0  s1    
//     
//      
//   
//      
int s0=0,s1=0;
//     
//   
for(int i=lenmask;i<pos;i++)
{//calcS01
//eqm     
//    
int eqm=1;
// eqm
for(int i1=0;i1<lenmask;i1++)if(mask[i1]!=result[i+i1-lenmask]){eqm=0;break;}
//      ,  
//    
if(eqm==1)if(result[i]==0)s0++;else s1++;
}//calcS01

//     
//     s0  s1
// hs   1,  
//     
if(s0<s1){result[pos]=0;hs=1;break;}
if(s1<s0){result[pos]=1;hs=1;break;}
}//lenmask
if(hs==1)continue;
//     , 
//     rs
result[pos]=rs;rs=(byte)(1-rs);
}//circlepos

//  
//    
so="";
for(int i=0,c=0;i<lenrez;i++)
{//out rez
so+=String.valueOf(result[i]);
c++;
if(c==64){c=0;System.out.println(so);so="";}
}//out rez
System.out.println(so);

//     
System.out.println
("   ");

//     
//pw    , 
//   
for(int pw=1;pw<maxpower;pw++)
{//pw
//    
//    
//       
//     
//   
//      0  pm-1
//  pm      
int pm=1;for(int i=0;i<pw;i++)pm*=2;
//   ,    
//    
System.out.println("   "+String.valueOf(pw));
int mincount=lenrez,maxcount=0;
//      0  pm-1, 
//      
for(int im=0;im<pm;im++)
{//im
//     im
p=im;
for(int i=pw-1;i>=0;i--)
{mask[i]=(byte)(p%2);p/=2;}

//     
//   
// s     
//    
int s=0;
for(int i0=pw;i0<=lenrez;i0++)
{//i0
//      
int eqm=1;
for(int i1=0;i1<pw;i1++)if(result[i0+i1-pw]!=mask[i1]){eqm=0;break;}
if(eqm==1)s++;
}//i0
//    
//   
//     
//System.out.println(String.valueOf(s));

//    
if(s<mincount)mincount=s;
if(s>maxcount)maxcount=s;
}//im
System.out.println(" ="+String.valueOf(mincount));
System.out.println(" ="+String.valueOf(maxcount));
}//pw

return;
}//main

}//class