Große Zufallszahlen - Eintrittswahrscheinlichkeit

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Große Zufallszahlen - Eintrittswahrscheinlichkeit

    Hallo,
    Ich bin am überlegen sowie auf der Suche nach einer Pseudo-Zufalls-Funktion, die für große Zahlen gedacht ist. Dabei soll man den Range-Wert einstellen können, wie bei (mt_)rand. Die bisherigen Funktionen, die ich gefunden habe, sind ein wenig zu sehr abweichend von der Verteilung der Zahlen in Bezug auf (mt_)rand.

    Desweiteren such ich nach einer einfachereren Lösung für folgendes Szenario bzgl. Eintrittswahrscheinlichkeit bei unterschiedlichen Werten. Der Value-Parameter definiert hier die Chance des Eintretens, des jeweiligen Datensatzes.

    PHP-Code:
    $users = array(
        
    'A' => '100',
        
    'B' => '2000',
        
    'C' => '30000',
        
    'D' => '400000',
        
    'E' => '5000000',
    );

    $maximum array_sum_bignum($users);
    $number  mt_rand_bignum('1'$maximum);
    $users   shuffle_keep_keys($users);
    $count   '0';
    foreach(
    $users AS $name => $value)
    {
        
    $min   bcadd($count'1');
        
    $count bcadd($count$value);
        
    $max   $count;

        if((
    $min <= $number) AND ($max >= $number))
        {
            
    //echo $min . '' . $max . '' . $value;
            
    break;
        }


  • #2
    Ich mag große Zahlen, auch Zufallszahlen und so wieter, aber von dem was du da möchtest, verstehe ich nix! Auch die Funktionen welche da bei dir zum Einsatz kommen habe ich noch nie gesehen.
    Wir werden alle sterben

    Kommentar


    • #3
      Das sind zwei verschiedene Dinge. Beim Ersten gehts nur um den Generator, womit ich größere/kleinere Zahlen rauskriegen möchte als (-)2^31-1. Das Zweite hat mit dem Ersten nur in der Hinsicht was zu tun, weil es um größere Zufallswerte geht. Die Funktionen array_sum_bignum/mt_rand_bignum sind dieselbige wie array_sum/mt_rand, nur mit größeren Werten, wobei die Funktion für die großen Zufallszahlen noch nicht vorhanden ist. Die Funktion shuffle_keep_keys sorgt nur dafür, dass beim Sortieren mit shuffle die Array-Schlüssel erhalten bleiben.
      Zuletzt geändert von OneWayUserAcci; 09.06.2009, 13:07.

      Kommentar


      • #4
        Zitat von OneWayUserAcci Beitrag anzeigen
        Das sind zwei verschiedene Dinge. Beim Ersten gehts nur um den Generator, womit ich größere/kleinere Zahlen rauskriegen möchte als (-)2^31-1.
        PHP-Code:
        echo mt_rand(0pow(260));
        // 1070457797516197888

        echo mt_rand(0pow(260));
        // 426054254793326592

        echo mt_rand(0pow(260));
        // 939119261509484544 

        Kommentar


        • #5
          @h3ll
          PHP: mt_getrandmax - Manual

          Da hasste wohl ein 64 Bit System
          Das hat aber nicht jeder.
          PHP-Code:
          echo mt_rand(0pow(260)).'<br>';
          echo 
          mt_rand(0pow(260)).'<br>';
          echo 
          mt_rand(0pow(260)).'<br>';
          echo 
          mt_rand(0pow(260)).'<br>';
          echo 
          mt_rand(0pow(260)).'<br>'
          Liefert bei mir IMMER und konsequent 0. Nix anderes.
          Wir werden alle sterben

          Kommentar


          • #6
            Zitat von combie Beitrag anzeigen
            @h3ll
            PHP: mt_getrandmax - Manual

            Da hasste wohl ein 64 Bit System
            Das hat aber nicht jeder.
            Tja, wer hat, der hat

            64-Bit Prozessoren kriegt man inzwischen eh schon nachgeschmissen.

            Kommentar


            • #7
              Aus meiner Wühlkiste:
              PHP-Code:
              function bc_rand($start,$end,$scale=null)
              {

                  if(
              is_null($scale))
                  {
                      if(
              bccomp($start,$end) >= 0)
                        throw new 
              Exception('Left Value must be lower');
                  }else
                  {
                      if(
              bccomp($start,$end,$scale) >= 0)
                        throw new 
              Exception('Left Value must be lower');
                  }
                  
              $result '';
                  if(
              is_null($scale))
                  {
                      
              $diff bcsub($end,$start);
                  }else
                  {
                      
              $diff bcsub($end,$start,$scale);
                  }
                  
              $begrenzt true;
                  for(
              $i=0;$i<strlen($diff);$i++)
                  {
                      
              $ziffer $diff{$i};
                      if(
              $ziffer === '.')
                      {
                        
              $result .= '.';
                      }else
                      {
                        if(
              $begrenzt)
                        {
                         
              $neue mt_rand(0,$ziffer);
                         if(
              $neue $ziffer$begrenzt false;
                        }else
                        {
                         
              $neue mt_rand(0,9);
                        }
                        
              $result .= $neue;
                      }
                  
                  }
                    
                  
              $result ltrim($result,'0');
                  if(
              === strpos($result,'.')) $result '0'.$result;
                  
                  if(
              is_null($scale))
                  {
                      return 
              bcadd($start,$result);
                  }else
                  {
                      return 
              bcadd($start,$result,$scale);
                  }
              }

              echo 
              bc_rand('-34534345645635235346332454363453454564','235232389573642345273523451642',6); 
              Wir werden alle sterben

              Kommentar


              • #8
                Nun tritt wieder das Problem der Verteilung auf s.u.. Ich nehm mal an, dass im PHP C-Quelltext keine extra Funktion dafür gebaut wurde und einfach eine von C genommen wurde, daher die Begrenzung?! Und sowas wie Zend_Rand gibts glaub auch net, mal schauen, irgendwie kriegt man das schon zamm gewurschtelt.

                PHP-Code:
                Array
                (
                    [
                10] => 5085
                    
                [7] => 532
                    
                [4] => 524
                    
                [0] => 505
                    
                [8] => 491
                    
                [3] => 485
                    
                [5] => 484
                    
                [9] => 481
                    
                [2] => 480
                    
                [1] => 472
                    
                [6] => 461

                Kommentar


                • #9
                  Ich hab mich für die folgende Funktion entschieden, welche ich gefunden habe.

                  PHP-Code:
                  function bcrand($min$max)
                  {
                      if(
                  bccomp($max$min) != 1)
                      {
                          return 
                  0;
                      }
                      
                  $top    bcsub($max$min);
                      
                  $rand   bcadd($top1);
                      
                  $length strlen($top);
                      while(
                  bccomp($rand$top) == 1)
                      {
                          unset(
                  $rand_part);
                          
                  $n 0;
                          while(
                  $n <= $length)
                          {
                              if(
                  $length $n >= 9)
                              {
                                  
                  $rand_part[] = mt_rand(0999999999);
                              }
                              else
                              {
                                  
                  $j 0;
                                  
                  $foo '';
                                  while(
                  $j $length $n)
                                  {
                                      
                  $foo .= '9';
                                      ++
                  $j;
                                  }
                                  
                  $foo += 0;
                                  
                  $rand_part[] = mt_rand(0$foo);
                              }
                              ++
                  $n;
                          }
                          
                  $i     0;
                          
                  $rand  '';
                          
                  $count count($rand_part);
                          while(
                  $i $count)
                          {
                              
                  $rand .= $rand_part[$i];
                              ++
                  $i;
                          }
                      }
                      return 
                  bcadd($rand$min0);

                  Zuletzt geändert von OneWayUserAcci; 11.06.2009, 13:10.

                  Kommentar

                  Lädt...
                  X