Informe Practica 0

Sergio Liberati
Laboratorio de procesamiento digital de se
nales
Profesor: Carlos Mejias
8 de diciembre de 2015

Resumen
En esta practica se explicaran y demostraran las metodologas necesarias para realizar operaciones como descomposicion de n
umeros enteros para distintos procesos, uso
de operadores comparativos y modelacion de Series o Sucesiones mediante procesos
Computables.

1.

Introducci
on

Al realizar una demostracion de la versatilidad que presentan los procedimientos

basicos realizables por el lenguaje C, quedara expuesta la potencia y fiabilidad de este. Yendo desde descomposicion de n
umeros hasta sucesiones, pasando incluso por los
amigables n
umeros primos que todos conocemos desde muy peque
nos, valiendonos de
los operadores mas basicos disponibles en C, se realizaran distintos experimentos que
demostraran la utilidad y con fiabilidad que nos dispone el lenguaje C

2.

Metodologa Empleada

A continuacion se presentaran los Algoritmos ( y explicacion matematica) empleados para la realizacion de tres experimentos: N
umeros Primos, Numeros Romanos y
Secuencia de Fibonacci.
2.1.
2.1.1.

Algoritmo de N
umeros Primos
Muestra de c
odigos

#include<s t d i o . h>
void main ( void )
{
int num [ 1 0 0 ] ;
int i , j ;
for ( i =1; i <=100; i ++)// s e c a r g a e l v e c t o r num [ 1 0 0 ] con l o s
// numeros d e l 1 a l 100
{
num [ i 1]= i ;
}
for ( i =1; i <=99; i ++){
i f (num [ i ] ! = 0 ) {
for ( j=i +1; j <=99; j ++)
{
i f ( ( num [ j ] % num [ i ])==0){
num [ j ] = 0 ;
}
}
}
}
p r i n t f ( \n Primos d e l 1 a l 100\n ) ;
for ( i =1; i <=100; i ++){
i f (num [ i 1]!=0){
p r i n t f ( %d ,num [ i 1 ] ) ;
}
}
}
2.1.2.

C
alculos Matem
aticos

esto es una prueba calculo

El calculo de n
umeros primos es una de las principales utilidades del lenguaje C
(desde el punto de vista de una programacion sencilla) ya que facilmente podremos
conseguir los primeros 5000 n
umeros primos (por ejemplo).
A pesar que este procedimiento puede lograrse de distintas maneras (distintos Algoritmos), utilizaremos un metodo que implica un vector con los n
umeros del 1 al 100
y una comparacion elemento a elemento.
Consiste en tener un vector v[100] donde v[0] = 1, v[1] = 2, v[2] = 3...v[99] =
100...v[n] = n + 1 (sabiendo que en C, la primera entrada de un vector v[] es v[0]).
El cual mediante un ciclo f or se ira comparando elemento a elemento, donde todo
aquel numero divisible (con residuo 0) por uno menor a el sera descartado por ser un
n
umero no primo.
De esta manera pueden conseguirse los n
umeros primo que hay entre el 1 y el 100, sin
embargo este procedimiento se puede emplear para n
umeros superiores a 100 (incluso
superiores a 5000 como ejemplificamos al comienzo).

2.2.
2.2.1.

Algoritmo de Conversi
on N
umeros en Base Decimal a Nomenclatura
Romana
Muestra de c
odigos

#include<s t d i o . h>
void romano ( int n ) ; // s o l o puede c a l c u l a r l o s numeros
// romanos d e l 1 a l 3999
int main ( void ){
int num ;
s c a n f ( %d ,&num ) ;
p r i n t f ( e l v a l o r de %d en romano e s ,num ) ;
i f (num==1000)
p r i n t f ( M ) ;
else
romano (num ) ;
return 0 ;
}
void romano ( int n )
{
int a , b , c , d ;
d=n / 1 0 0 0 ;
c=(n %1000)/100;
b=(n %100)/10;
a=(n %100) %10;
switch ( d ){
case 3 :
p r i n t f ( MMM ) ;
break ;
case 2 :
p r i n t f ( MM ) ;
break ;
case 1 :
p r i n t f ( M ) ;
break ;
}
switch ( c ){
case 9 :
p r i n t f ( CM ) ;
break ;

case 8 :
p r i n t f ( DCCC ) ;
break ;
case 7 :
p r i n t f ( DCC ) ;
break ;
case 6 :
p r i n t f ( DC ) ;
break ;
case 5 :
p r i n t f ( D ) ;
break ;
case 4 :
p r i n t f ( CD ) ;
break ;
case 3 :
p r i n t f ( CCC ) ;
break ;
case 2 :
p r i n t f ( CC ) ;
break ;
case 1 :
p r i n t f ( C ) ;
break ;
}
switch ( b ){
case 9 :
p r i n t f ( XC ) ;
break ;
case 8 :
p r i n t f ( LXXX ) ;
break ;
case 7 :
p r i n t f ( LXX ) ;
break ;
case 6 :
p r i n t f ( LX ) ;
break ;
case 5 :
p r i n t f ( L ) ;
break ;
case 4 :
4

p r i n t f ( XL ) ;
break ;
case 3 :
p r i n t f ( XXX ) ;
break ;
case 2 :
p r i n t f ( XX ) ;
break ;
case 1 :
p r i n t f ( X ) ;
break ;
}
switch ( a ){
case 9 :
p r i n t f ( IX ) ;
break ;
case 8 :
p r i n t f ( VIII ) ;
break ;
case 7 :
p r i n t f ( VII ) ;
break ;
case 6 :
p r i n t f ( VI ) ;
break ;
case 5 :
p r i n t f ( V ) ;
break ;
case 4 :
p r i n t f ( IV ) ;
break ;
case 3 :
p r i n t f ( IIV ) ;
break ;
case 2 :
p r i n t f ( IV ) ;
break ;
case 1 :
printf (I );
break ;
}

}
2.2.2.

C
alculos Matem
aticos

La principal caracterstica de este algoritmo es que tiene un alcance limitado (a nivel

de computo) debido a que historicamente y de acuerdo con la documentacion oficial
de la epoca, los n
umeros romanos mayores a 3999, se representan con letras ajenas al
alfabeto latino (mejor dicho letras pertenecientes a este alfabeto pero con agregados
visuales). Por ende esto dificulta la representacion de estos n
umeros en un lenguaje con
base de caracteres reducida como lo es C. Puesto que los caracteres del tipo IV , V , X,
L, entre otros, no son representables con el repertorio de caracteres del lenguaje C.
Sin embargo se logran el objetivo propuesto que es representar de manera correcta
n
umeros en base decimal del 1 al 1000 (y mayores que este) con la nomenclatura Romana, logrando procesar y convertir efectivamente cualquier n
umero entero x tal que
1 x 3999.
El proceso utilizado para realizar la conversion de n
umeros en base decimal a la nomenclatura Romana consiste en el aprovechamiento de dos herramientas fundamentales
de la programacion: la division entera y el operador mod %.
La teora de operaciones aritmeticas basicas en la programacion en C nos indica
que el resultado de una division va de la mano con el tipo de variables que se esten
operando. Por lo tanto es de esperarse (y es as) que al dividir dos variables del tipo
integer (int), el resultado sea de tipo integer. Esta particularidad de las variables de
tipo int puede ser aprovechada para descomponer un numero, ya que al operar, por
ejemplo, 735/100, de la siguiente manera;
...
int a =735 ,b=100;
p r i n t f ( 735/100= %d , a/b ) ;
...
Comprobaremos que efectivamente el resultado sera un numero entero (int), y ademas
obtendremos que el n
umero 735 (el cual se encuentra en base decimal) al ser descompuesto en base decimal, presenta un valor de 7 que acompa
na como m
ultiplo al tercer
numero en la base decimal (100).
Bien, ahora queremos obtener el resto del numero, pero se observa que la operacion
de division entera destruye el numero original (si no se almacena), por lo tanto el primer
paso para corregir esta situacion es almacenar el valor del numero a descomponer en
una variable. Una vez resuelto esto, podemos conseguir el resto del numero utilizando
el operador mod( %).
El operador mod o (resto), consiste en calcular el cociente de una division (por
ejemplo, 5/4, cociente 1). podemos aprovechar esto para mostrar el resto del numero
que no se logra obtener utilizando la division entera. Es decir, siguiendo nuestro ejemplo,
para obtener el 35 de 735 podemos realizar 735 %100 y obtendremos 35.
Una vez comprendido esto, podemos valernos de estas operaciones para descomponer
cualquier numero, almacenar esta descomposicion es distintas variables, y utilizarlas
6

para realizar distintas operaciones. En nuestro caso, haremos pasar estas variables por
operadores switch para imprimir el valor correspondiente en nomenclatura Romana de
todas y cada una de las componentes del numero (original en base decimal).
Para ejemplificar esto podemos computar:
...
int n=1347
int a , b , c , d ;
a=n / 1 0 0 0 ;
b=(n %1000)/100;
c=(n %100)/10;
d=(n %100) %10;
...
Y obtendremos que las variables a, b, cyd corresponderan al n
umero 1347 descompuesto
(a = 1, b = 3, c = 4yd = 7), por lo tanto podremos valernos de estos valores para procesarlos posteriormente con un operador switch correctamente estructurado y
obtendremos el n
umero 1347 en Nomenclatura Romana MCCCXLVII.
2.3.
2.3.1.

Algoritmo para representar la Serie de Fibonacci

Muestra de c
odigos

i n c l u d e <s t d i o . h>
int main ( void ){
int f i b o l d =0, f i b n e w =1, t r a n s ;
p r i n t f ( 25 t e r m i n o s de F i b o n a c c i : %d %d , f i b o l d , f i b n e w ) ;
for ( int i =3; i <=25; i ++)
{
t r a n s =f i b n e w ;
f i b n e w=f i b o l d+f i b n e w ;
f i b o l d=t r a n s ;
p r i n t f ( %d , f i b n e w ) ;
}
}
2.3.2.

C
alculos Matem
aticos

La secuencia de Fibonacci, Famosa por su relacion con Arcos Naturales desarrollados

en algunos animales (incluso el ser humano), proviene de una simple operacion recursiva
la cual toma dos n
umeros relativamente consecutivos (consecutivos en la secuencia de
Fibonacci) y los suma para obtener un tercero que sera sumado con el segundo n
umero
que lo origino. Es decir, para el enesimo termino de la secuencia de Fibonacci, tendremos
que Fn+2 = Fn + Fn+1 para todo n 0 , donde F1 = 0, F2 = 1.
Ya que procederemos a sumar dos n
umeros consecutivamente, y el resultado de cada
suma sera utilizado en la siguiente suma, tendremos que utilizar 3 variables, dos que
7

se sumen y una tercera de transicion para intercambiar los valores y poder realizar la
suma recursiva perpetuamente.

3.

Analisis e interpretacion de resultados

En el caso de los n
umeros primos, se obtuvieron efectivamente los n
umeros primos
contenidos desde el 1 hasta el numero 100, es decir, los primos desde el 1 hasta el 97.
Sin embargo este algoritmo podra emplearse de manera mas eficaz y corta, ahorrando
de esta manera el uso de memoria.
Para los n
umeros Romanos, tal como se expuso en la seccion de este experimento,
solo se pueden obtener correctamente los n
umeros romanos del 1 al 3999. Cabe destacar
que la conversion es completamente correcta en este rango (1-3999).
La Secuencia de Fibonacci fue modelada y simulada completamente seg
un la finalidad de la practica (obtener los primeros 25 terminos). aunque el algoritmo dise
nado
y empleado puede obtener el enesimo termino de la secuencia (con limitaciones de
memoria dependiendo del tipo de variable usado).

4.

Conclusiones

Se demostro que efectivamente el lenguaje C tiene una potencialidad y una fiabilidad (que va de la mano con la correcta programacion) que lo hacen sin duda, una
herramienta fundamental para modelaciones matematicas, y operaciones aritmeticas

()simples o muy complejas) fundamentales en el Area

de Ingeniera.
*

5.

Recomendaciones

El algoritmo de los N
umeros primos se puede realizar de manera mas eficiente empleando el siguiente codigo para conseguir todos los n
umeros primos desde el 1 hasta
el enesimo numero n(introducido por el usuario).
#include<s t d i o . h>
int primo ( int n ) ;
int main ( void ){
int n ;
s c a n f ( %d ,&n ) ;
p r i n t f ( 1 2 ) ;
for ( int i =3; i<=n ; i ++)
primo ( i ) ;
}
int primo ( int n ){
int s =0;
8

for ( int i =2; i<=n ; i ++)

i f ( n %i ==0)
s +=1;
i f ( s==0)
p r i n t f ( %d , n ) ;
}

6.

Referencias
https://es.wikipedia.org/w/index.php?title=Alfabeto&oldid=87003116,