<?php
/**
 * Clase Fixture.
 * Genera una tabla de cruces para un torneo tipo Single Round Robin. o de
 * liguilla.
 *
 * @author      Marcelo Castro
 * @package     Fixture creado en el projecto opet
 * @copyright   2011 - ObjetivoPHP
 * @license     Gratuito (Free) http://www.opensource.org/licenses/gpl-license.html
 * @author      Marcelo Castro (ObjetivoPHP)
 * @link        objetivophp@******.*****
 * @link        http://objetivophp.com
 * @version     0.0.1 (19/02/2011 - 21/02/2011)
 */
class Fixture
{
    /**
     * Cantidad de equipos participantes en el torneo.
     * @var integer
     */
    private $_cantidadEquipos   = 10;
 
    /**
     * Cantidad de equipos utilizados para armar el fixture.
     * Puede haber uno mas en caso de ser impar el numero de equipos.
     * @var integer
     */
    private $_equiposFixture;
 
    /**
     * Cantidad de fechas que contendra el torneo.
     * @var integer
     */
    private $_fechas;
 
    /**
     * Cantidad de partidos que se jugaran por fecha.
     * @var integer
     */
    private $_partidosXFechas;
 
    /**
     * Guarda la matriz del fixture, incluye el equipo ficticio en caso de que
     * sea necesario.
     * @var array
     */
    private $_fixture           = array();
 
    /**
     * Contiene los nombres de los equipos o en su defecto los numeros, que se
     * le otorgaron a cada uno.
     * @var array
     */
    private $_equipos           = array();
 
    /**
     * Contiene si se seudo-aleatoriza la tabla de cruces o no.
     * @var boolean
     */
    private $_aleatorio         = true;
 
    /**
     * Contiene que debe de ponerse cuando un cuadro queda libre, caso
     * de cantidad de cuadros impares.
     * @var string
     */
    private $_libre             = 'libre';
 
    /**
     * Metodo __construct.
     * @param   mixed     $equipos    Cantidad de equipos o arreglo con los nombres.
     * @return  void
     */
    public function __construct($equipos = null)
    {
        if (is_array($equipos)) {
            $this->_cantidadEquipos = count($equipos);
            $this->_equipos         = $equipos;
        } else {
            $this->_cantidadEquipos =  is_int($equipos)? $equipos : 10;
            for ($f = 0; $f <= $this->_cantidadEquipos; $f++) {
                $this->_equipos[$f] = $f+1;
            }
        }
 
        $this->_partidosXFechas = ceil($this->_cantidadEquipos /2 );
        $this->_equiposFixture  = $this->_cantidadEquipos +  $this->_cantidadEquipos % 2;
        $this->_fechas          = $this->_partidosXFechas * 2 - 1 ;
    }
 
    /**
     * Configura si se aleatoriza la tabla de cruces.
     * @param   boolean     $aleatorio
     * @return  void
     */
    public function setAleatorio($aleatorio = true)
    {
        $this->_aleatorio   = ($aleatorio)? true : false;
    }
 
    /**
     * Asigna el comentario para fecha libre.
     * @param   string  $cometario
     * @return  void
     */
    public function setFechaLibre($comentario)
    {
        $this->_libre = $comentario;
    }
 
    /**
     * Metodo tablaDeCruces.
     * Genera una matriz con los cruces correspondientes entre los equipos.
     * @return void
     */
    public function tablaDeCruces()
    {
        $fixture   = array();
        if ($this->_aleatorio) {
            shuffle($this->_equipos);
        }
 
        if ($this->_cantidadEquipos % 2) {
            $this->_equipos[$this->_equiposFixture-1] = $this->_libre;
        }
 
        // Lleno el indice A de cada elemento con numeros del numero 1
        // hasta llegar al maximo de fechas y vuelvo a comenzar en 1.
        // El ultimo numero puesto debe ser el maximo de fechas.-
        $datos      = $this->_partidosXFechas * $this->_fechas;
        for ($f = 1; $f <= $datos; $f++) {
 
            $col        = $f % $this->_partidosXFechas;
            $col        = ($col != 0)? $col : $this->_partidosXFechas;
            $fila       = ceil ($f / $this->_partidosXFechas);
            $auxiliar   = $f % $this->_fechas;
            if ($auxiliar == 0) {
                $auxiliar = (int) $this->_fechas;
            }
            $fixture[$fila][$col]['A'] = $this->_equipos[$auxiliar-1];
        }
 
        // Lleno el primer elemento de cada fila con el ultimo equipo
        // o el equipo ficticio, si la cantidad de equipo es impar.
        for ($f = 1; $f<= $this->_fechas; $f++) {
            $fixture[$f][1]['B']    = $this->_equipos[$this->_equiposFixture-1];
        }
 
        // Lleno el indice B de cada elemento empezando del maximo de fechas
        // hasta 1 y vuelvo a empezar salteo la primer columna que ya fue completada
        // en el ciclo anterior
        $indice = $this->_fechas;
        for ($f = 1; $f <= $this->_fechas; $f++) {
            for ($c = 2; $c <= $this->_partidosXFechas; $c++) {
                $fixture[$f][$c]['B']   = $this->_equipos[$indice - 1];
                if (--$indice == 0) {
                    $indice = $this->_fechas;
                }
            }
        }
        $this->_fixture     = $fixture;
    }
 
    /**
     * Retorna el arreglo de todos los cruces.
     * @return array 
     */
    public function getCruces()
    {
        return $this->_fixture;
    }
 
    /**
     * Metodo verCuadro.
     * Muestra la tabla de cruces en una tabla HTML, es solo a efectos demostrativos
     * @return  HTML
     */
    public function verCuadro()
    {
        echo "<table border=1>\n";
        for ($f = 1; $f <= $this->_fechas; $f++) {
            echo "<tr>\n";
            for ($c = 1; $c <= $this->_partidosXFechas; $c++) {
                echo "<td>";
                echo utf8_decode($this->_fixture[$f][$c]['A']);
                echo '</br>' . utf8_decode($this->_fixture[$f][$c]['B']);
                echo "</td>\n";
            }
            echo "</tr>\n";
        }
        echo "</table>";
    }
}

<?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;
    }
}

// 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);

<?php
// iniciamos session para no propagar por url variables que nos van a ayudar
// a mejorar la rapidez y la presentacion.
session_start();
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>BUSCADOR FULLTEXT + PAGINADOR</title>
</head>
 
<body>
	<?php
	// Parametros a ser usados por el Paginador y el Buscador
	$cantidadRegistrosPorPagina	= 1;
    $cantidadEnlaces            = 5; // Cantidad de enlaces que tendra el paginador.
    $totalRegistros             = 0;
 
    // Vemos si viene por el paginador o por el form del buscador
    if (isset($_POST['buscar'])) { // Viene por el buscador
        $pagina                 = 0;
        $inicioLimit            = 0;
        $_SESSION['BUSCAR']     = $_POST['buscar'];
        // Configuro el paginador
        require_once 'BuscadorFullText.php';
        $objBuscador				= new BuscadorFullText($_POST['buscar'], 'buscador');
        // Agregamos los campos donde se buscara las palabras o criterios de busqueda
        $objBuscador->addCamposFullText('titulo, desarrollo');
 
        // Campos que se obtendran como resultado
        $objBuscador->addCamposResultado(array('idNoticia', 'titulo', 'desarrollo', 'categoria'));
 
        // Parametros que pueden variar en este caso debe coincidir el nombre del campo en el form html
        // con el nombre en la tabla MySQL
        if (isset($_POST['categoria']) && $_POST['categoria'] ) {
            $objBuscador->addParametrosVariables('categoria' , '=');
        }
        // añade a la consulta una condicion fija
        $objBuscador->addParametrosFijos("estado LIKE 'aprobada'");
 
        // Para limitar la cantidad de caracteres en la salida de algun campo
        $objBuscador->limitarLargo('titulo', 100);
        $objBuscador->limitarLargo('desarrollo', 250);
        // Capturamos la consulta que se debe realizar y agregamos el limit
        $consulta                = $objBuscador->getConsultaMysql();
        $_SESSION['CONSULTA']    = $consulta;
 
    } else { // Viene por el paginador
        $pagina					= isset($_GET['pagina'])? $_GET['pagina'] : 0;
        $inicioLimit			= $cantidadRegistrosPorPagina * $pagina;
        $consulta               = isset($_SESSION['CONSULTA'])?$_SESSION['CONSULTA'] : '';
        $_SESSION['BUSCAR']     = isset($_SESSION['BUSCAR'])? $_SESSION['BUSCAR'] : '';
    }
 
	// incluimos e instanciamos la clase buscadorFullText, pasando como parametros
    // el valor del campo de busqueda y la tabla a buscar.
	?>
    <div align="center">
	<form id="form1" name="form1" method="post" action="">
		<input type="text" name="buscar" id="buscar" value="<?php echo $_SESSION['BUSCAR']; ?>" />
			<select name="categoria" id="categoria">
		  		<option value="0">Todo el Sitio</option>
                <option value="Noticias">Noticias</option>
		  		<option value="Reportes">Reportes</option>
		  		<option value="Revisiones">Revisiones</option>
	    	</select>
	  	<input type="submit" name="enviar" id="enviar" value="Enviar" />
    </form>
    <?php
	echo 'Consulta Generada: <br />' .$consultaLimit      = sprintf($consulta, $inicioLimit, $cantidadRegistrosPorPagina);
    echo '</div><br /><br />';
 
    if ($consultaLimit) {
        // CONEXION MYSQL
        // Bueno ahora lo hacemos con la clasica mysql_connect.
        $conexion           = mysql_connect('localhost', 'root', '');
        mysql_select_db('buscadorfulltext', $conexion);
        $resultados         = mysql_query($consultaLimit, $conexion);
        $resultadosCantidad = mysql_fetch_row(mysql_query("SELECT FOUND_ROWS();", $conexion));
        $totalRegistros     = $resultadosCantidad[0];   // Se usara en el Paginador
        // Mostramos los resultados de la forma clasica
        echo '<table>';
        while($fila = mysql_fetch_array($resultados)) {
            echo '<tr >';
                echo '<td style="border:1px; border-style:solid;">' . $fila['idNoticia'] . '</td>';
                echo '<td style="border:1px; border-style:solid;">' . $fila['titulo'] . '</td>';
                echo '<td style="border:1px; border-style:solid;">' . $fila['desarrollo'] . '</td>';
                echo '<td style="border:1px; border-style:solid;">' . $fila['categoria'] . '</td>';
            echo '</tr>';
        }
        echo '</table>';
    } else { // Muestro Propiedades del Buscador
    ?>
     <div align="center">
  <center>
  <table border="0" cellpadding="0" cellspacing="0" width="450" id="AutoNumber1" height="312">
    <tr>
      <td height="17" colspan="2">Propiedades del Buscador FULLTEXT</td>
      </tr>
    <tr>
      <td width="11%" height="17"><b>Operador</b></td>
      <td width="89%" height="17">
      <p align="center"><b>Significado</b></td>
    </tr>
    <tr>
      <td width="11%" align="center" height="13"></td>
      <td width="89%" height="13"> </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="36" style="border-bottom: 1px dotted #000000">&nbsp;</td>
      <td width="89%" height="36" align="justify" style="border-bottom: 1px dotted #000000">Por defecto no se especifica nada, las palabras son
      optativas pero tendran mayor importancia los registros con mas palabras
      coincidentes. </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="23" style="border-bottom: 1px dotted #000000">+</td>
      <td width="89%" height="23" align="justify" style="border-bottom: 1px dotted #000000">Indica que la palabra debe estar presente en los&nbsp;
      registro buscados. </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="23" style="border-bottom: 1px dotted #000000">-</td>
      <td width="89%" height="23" align="justify" style="border-bottom: 1px dotted #000000">Indica que la palabra no debe estar presente en los
      registros buscados.</td>
    </tr>
    <tr>
      <td width="11%" align="center" height="54" style="border-bottom: 1px dotted #000000">&lt;&gt;</td>
      <td width="89%" height="54" align="justify" style="border-bottom: 1px dotted #000000">Estos dos operadores se acostumbran a usar para cambiar la
      importancia de una palabra en la b&uacute;squeda. El signo &lt; disminuye la
      contribuci&oacute;n y el signo &gt;&nbsp; la aumenta. </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="90" style="border-bottom: 1px dotted #000000">~</td>
      <td width="89%" height="90" align="justify" style="border-bottom: 1px dotted #000000">El tilde opera como negaci&oacute;n, causando una importancia negativa de la
      palabra en la b&uacute;squeda. Es &uacute;til para marcar las palabras de ruido. Una
      fila que contiene dicha palabra se le dara una importancia mas baja que
      otras, pero no se excluir&aacute; de los resultados, como si ocurrir&iacute;a si se
      usara el operador menos.</td>
    </tr>
    <tr>
      <td width="11%" align="center" height="36" style="border-bottom: 1px dotted #000000">&quot;</td>
      <td width="89%" height="36" align="justify" style="border-bottom: 1px dotted #000000">Las comillas dobles al principio y final de una frase,
      buscara s&oacute;lo registros que contienen la frase completa , tal como se
      tecle&oacute;.</td>
    </tr>
    </table>
  </center>
</div>
 
    <?php
    }
    // Comenzamos con el paginador.
    require_once 'Paginador.php';
    // Instanciamos la clase Paginador
    $paginador          = new Paginador();
 
    // Configuramos cuanto registros por pagina que debe ser igual a el limit de la consulta mysql
    $paginador->setCantidadRegistros($cantidadRegistrosPorPagina);
    $paginador->setCantidadEnlaces($cantidadEnlaces);
 
    // Y mandamos a paginar desde la pagina actual y le pasamos tambien el total
    // de registros de la consulta mysql.
    $datos              = $paginador->paginar($pagina, $totalRegistros);
 
 
    // Preguntamos si retorno algo, si retorno paginamos con los datos que nos da el
    // paginador que es un arreglo.
    if ($datos) {
        echo '<div align="center">';
        echo 'Pagina: ' . ($pagina + 1) . ' de ' . $paginador->getCantidadPaginas() . '<br />';
        echo 'Registros encontrados: ' . $totalRegistros . '<br />';
        foreach ($datos as $enlace) {
        ?>
            <a href="?pagina=<?php echo $enlace['numero']; ?>" title="<?php echo $enlace['title']; ?>" style="text-decoration:none;"><?php echo $enlace['vista']; ?></a>
        <?php
        }
        echo "</div>";
    }
    ?>
    <br />
</body>
</html>