Esta clase la realice no se con que fin y no se que utilidad pueda tener todavia, mas allá de jugar un rato con ella y programar otro poco. Se encarga de generar números aleatorios en un entorno dado, pudiendo elegir incluso la cantidad de decimales, la clase nos retorna como salida un arreglo con la cantidad de elementos seleccionados.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
<?php
/**
 * Clase Aleatorio.
 * Genera un numero aleatorio entre dos numeros dados.
 *
 * @package     matematica creado en el projecto ipusa
 * @copyright   2010 - ObjetivoPHP
 * @license     Gratuito (Free) http://www.opensource.org/licenses/gpl-license.html
 * @author      Marcelo Castro (ObjetivoPHP)
 * @link        objetivophp@*****.***
 * @version     1.0.0 (17/09/2010 - 17/09/2010)
 */
class Aleatorio
{
    /**
     * Es el extremo inferior del entorno de los numero aleatorios.
     * @var float
     */
    private $_extremoInferior = 0;
 
    /**
     * Es el extremo superior del entorno superior de los numeros aleatorios.
     * @var float
     */
    private $_extremoSuperior = 1;
 
    /**
     * Cantidad de decimales, 0 para entero, max 10.
     * @var integer
     */
    private $_decimales = 0;
 
    /**
     * Cantidad de numeros aleatorios a Generar.
     * @var integer
     */
    private $_cantidad = 1;
 
    /**
     * Configura si seran aleatorios unicos false, o true para que se puedan repetir.
     * @var boolean
     */
    private $_permitirRepetidos = true;
 
    /**
     * Guarda los numeros aleatorios generados.
     * @var array
     */
    private $_aleatorios = array();
 
    /**
     * Metodo __construct.
     * @param   double  $extInferior    Numero minimo que se puede generar.
     * @param   double  $extSuperior    Numero maximo que se puede generar.
     * @return  void
     */
    public function  __construct($extInferior, $extSuperior)
    {
        if ($extSuperior > $extInferior) {
            $this->_extremoInferior = $extInferior;
            $this->_extremoSuperior = $extSuperior;
        }
    }
 
    /**
     * Metodo setDecimales.
     * Configura cuantos decimales despues de la coma deber tener el numero
     * aleatorio generado.
     * @param   integer $decimales  cantidad de decimales despues de la coma.
     * @return  void
     */
    public function setDecimales($decimales)
    {
        if ($decimales >=0 && $decimales <=10) {
            $this->_decimales = (int) $decimales;
        }
    }
 
    /**
     * Metodo setCantidad.
     * Configura la cantidad de numeros aleatorios que deberan generarse.
     * @param   integer $cantidad   Cantidad de numeros a generarse.
     * @return  void
     */
    public function setCantidad($cantidad)
    {
        $this->_cantidad = ($cantidad > 0)? (int) $cantidad : 1;
    }
 
    /**
     * Metodo setPermitirRepetidos.
     * Configuramos si se pueden repetir numeros o no.
     * @param   boolean $repetir true se pueden repetir los numeros
     *                           false no se puede repetir
     * @return  void
     */
    public function setPermitirRepetidos($repetir = true)
    {
        $this->_permitirRepetidos = ($repetir)? true : false;
    }
 
    /**
     * Metodo generar.
     * Genera los numeros aleatorios.
     * @return array
     */
    public function generar()
    {
        if (!$this->_controlarBucle()) {
            trigger_error('No se permite generar mas del 75% de los numeros unicos.', E_USER_ERROR);
            return;
        }
        mt_srand();
        $maxAleatorio   = mt_getrandmax();
        $amplitud       = $this->_extremoSuperior - $this->_extremoInferior;
 
        for ($i = 0; $i < $this->_cantidad; $i++) {
            do {
                $aleatorio  = mt_rand() / $maxAleatorio;
                $numero     = ($amplitud * $aleatorio) + $this->_extremoInferior;
                $numero     = number_format($numero, $this->_decimales);
            } while (!$this->_permitirRepetidos && in_array($numero, $this->_aleatorios));
            $this->_aleatorios[$i] = $numero;
        }
        return $this->_aleatorios;
    }
 
    /**
     * Metodo getAleatorios.
     * Retorna los numeros aleatorios que fueron generados.
     * @param   integer $orden 1 = Ascendente, 2 = descendente, otro sin ordenar.
     * @return  array
     */
    public function getAleatorios($orden = null)
    {
        $numeros    = $this->_aleatorios;
        switch ($orden) {
            case 1:
                sort($numeros);
                break;
            case 2:
                rsort($numeros);
                break;
            default:
        }
        return $numeros;
    }
 
    /**
     * Metodo _controlarBucle.
     * Ofrece seguridad de no caer en un bucle infinito.
     * @return boolean
     */
    private function _controlarBucle()
    {
        $posible    = true;
        if ($this->_permitirRepetidos === false) {
            $intervalo      = 1 / pow(10, $this->_decimales);
            $amplitud       = $this->_extremoSuperior - $this->_extremoInferior + $intervalo;
            $maxCantidad    = $amplitud / $intervalo;
            if (($maxCantidad * 0.75) <= $this->_cantidad) {
                $posible    = false;
            }
        }
        return $posible;
    }
}
Bueno la utilización es sencilla. Como siempre primero instanciamos la clase, dándole los parámetros inferiores y superiores. Luego si queremos alguna opción más se la damos y por ultimo enviamos a generar.

Ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Instanciamos la clase y le decimos que genere en el entorno 15,99
$obj = new Aleatorio(15, 99);
//Podemos Congiguramos la cantidad de numeros que queremos si no ponemos nada es 1.
$obj->setCantidad(5);
// Cantidad de números después de la coma, 0 (cero) para enteros.
$obj->setDecimales(0);
// Configuramos si queremos que se repitan o no los numeros aleatorios.
$obj->setPermitirRepetidos(false);
// Generamos los numeros una vez seleccionadas las opciones que queremos.
// generar retorna un arreglo pero si no lo capturamos lo podremos hacer luego 
// con getAleatorios
$obj->generar();
// Capturamos los numeros generados.
// 1> ascendente - 2> Descendente - nullo como salieron
$numeros    = $obj->getAleatorios(1);
// Imprimimos los resultados
var_dump($numeros);

Bueno espero que a alguna persona le sea de utilidad.