Primera prctica de Programacin 2 Curso 2016/2017

Los tipos integrales con signo

En Java, los diferentes tipos que representan nmeros enteros se denominan tipos
integrales. Se diferencian entre s en el nmero de bits que utilizan para representar un
nmero entero y en si la representacin tiene en cuenta el signo del nmero entero.
Si queris una descripcin detallada de cmo funcionan, podis consultar la especificacin
del lenguaje Java que podis encontrar en:

The Java Language Specification (Java SE 8 Edition)

En esta prctica, para simplificar, nos centraremos en los t ipos integrales con signo:
byte, short, int y long cuyos tamaos son 8, 16, 32 y 64 bits respectivamente. Por ello,
en el esqueleto de la solucin que os hemos proporcionado se tiene:

public int BYTE_SIZE = 8;

public int SHORT_SIZE = 16;
public int INTEGER_SIZE = 32;
public int LONG_SIZE = 64;

Para representar estos tipos integrales usaremos arrays de enteros en los que, en cada
posicin, tendremos el valor de un bit, es decir, arrays de ceros o unos. El bit menos
significativo estar en la posicin 0 del array, es decir:

En el proyecto os proporcionamos funciones para crear ceros (todos los bits a cero) de
integrales de diferentes longitudes:

public int[] zeroOfSize(int size) {

return new int[size];
}
public int[] zeroByte() {
return zeroOfSize(BYTE_SIZE);
}
public int[] zeroShort() {
return zeroOfSize(SHORT_SIZE);
}
public int[] zeroInteger() {
return zeroOfSize(INTEGER_SIZE);
}
public int[] zeroLong() {
return zeroOfSize(LONG_SIZE);
}

1
Primera prctica de Programacin 2 Curso 2016/2017

Para simplificar las pruebas, tambin os proporcionamos una funcin para convertir un int[]
(que solamente contiene ceros y unos) en un String, de manera que se pueda leer
cmodamente (es decir, de izquierda a derecha):

public String toString(int[] num) {

char[] chars = new char[num.length + num.length/8];
int iChars = 0;
for (int iNum = num.length-1; iNum >= 0; iNum--) {
chars[iChars] = (char) ('0' + num[iNum]);
iChars = iChars + 1;
if (iNum != 0 && iNum % 8 == 0) {
chars[iChars] = ' ';
iChars = iChars + 1;
}
}
return new String(chars, 0, iChars);
}

Si no comprendis exactamente cmo funciona no os preocupis. Ms adelante

detallaremos su diseo.

Funciones de test
En el proyecto os incluimos un conjunto de funciones de test que comprueban si las
funciones que habis implementado calculan correctamente sus resultados para algunos
valores de sus parmetros. Es muy importante que os acostumbreis a probar
exhaustivamente vuestros programas. Es por ello muy interesante que estudiis
detenidamente el cdigo de pruebas que se os proporciona ya que os puede servir de
inspiracin para hacer pruebas en otros contextos.

En general, un conjunto de test nunca podr garantizar que la funcin sea correcta al 100%.
Pero cuantos ms tests diferentes se hagan, ms seguridad tendremos en que la funcin no
contiene errores. Eso s, si una funcin no pasa algn test sabemos con certeza (si el test
est correctamente diseado) que no funciona.

Tened en cuenta que no solamente es importante que la funcin calcule correctamente sus
resultados: el cdigo ha de ser inteligible, los nombres de las variables han de ser
adecuados, etc, etc.

Hacer que la funcin calcule correctamente lo tenis que considerar casi el punto de
partida de vuestra solucin, ms que el punto de llegada. Es decir: no debis entregar
el primer cdigo que habis conseguido hacer que funcione, sino un cdigo que funcione y
que est expresado de la mejor manera posible. Para poder hacer esto es indispensable
disponer de tests que comprueben que no rompemos nada al mejorar el cdigo de nuestra
solucin.

2
Primera prctica de Programacin 2 Curso 2016/2017

La clase principal
Se ha optado por hacer que la clase que contiene todo el cdigo sea extensin de
CommandLineProgram. De esta manera, cuando lo ejecutemos, el resultado nos aparecer
en la ventana Output del Netbeans. Adems, las lneas correspondientes a pruebas
correctas se escribirn en verde y las correpondientes a errores en rojo.

Si prefers usar un ConsoleProgram simplemente cambiadlo.

un
Estructura de la funcin r
La funcin run es la que ejecuta todas las funciones de prueba (una para cada apartado):

public void run() {

testZeroesAndToString();
//testAllBits();
//testCopy();
//testNarrow();
//testWiden();
//testCast();
//testAnd();
//testOr();
//testLeftShift();
//testUnsignedRightShift();
//testSignedRightShift();
}

La nica llamada que no est comentada es la que se corresponde con cdigo que os
proporcionamos nosotros. A medida que vayis completando vuestra solucin de la
prctica, iris descomentado las llamadas correspondientes para ejecutar las pruebas
correspondientes a cada funcin.

Cdigo correspondiente a cada apartado

En el proyecto se os proporciona la cabecera de cada una de las funciones que debis
implementar en cada apartado. P odis aadir las funciones auxiliares que queris, pero
no podis cambiar las cabeceras de las funciones que se os piden y que se describen
en este enunciado.

Todas las funciones tienen la misma implementacin, por ejemplo:

public boolean allBits(int[] num) {

throw new UnsupportedOperationException("apartado 1");
}

3
Primera prctica de Programacin 2 Curso 2016/2017

Lo que debis hacer es eliminar la nica lnea de cdigo y substituidla por vuestra
implementacin. Esta lnea lo nico que hace es dejar contento al compilador (el cdigo
Java es vlido) pero da un error de ejecucin cuando se la llama.

Estructura de una funcin de test

Cada funcin de test se corresponde con una funcin y prueba su funcionamiento para
algunos valores de los parmetros. Por ejemplo, la correspondiente a las funciones que
devuelven vectores de ceros de diferentes longitudes es:

public void testToString() {

checkEquals("00000000",
"toString(zeroByte())",
zeroByte());
checkEquals("00000000 00000000",
"toString(zeroShort())",
zeroShort());
checkEquals("00000000 00000000 00000000 00000000",
"toString(zeroInteger())",
zeroInteger());
checkEquals("00000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000",
"toString(zeroLong())",
zeroLong());
checkEquals("10 11001010",
"toString(new int[]{0, 1, 0, 1, 0, 0, 1, 1, 0, 1})",
new int[] {0, 1, 0, 1, 0, 0, 1, 1, 0, 1});
printBar();
}

Esta funcin realiza cuatro pruebas comprobando si las cadenas que obtenemos al llamar a
toString sobre integrales de diferentes longitudes (byte, short, int o long) se
corresponden con las cadenas dadas.

Por supuesto que podis aadir nuevas pruebas para aumentar la confianza en
vuestras soluciones.

Funcin de checking
La funcin de checking que hace esto es la siguiente:

public void checkEquals(String expected,

String expression,
int[] num) {
String actual = toString(num);
if (expected.equals(actual)) {
printlnOk(expression);

4
Primera prctica de Programacin 2 Curso 2016/2017

} else {
printlnError("\"" + expression + "\" should be \""
+ expected + "\" but is \"" + actual +
"\"");
}
}

Todas las funciones de checkXXXX tienen una estructura similar. En este caso, la funcin
recibe tres parmetros:
el resultado que se espera obtener
una cadena que representa lo que se est comprobando (que aparecer en el
mensaje que se mostrar al usuario)
el nmero que se pasar a toString
La funcin llama a toString y obtiene el resultado real (variable actual) y comprueba si
ste es igual o no al resultado esperado. En caso de que sea as, se muestra el mensaje de
OK. En caso de no ser iguales, se muestra el mensaje de error indicando la expresin, el
valor esperado y el valor obtenido.

Ejecucin de los tests

Si ejecutamos el programa, se muestra:

OK: toString(zeroByte())
OK: toString(zeroShort())
OK: toString(zeroInteger())
OK: toString(zeroLong())
OK: toString(new int[]{0, 1, 0, 1, 0, 0, 1, 1, 0, 1})

Si hubiera algn error, se mostrara:

OK: toString(zeroByte())
ERROR: "toString(zeroShort())" should be "00000000 00000000" but is
"0000 00000000"
OK: toString(zeroInteger())
OK: toString(zeroLong())
OK: toString(new int[]{0, 1, 0, 1, 0, 0, 1, 1, 0, 1})

Como vemos, parece ser que en vez de crear un integral de 16 bits lo hemos creado de 14.
Para que se lean mejor los nmero binarios, la funcin toString aade espacios cada 8
bits, contando desde el bit menos significativo (el de ms a la derecha).

Conforme vayis avanzando en la prctica, es conveniente que estudiis el cdigo de

prueba correspondiente a la funcin del apartado a resolver para entender el porqu de los
resultados que muestran las pruebas para comprender mejor la funcin que debis
implementar.

5
Primera prctica de Programacin 2 Curso 2016/2017

Funciones bsicas

Apartado 1: boolean allBits(int[] num)

La primera funcin que se os pide ha de comprobar que, dado un array de enteros, stos
solamente son o bien cero o bien uno.

Una vez implementada, ya podris utilizar las siguientes funciones:

public boolean hasSize(int[] num, int size) {

return num.length == size;
}

public boolean isByte(int[] num) {

return hasSize(num, BYTE_SIZE) && allBits(num);
}

public boolean isShort(int[] num) {

return hasSize(num, SHORT_SIZE) && allBits(num);
}

public boolean isInteger(int[] num) {

return hasSize(num, INTEGER_SIZE) && allBits(num);
}

public boolean isLong(int[] num) {

return hasSize(num, LONG_SIZE) && allBits(num);
}

Apartado 2: void copy(String from, int[] to)

Esta funcin copia los bits que hay en la cadena from en el array to, teniendo en cuenta lo
siguiente:
la funcin deja de copiar tanto si ha acabado la cadena como si ya no quedan ms
posiciones libres en el vector
solamente se copian los bits que son 0 o 1 en la cadena. Si hay algn carcter
diferente, ste se ignora.
las posiciones 0 del array y de la cadena son diferentes: en el array la posicin cero
se corresponde con el bit de menor peso; en la cadena, con el de mayor peso.
Para entender este ltimo punto, considerad la siguiente figura:

6
Primera prctica de Programacin 2 Curso 2016/2017

Una vez creada la funcin copy, podremos usarla para crear valores de los diferentes tipos
integrales existentes en Java:

public int[] newByte(String from) {

int[] num = zeroByte();
copy(from, num);
return num;
}

public int[] newShort(String from) {

int[] num = zeroShort();
copy(from, num);
return num;
}

public int[] newInteger(String from) {

int[] num = zeroInteger();
copy(from, num);
return num;
}

public int[] newLong(String from) {

int[] num = zeroLong();
copy(from, num);
return num;
}

Conversiones

Apartado 3: int[] narrow(int[] num, int toLength)

Una de las operaciones que podemos realizar entre tipos integrales son las conversiones.
En este apartado nos centraremos en las conversiones que se realizan hacia un tipo con el
mismo o menor nmero de bits, es decir, dentro de la funcin narrow tendremos garantizada
la precondicin:

0 <= toLength <= num.length

7
Primera prctica de Programacin 2 Curso 2016/2017

Lo que sucede en este caso es que se pierden los bits ms significativos del integral
original. En el caso de convertir al mismo nmero de bits se obtiene una copia (no se
devuelve el original).

Apartado 4: int[] widen(int[] num, int toLength)

Vamos a tratar el caso opuesto al del apartado anterior: cuando la conversin se realiza
hacia un tipo que tiene un mayor nmero de bits. Podra parecer que este caso es igual al
anterior y que solamente debemos de copiar los bits existentes en el resultado. Si lo
hacemos, nos olvidamos de un elemento importante: para que se mantenga el valor
numrico, hemos de rellenar los bits de mayor peso del resultado, con el bit de signo del
valor integral original.
Por ejemplo, dado el nmero 0101 si lo queremos expresar en 6 bits, su valor ser
000101. En ambos casos su valor numrico se corresponde con el nmero 5. Cul es la
representacin binaria del nmero -5? Usando complemento a 1, partimos de 5 (0101),
cambiamos ceros por unos y unos por ceros (1010) y sumamos 1 (1011). Qu pasara si
no rellenramos los bits ms significativos con el bit de signo que ahora es 1? Pues que al
transformarlo a seis bits obtendramos 001011 que se corresponde con el nmero 11, no
con -5. En cambio, si rellenamos con 1s, obtenemos 111011 que es -5 expresado con 6
bits.
Ahora la precondicin que podis suponer es:

0 <= from.length <= toLength

y, como en la funcin anterior, si se pide la misma longitud que la original, debemos

retornar una copia, no el array original.

Apartado 5: int[] cast(int[] from, int toLength)

Esta es muy fcil: dependiendo del tamao de from y del tamao deseado, haced narrow
o widen segn corresponda. En ningn caso, devolved el array original.
Una vez realizada esta funcin, ya podris convertir entre cualquier tipo integral con las
funciones:

public int[] toByte(int[] from) {

return cast(from, BYTE_SIZE);
}

public int[] toShort(int[] from) {

return cast(from, SHORT_SIZE);
}

public int[] toInteger(int[] from) {

return cast(from, INTEGER_SIZE);
}

8
Primera prctica de Programacin 2 Curso 2016/2017

public int[] toLong(int[] from) {

return cast(from, LONG_SIZE);
}

Operaciones booleanas

Apartado 6: int[] and(int[] arg1, int[] arg2)

La funcin que calcula el and de dos valores integrales bit a bit sera muy simple si no fuera
por la letra pequea:
si ambos parmetros pueden representarse en 32 bits (byte, short o integer), se
transforman ambos a integer y se realiza en and booleano posicin a posicin (el
resultado tiene 32 bits)
si al menos uno de ellos necesita 64 bits para representarse, se transforman ambos
a long y se realiza en and booleano posicin a posicin (el resultado tiene 64 bits)

Apartado 7: int[] or(int[] arg1, int[] arg2)

La funcin que calcula el or de dos valores integrales bit a bit tiene la misma letra pequea
que la detallada en el apartado anterior pero, obviamente, realiza el or booleano posicin a
posicin.

Operaciones de desplazamiento

Apartado 8: int[] leftShift(int[] num, int numPos)

Esta operacin desplaza los bits del nmero numPos (>= 0) posiciones hacia la izquierda
(hacia las posiciones ms significativas del nmero). Las posiciones de la derecha se
rellenan con ceros. Como siempre, la letra pequea es importante:
si el valor es representable como entero (32 bits), se transforma num a entero y se
desplazan tantas posiciones como los 5 bits menos significativos de numPos, es
decir, un nmero entre 0 y 31 (para obtenerlo podis usar el operador %). El
resultado obtenido es un nmero entero (32 bits).
si el valor no es representable como entero (es un long), se desplazan tantas
posiciones como los 6 bits menos significativos de numPos, es decir, un nmero
ong.
entre 0 y 63. El resultado obtenido es un l
como se ha indicado, en ambos casos, las posiciones de la derecha se rellenan con
ceros.

9
Primera prctica de Programacin 2 Curso 2016/2017

Apartado 9: int[] unsignedRightShift(int[] num, int

numPos)
Esta funcin es como la anterior, pero desplazando en el sentido contrario, es decir, hacia la
derecha (hacia los bits menos significativos). Las posiciones de la izquierda se rellenan
siempre con ceros (por ello se dice que es unsigned, ya que no se trata el bit de signo de
forma especial).

Apartado 10: int[] signedRightShift(int[] num, int numPos)

Finalmente, el ltimo desplazamiento, ser tambin hacia al derecha pero el valor con el
que se rellenan las posiciones de la izquierda se corresponde con el bit de signo que tena
el nmero original (una vez promocionado a int o long segn corresponda).

El informe de la prctica
El informe de la prctica constituye el 20% de la nota total. Tendr la siguiente estructura:
Portada con el nombre de la prctica, nombre del alumno, DNI, Grupo de prcticas,
fecha.
Para cada funcin que se os pide, una d escripcin de cmo la habis diseado
(en la siguiente seccin del enunciado tenis un ejemplo).
Una seccin final de conclusiones que responda a la pregunta: qu he aprendido
solucionando la prctica?
Una seccin de bibliografa: apuntes, libros, pginas web.

Como se ha indicado, adems del cdigo de vuestras funciones, para cada uno de los
apartados os pedimos una descripcin sobre cmo habis pensado la solucin. Puede
contener texto, diagramas (los podis realizar a mano y luego escanearlos), etc, etc.

NO ha de contener cdigo Java (ste ya aparece en el cdigo del proyecto). Si realmente

pensis en Java, decdnoslo, y os enviaremos un Blade Runner para comprobar si sois
humanos o replicantes.

oString, que se os proporciona:

Por ejemplo, considerad la funcin t

public String toString(int[] num) {

char[] chars = new char[num.length + num.length/8];
int iChars = 0;
for (int iNum = num.length-1; iNum >= 0; iNum--) {
chars[iChars] = (char) ('0' + num[iNum]);
iChars = iChars + 1;
if (iNum != 0 && iNum % 8 == 0) {

10
Primera prctica de Programacin 2 Curso 2016/2017

chars[iChars] = ' ';

iChars = iChars + 1;
}
}
return new String(chars, 0, iChars);
}

Dicha funcin escribe, en forma de cadena, los bits correspondientes a un integral

(representado por un array de enteros en el que la posicin 0 se corresponde con el bit de
menor peso). Adems, para mejorar la legibilidad, cada 8 espacios contando desde el bit
menos significativo, se dejar un espacio en blanco. Es decir, si el nmero es:

new int[] {0, 1, 0, 1, 0, 0, 1, 1, 0, 1})

el resultado de toString debera ser "

10 11001010".

Cmo se ha diseado la solucin?

Se ha de crear un String, pero para hacerlo, se necesitar crear primero un array
para guardar los caracteres del String.
Qu tamao tiene el array? Como es preciso guardar tantos bits como hay
en la num, sern necesario num.length posiciones. Pero como cada 8 bits
se aadir un espacio, a este tamao he de aadir num.length / 8.
A este array le denominamos c hars.
El orden de los bits en el array es diferente que en el String (la posicin 0 del array
contiene el bit menos significativo pero en el String esta posicin est ocupada por
el ms significativo, ya que es el que aparece ms a la izquierda).
Se ha de recorrer num y result en sentidos diferentes, por tanto se usarn
dos ndices: iNum para el array de enteros y i Chars para el de caracteres.
Se recorrer num de izquierda a derecha, es decir, desde el bit ms
significativo hasta el menos significativo (empezar desde num-length - 1
y se descender hasta haber tratado el 0 ).
Por tanto, iChars comenzar desde 0 (primera posicin del String).
A cada paso, si en el array num hay un 0, en chars se coloca 0 y, si hay un 1, un 1.
La expresin usada: (char) ('0' + num[iNum]), est explicada en los
apuntes del tema de Programacin Orientada a Objetos (pgina 13).
Dnde se aaden espacios? Imaginemos un num que tiene 20 posiciones. Su
representacin sera:

(posiciones 19 a 16) + + (posiciones 15 a 8) + + (posiciones 7 a 0)

Es decir, hay un espacio a la derecha de cada posicin (iNum) que es mltiplo de 8,

excepto del caso iNum=0 que no tiene un espacio a la derecha. Por tanto, la
condicin es: iNum != 0 && iNum % 8 == 0.

11
Primera prctica de Programacin 2 Curso 2016/2017

Criterios de evaluacin
Cada funcin evala sobre 1 punto, el 20% del cual se corresponde con el informe.
No solamente se tendr en cuenta que calcule bien su resultado, sino que el cdigo
sea entendible, los nombres de las variables razonables y que, en caso de ser
complicada, use funciones auxiliares, etc.

Formato de la entrega
Un fichero ZIP (no rar, 7z, tgz, etc.) que contenga:
Un PDF (no doc, docx, txt, odf, etc.) con el informe.
El directorio del proyecto Netbeans con vuestra solucin (haced un c lean del
proyecto para que ocupe el mnimo de espacio).
La entrega se realizar va sakai (en el apartado de a ctividades).

12