Kellosarjassa olevat satunnaiset bitit

Tässä uusimmassa versiossa yritetään laskea paremmin kellosarjasta tulevia satunnaisbittejä. Ohjelmassa lasketaan satunnaisbittejä neljällä eri tavalla. Ensimmäisessä tavassa (muuttuja b) lasketaan kellosarjojen pituuksia, eli sitä kuinka monta kertaa peräkkäin sama numero ilmenee. Tämä tapa on ollut mukana alusta asti. Toinen tapa on periaatteessa sama, aina kun kellosarjan numero vaihtuu, lisätään teoreettiseen satunnaisuuteen yksi bitti (muuttuja rndbits). Kolmannessa tavassa lisätään satunnaisuuteen yksi bitti aina kun kellosarjan pituus vaihtuu (muuttuja rndbits2). Neljännessä tavassa (rndbits3) tarkastellaan viittä erilaista edellistä kellosarjan pituutta, ja aina kun tulee edellisistä poikkeava kellosarjan pituus lisätään satunnaisuutta yhden bitin verran.

Kaikkien näiden tapojen pitää toteutua eli laskennallisia satunnaisbittejä jokaisella tavalla tulee olla enemmän kun haluttuja satunnaisbittejä puskurissa.

Clockbytes ehto varmistaa että kellomateriaalia käsitellään ainakin 2 kiloa.

Sen verran ovat palautetut satunnaisbitit parantuneet, että ensimmäisissä testeissä dieharder ei huomannut yhtään heikkoutta. Aiemmin niitä oli pari kolme.

void ressu_genbytes(int size, unsigned char *buffer, int b) /* (c) JariK 2013-2019 */
{
  int c, d, e, f, g,
    byte, prevbyte,
    chainbytes, prevchainbytes = -1,
    clockbytes = 0,
    rndbits = 0, rndbits2 = 0,
    rndbits3 = 0;
  unsigned char oldchains[5] = { 0,0,0,0,0 };
  
  prevbyte=clockbyte();
  chainbytes=1;
  f=0;

  for(c=0; c < 8*b || clockbytes < 2000 ||
        rndbits < 8*size ||
        (rndbits2 > 0 && rndbits2 < 8*size ) ||
        (rndbits3 > 0 && rndbits3 < 8*size); c++)
  {
    for(d=0; d<size; d++) {
      e = buffer[d];
      e = ((e&0x80)>>7) | ((e&0x7f)<<1);
      byte = clockbyte();
      buffer[d] = e^byte;
      if(prevbyte != byte) {
        prevbyte = byte;
        rndbits++;
        if(prevchainbytes != chainbytes) {
          prevchainbytes = chainbytes;
          rndbits2++;
          for(g = 0; g < sizeof(oldchains); g++)
          {
            if(oldchains[g] == chainbytes)
              break;
          }
          if(g == sizeof(oldchains)) {
            rndbits3++;
            g--;
          }
          while(g > 0) {
            oldchains[g] = oldchains[g-1];
            g--;
          }
          oldchains[0] = chainbytes;
        } // if(prevchainbytes
        clockbytes+= chainbytes;
        chainbytes = 0;
      } // if(prevbyte
      chainbytes++;
    } // for(d
    for(d=0; d<size; d++) {
      f = (f+buffer[d])%size;
      e = buffer[d];
      buffer[d] = buffer[f];
      buffer[f] = e;
    }
  } // for(c
}

Tässä vielä rutiini alkuperäisen b:n laskentaan.

int ressu_calculate_b()
{
  int c,d,e,total,count,bytes;

  total=0;
  count=0;
  d=clockbyte();
  for(c=0;c<4096;c++) {
    bytes=1;
    while((e=clockbyte())==d)
      bytes++;
    total+=bytes;
    count++;
    d=e;
  }

  return((int)((float)total/count));
}

Clockbyte löytyy aiemmasta postista.