ACTIVIDAD PRÁCTICA Nº 3

ARQUITECTURA DE COMPUTADORAS 1

TEMA: Aritmética de la computadora digital.

PROFESOR: Ing. José María Ducloux.

ALUMNOS:

 Alf. Arguello Irupé.

 Alf. Sztuka Daniel.
INDICE

1. DESARROLLO ------------------------------------------------------------------- Pág. 3.

1.1. Código a analizar -------------------------------------------------------------
Pág. 3.
1.2. Explicación de cada prueba --------------------------------------------------
Pág. 8.

2
1. DESARROLLO

1.1. Código a analizar;

// *************************

// Declaración de variables

// *************************

byte byte_var; // variable entera sin signo de 8 bits.

char char_var; // variable entera con signo de 8 bits.

unsigned int uint_var; // variable entera sin signo de 32 bits.

signed int int_var; // variable entera con signo de 32 bits.

float float_var; // variable de coma flotante de 32 bits (con signo).

// se define una unión para poder visualizar los bits de un dato de coma flotante.

union float_integer {

signed int entero;

float flotante;

};

union float_integer float_dato; // dato de coma flotante (puede ser accedido como
entero o como flotante)

// *************************

// Sección de setup()

// *************************

void setup() {

Serial.begin(9600);

delay(1000);

3
// *************************

// Sección de loop()

// *************************

void loop() {

Serial.println("****************");

Serial.println("Prueba #01");

byte_var = 28;

Serial.println(byte_var, BIN);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #02");

char_var = 28;

Serial.println(char_var, BIN);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #03");

char_var = -28;

Serial.print(char_var, BIN);

Serial.println(" -> para este número solo considerar los 8 bits de la derecha.");

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #04");

char_var = -128;

char_var = (-1) * char_var;

4
Serial.println(char_var, DEC);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #05");

Serial.println("Nota: tener en cuenta que el método print() no visualiza ceros a la

izquierda.");

char_var = 28;

int_var = (signed int)char_var;

Serial.print(char_var, BIN);

Serial.println(" -> es una variable de 8 bits.");

Serial.print(int_var, BIN);

Serial.println(" -> es una variable de 32 bits.");

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #06");

Serial.println("Nota: tener en cuenta que el método print() no visualiza ceros a la

izquierda.");

char_var = -28;

int_var = (signed int)char_var;

Serial.print(char_var, BIN);

Serial.println(" -> para este número solo considerar los 8 bits de la derecha.");

Serial.print(int_var, BIN);

Serial.println(" -> para este número considerar todos los bits (32 bits).");

Serial.println("****************");

Serial.println("");

Serial.println("****************");

5
Serial.println("Prueba #07");

float_var = 0.03125; // este número se puede representar como una fracción:

3125/100000 = 0.03125

Serial.println(float_var, 5);

int_var = 1000 * float_var;

Serial.println(int_var, DEC);

float_var = (float)int_var / 1000;

Serial.println(float_var, DEC);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #08");

float_var = 0.03125; // este número se puede representar como una fracción:

3125/100000 = 0.03125

Serial.println(float_var, 5);

int_var = 100000 * float_var;

Serial.println(int_var, DEC);

float_var = (float)int_var / 100000;

Serial.println(float_var, DEC);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #09");

float_dato.flotante = -1.6328125;

Serial.println(float_dato.flotante, 7);

Serial.println(float_dato.entero, BIN);

Serial.println("****************");

Serial.println("");

6
Serial.println("****************");

Serial.println("Prueba #10");

float_dato.flotante = -1.6328121345;

char char_array[] = "-1.6328121345";

Serial.print(char_array);

Serial.println(" -> es el valor verdadero.");

Serial.println(float_dato.flotante, 10);

Serial.println(float_dato.entero, BIN);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #11");

float_dato.flotante = -1.0000000000000012;

char char_array2[] = "-1.0000000000000012";

Serial.print(char_array2);

Serial.println(" -> es el valor verdadero.");

Serial.println(float_dato.flotante, 16);

Serial.println(float_dato.entero, BIN);

Serial.println("****************");

Serial.println("");

Serial.println("****************");

Serial.println("Prueba #12");

float_dato.flotante = -1.6328125;

float_dato.flotante /= 0;

Serial.println(float_dato.flotante, 7);

char_var = -28;

char_var /= 0;

7
 Serial.println(char_var, DEC);

Serial.println("****************");

Serial.println("");

while (1);

1.2. Explicación de cada prueba :

 Prueba #01

11100

// Aquí está el numero 28 (variable “byte_var”, que representa un entero sin signo de 8
bits) transformado en binario

 Prueba #02

11100

// Aquí el 28 está declarado en la variable “char_var” (entero con signo de 8 bits) y

transformado a binario

 Prueba #03 11111111111111111111111111100100 -> para este número solo

considerar los 8 bits de la derecha

// En este caso el número es el -28, también declarado como entero con signo. Como se
puede apreciar, está en binario y se utiliza el sistema de representación complemento a
2.

 Prueba #04

-128

//El número es el -128, también declarado como entero con signo; se lo multiplica por -1
para obtener su opuesto, pero en lugar de visualizarse 128 se obtiene el mismo número.
Esto se debe a que el valor máximo positivo de una variable char es 127.

 Prueba #05

Nota: tener en cuenta que el método print() no visualiza ceros a la izquierda.

11100 -> es una variable de 8 bits.

11100 -> es una variable de 32 bits.

8
//En este caso primero muestra el número 28 en binario como variable de 8 bits, y abajo
muestra su conversión a una variable de 32 bits (no se visualizan los ceros adelante, el
valor correcto sería 00000000000000000000000000011100)

 Prueba #06

Nota: tener en cuenta que el método print() no visualiza ceros a la izquierda.

11111111111111111111111111100100 -> para este número solo considerar los 8 bits

de la derecha.

11111111111111111111111111100100 -> para este número considerar todos los bits

(32 bits).

//El numero representado en binario es el -28; al igual que el anterior, primero se

muestra su valor como variable de 8 bits y luego su conversión a 32 bits. Hay que tener
en cuenta que la correcta visualización de la variable de 8 bits es 11100100

 Prueba #07

0.03125

31

0.0310000000

//En este caso al valor de tipo flotante 0.03125 se lo multiplica por 1000 y se lo
transforma a un entero de 32 bits quedando como resultado 31 (sin coma ya que esta
pasado a un entero, perdiéndose parte del valor original); de aquí se lo divide por 1000 y
se lo pasa a flotante nuevamente. Como se puede visualizar, el nuevo número es
diferente al original, debiéndose esto al cambio de tipo de valor usado.

 Prueba #08

0.03125

3125

0.0312500000

//Esta prueba es similar al anterior, pero en lugar de 1000 se lo multiplica por 100000,
lo que hace que al convertirse nuevamente no se pierdan los datos iniciales.

 Prueba #09

-1.6328125

10111111110100010000000000000000

9
//En este caso se declara un valor flotante negativo, y como la función permite que el
dato pueda ser accedido como entero o como flotante, además del valor negativo
también se imprime el valor en binario del mismo y el resto de los bits se completa con
0.

 Prueba #10

-1.6328121345 -> es el valor verdadero.

-1.6328121424

10111111110100001111111111111101

//En este caso el valor varía debido a que en la segunda línea esta expresado como coma
flotante, por lo que el valor se redondea; luego se visualiza el valor que esta redondeado
en binario.

 Prueba #11

-1.0000000000000012 -> es el valor verdadero.

-1.0000000000000000

10111111100000000000000000000000

//En este caso ocurre similar a la prueba 10, el número se redondea haciendo que el
valor mostrado sea diferente. En cuanto a su representación en binario, se completa con
0 hacia su derecha para visualizar 32 bits.

 Prueba #12

inf

**B0100000063f694 Š

//El caso número 12 el valor se divide por 0, mostrándose en pantalla “inf” de infinito
en el caso de un valor flotante; en el otro caso sin embargo figura un error debido a que
el valor debe ser representado como una variable entera con signo de 8 bits, cosa que no
es posible para el infinito.

10