public static int[] base (int ancho_libro,int largo_libro, int ancho_palet,int largo_palet, int empaquetado, int compensacionAncho, int compensacionAlto ) {
       
       /*
        * @Descripcion :
        * - Miembro para calcular la base de un palet. Calcula el mejor 
        * aprovechamiento de un palet con una base dada combinando las 
        * 2 dimensiones de cada uno de los elementos (2 para el libro y 
        * 2 para el palet).
        * 
        * - Usa 4 variables de tipo entero, para las dimensiones. 
        * Devuelve un array de entero.
        */
    
        /* Variables para calcular cuantos entran en el ancho del paler 
        * combinando las dos dimensiones del libro con el ancho del 
        * palet: ancho * ancho / ancho * largo 
        * y con el largo: largo * ancho / largo * largo
        */
        int ancho_palet_a=0;
        int ancho_palet_b=0;
        int largo_palet_a=0;
        int largo_palet_b=0;

        /*
        * Variables para almacenar cuantos entran en cada posición en 
        * cada uno de los lados del palet (a <-> a | b <-> b)
        */
        int entran_ancho_a=0; // ancho del palet * ancho del libro
        int entran_ancho_b=0; // ancho del palet * largo del libro
        int entran_largo_a=0; // largo del palet * largo del libro
        int entran_largo_b=0; // largo del palet * ancho del libro

        /*
        *  Variables para el resto del formato por si puede ponerse un 
        * libro al contrario del resto en esa dimensión
        */
        int resto_division_largo=0;
        int resto_division_ancho=0;

        // Variable para el total de la base donde se almacena el 
        // resultado de la función
        int total=0;
        
        // Cálculo de las primeras variables
        ancho_palet_a = ancho_palet / ancho_libro;
        ancho_palet_b = ancho_palet / largo_libro;
        largo_palet_a = largo_palet / ancho_libro;
        largo_palet_b = largo_palet / largo_libro;
        
        //Determinación cuadrada de la base
        int opcionA=ancho_palet_a*largo_palet_b;
        int opcionB=ancho_palet_b*largo_palet_a;
        
        if (opcionA>opcionB){
            entran_ancho_a= ancho_palet_a;
            entran_largo_a= largo_palet/largo_libro;
        } else {
            entran_ancho_a= ancho_palet_b;
            entran_largo_a= largo_palet/ancho_libro;
        }

        // Determinación del mejor aprovechamiento del ancho del palet
        int i;
        for (i=1; i<= ancho_palet_b; i++)
        {
            if (((ancho_libro*i) + ((ancho_palet_b-(i-1))*largo_libro)) <= ancho_palet)
            {
            entran_ancho_a = i;
            entran_ancho_b = ancho_palet_b-(i-1);
            break;
            }                                            
        }

        /*
        * Obtención de la segunda dimensión del palet en función del 
        * resultado obtenido en el ancho
        */
        entran_largo_a = largo_palet/largo_libro;
        entran_largo_b = largo_palet/ancho_libro;

        /* Si el formato es muy cuadrado y en el ancho salen todos en la
        * misma posición comprueba el mejor aprovechamiento en el largo 
        * del palet y recalcula las dimensiones.
        */
        if (entran_ancho_b <= 0)
        {
            for (i=1; i<= largo_palet_a; i++)
            {
                if (((largo_libro*i) + ((largo_palet_a-(i-1))*ancho_libro)) <= largo_palet)
                        {
                        entran_largo_a = i;
                        entran_largo_b = largo_palet_a-(i-1);
                        break;
                        }                                            
            } 
        }

        // Calcula la base del palet
        total = (entran_ancho_a * entran_largo_a)+(entran_ancho_b*entran_largo_b);
        
        /* Llena el array con lo datos a devolver
         * total --> cantidad total de la base --> index 0
         * entran_ancho_a: 
         * 	cantidad con los que entran de ancho en el ancho --> index 1
         * entran_ancho_b:
         * 	cantidad con los que entran de largo en el ancho --> index 2
         * entran_largo_a:
         * 	cantidad con los que entran de ancho en el largo --> index 3
         * entran_largo_b:
         * 	cantidad con los que entran de largo en el largo --> index 4
         */
        
        int valores [] = {total, entran_ancho_a, entran_ancho_b, entran_largo_a, entran_largo_b};
        return valores;

    }