Universidad de El Salvador

Facultad de Ingeniera y Arquitectura

Escuela de Ingeniera Elctrica




Laboratorio N 9: ANSI C: Estructuras y Funciones

Asignatura:
Introduccin a la Informtica

Profesor:
Ing. Walter Leopoldo Zelaya

Instructor:
Cesar Augusto Meja

Alumno Carn G.T G.L
Aguilar Quintanilla, Cristian Antonio AQ13003 02 04
Hidalgo Fuentes, Cesar Rolando HF13003 02 04
Jimnez Alas, Daniel Vladimir JA13001 02 04




Ciudad Universitaria, 18 de Junio de 2014









INTRODUCCIN.

Esta asignacin tiene como propsito apoyarse en lo que son las estructuras y los arreglos para poder
solucionar de una forma ms practica los problemas comunes en el rea laboral que lleva relacin a la
programacin, ya sea que casos aplicados a la realidad como cualquier problema de programacin que
se ver prximamente en el prximo curso de programacin, llevndonos esto como ultima herramienta
fundamental para la solucin de problemas.


Se estudiara lo que son estructuras y funciones para iniciar este trabajo primero se definirn lo que son
las estructuras, ya que con ellas se logra integrar muchas caractersticas en un solo tipo nuevo de datos.
Al terminar de comprender y utilizar las estructuras comenzaremos con el aprendizaje de las funciones
para lograr un cdigo modular y reutilizable.

Conoceremos un poco ms acerca de estos dos temas para poder realizar un cdigo que sea fcil de
corregir y de depurar.

La asignacin se resolver aplicando los conocimientos que hayamos obtenido durante nuestra
investigacin y horas clases.
































OBJETIVOS.


Objetivo general:

Desarrollar cdigos sencillos y reutilizables con estructuras y funciones.

Objetivos especficos:

1. Implementar punteros a las estructuras y funciones.
2. Conocer cmo es que trabajan las funciones.
3. Utilizar estructuras y funciones para la creacin de arreglos unidimensionales y
pluridimensionales.


































ESTRUCTURAS.


Qu es una estructura?

Una estructura es un tipo de dato definido por el usuario, al utilizar una estructura Usted tiene la
habilidad para definir un nuevo tipo de dato considerablemente ms complejo que los tipos que hemos
utilizado hasta ahora. Una estructura es una combinacin de varios tipos de datos previamente
definidos, incluyendo otras estructuras que hayamos definido previamente. Una definicin simple es,
"una estructura es un grupo de datos relacionados en una forma conveniente al programador y/o al
usuario del programa"


Para definir una estructura usamos el siguiente formato:

1. struct nombre_de_la_estructura {
2. campos de estructura;
3. };
Ahora que ya conocemos como definir empezamos con la creacin.
Ejemplo:

1. struct estructura_amigo {
2. char nombre[30];
3. char apellido[40];
4. char telefono[10];
5. char edad;
6. };

Ahora ya tenemos definida la estructura, pero aun no podemos usarla. Necesitamos declarar
una variable con esa estructura.
1. struct estructura_amigo amigo;

De todo esto depende que nuestro cdigo se realice de la mejor manera y sea sencillo y fcil de
corregir.

Inicializar una estructura.

A las estructuras se les pueden dar valores iniciales de manera anloga a como hacamos con los
arreglos.
Primero tenemos que definir la estructura y luego cuando declaramos una variable como estructura le
damos el valor inicial que queramos.

1. struct estructura_amigo amigo = {
2. "Juanjo",
3. "Lpez",
4. "22920483",
5. 30
6.};
Arreglos de estructuras.

Cmo se hace esto? Siguiendo nuestro ejemplo vamos a crear un arreglo de ELEMENTOS elementos:

1. struct estructura_amigo amigo[ELEMENTOS];
Ahora necesitamos saber cmo acceder a cada elemento del arreglo. La variable definida es amigo, por
lo tanto para acceder al primer elemento usaremos amigo[0] y a su miembro nombre: amigo[0].nombre.
Vemoslo en un ejemplo en el que se supone que tenemos que meter los datos de tres amigos:


1. #include <stdio.h>
2. #define ELEMENTOS 3
3. struct estructura_amigo {
4. char nombre[30];
5. char apellido[40];
6. char telefono[10];
7. int edad;
8. };
9. struct estructura_amigo amigo[ELEMENTOS];
10. int main( void )
11. {
12. int num_amigo;
13. for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
14. {
15. printf( "\nDatos del amigo nmero %i:\n", num_amigo+1 );
16. printf( "Nombre: " ); fflush( stdout );
17. gets(amigo[num_amigo].nombre);
18. printf( "Apellido: " ); fflush( stdout );

inicializar un arreglo de estructuras de la forma siguiente:

1. struct estructura_amigo amigo[ ] =
2. {
3. "Juanjo", "Lpez", "22044342", 30,
4. "Marcos", "Gamindez", "24054823", 42,
5. "Ana", "Martinez", "22335694", 20
6. };

Punteros a estructuras .

Tambin se puede apuntar a una estructura, primero de todo hay que definir la estructura de igual forma
que hacamos antes. La diferencia est en que al declara la variable de tipo estructura debemos ponerle
el operador '*' para indicarle que es un puntero.

Dado que es un puntero tenemos que indicarle dnde debe apuntar, en este
caso vamos a hacer que apunte a la variable amigo:
1. p_amigo = &amigo;
p_amigo es un puntero que apunta a la estructura amigo. Sin embargo p_amigo>edad es una
variable de tipo int. Por eso al usar el scanf tenemos que poner el &.
typedef.

Con typedef podemos crear nombres para los tipos de datos ya existentes, ya sea por capricho o para
mejorar la legibilidad o la portabilidad del programa.

Definicion de datos con typedef.

typedef tipo_de_variable nombre_nuevo;

Punteros .

Tambin podemos definir tipos de punteros:
1. int *p, *q;
Podemos convertirlo en:
1. typedef int *ENTERO;
2. ENTERO p, q;
Aqu p, q son punteros aunque no lleven el operador '*', puesto que ya lo lleva ENTERO
incorporado.


Arreglos
Tambin podemos declarar tipos arreglo. Esto puede resultar ms cmodo para la gente que viene de
BASIC o
PASCAL, que estaban acostumbrados al tipo string en vez de char:
1. typedef char STRING[255];
2. STRING nombre;
donde nombre es realmente char nombre[255];
3. Estructuras
Tambin podemos definir tipos de estructuras. Antes, sin typedef:
Sin typedef:
1. struct _complejo {
2. double real;
3. double imaginario;
4. }
5. struct _complejo numero;
Con typedef:
1. typedef struct {
2. double real;
3. double imaginario;
4. } COMPLEJO;
5. COMPLEJO numero;







FUNCIONES


Una funcin es un conjunto de declaraciones, definiciones, expresiones y sentencias que realizan una
tarea especfica.
La utilizacin de funciones nos permite dividir un programa extenso en pequeos segmentos que
realizan tareas concretas. Probablemente, dentro de un mismo programa se realicen las mismas tareas
varias veces, lo que se facilita mediante la utilizacin de funciones. Sin embargo, es probable que
ciertas funciones no sean reutilizables, pero al usarlas se mejora la legibilidad del programa.
Con el propsito de permitir un manejo eficiente de los datos, las funciones en C no se pueden anidar.
En otras palabras, una funcin no se puede declarar dentro de otra funcin, por lo que todas las
funciones son globales o externas, lo que hace que puedan llamarse desde cualquier parte de un
programa.
Cuando se accede a una funcin desde un determinado punto del programa, se le puede pasar
informacin mediante unos identificadores especiales conocidos como argumentos (tambin
denominados parmetros). Una vez que la funcin procesa esta informacin, devuelve un valor
mediante la instruccin return.

La estructura general de una funcin en C es la siguiente:
tipo_de_retorno nombre_de_la_funcin (lista_de_parmetros)
{
cuerpo_de_la_funcin
return expresin
}

Donde:
tipo_de_retorno: es el tipo del valor devuelto por la funcin, o, en caso de que la funcin no devuelva
valor alguno, la palabra reservada void .
nombre_de_la_funcin: es el nombre o identificador asignado a la funcin.
lista_de_parmetros: es la lista de declaracin de los parmetros que son pasados a la funcin. stos
se separan por comas. Debemos tener en cuenta que pueden existir funciones que no utilicen
parmetros.
cuerpo_de_la_funcin: est compuesto por un conjunto de sentencias que llevan a cabo la tarea
especfica para la cual ha sido creada la funcin.
return expresin: mediante la palabra reservada return , se devuelve el valor de la funcin, en este
caso representado por expresin.

Declaracin de funciones
Antes de empezar a utilizar una funcin debemos declararla. La declaracin de una fun-
cin se conoce tambin como prototipo de la funcin. En el prototipo de una funcin
se tienen que especificar los parmetros de la funcin, as como el tipo de dato que
devuelve.
Los prototipos de las funciones que se utilizan en un programa se incluyen generalmente
en la cabecera del programa y presentan la siguiente sintaxis:
tipo_de_retorno nombre_de_la_funcin(lista_de_parmetros);

Los prototipos de las funciones son utilizados por el compilador para verificar que se
accede a la funcin de la manera adecuada con respecto al nmero y tipo de parmetros,
y al tipo de valor de retorno de la misma.

Definicin de funciones.

Tras declarar una funcin, el siguiente paso es implementarla. Generalmente, este paso se conoce como
definicin. Es precisamente en la definicin de una funcin donde se especifican las instrucciones que
forman parte de la misma y que se utilizan para llevar a cabo la tarea especfica de la funcin. La
definicin de una funcin consta de dos partes, el encabezado y el cuerpo de la funcin.

La sintaxis de la definicin de una funcin es la siguiente:

tipo_de_retorno nombre_de_la_funcin(lista_de_parmetros)
{
sentencias;
}

El tipo_de_retorno representa el tipo de dato del valor que devuelve la funcin. Este tipo debe ser uno
de los tipos simples de C, un puntero a un tipo de C o bien un tipo struct . De forma predeterminada, se
considera que toda funcin devuelve un tipo entero (int) . En otras palabras, si en la declaracin o en la
definicin de una funcin no se especifica el tipo_de_retorno , el compilador asume que devuelve un
valor de tipo int .

El nombre_de_la_funcin representa el nombre que se le asigna a la funcin.


Devolucin de valores .

Una funcin en C slo puede devolver un valor. Para devolver dicho valor, se utiliza la
palabra reservada return cuya sintaxis es la siguiente:
return <expresin>;
Donde <expresi n> puede ser cualquier tipo de dato salvo un array o una funcin. Ada-
ms, el valor de la expresin debe coincidir con el tipo de dato declarado en el proto-
tipo de la funcin. Por otro lado, existe la posibilidad de devolver mltiples valores
mediante la utilizacin de punteros o estructuras.

Funciones void
Las funciones void dan una forma de emular, lo que en otros lenguajes se conocen como
procedimientos (por ejemplo, en PASCAL). Se usan cuando no requiere regresar un valor. Se muestra
un ejemplo que imprime los cuadrados de ciertos nmeros.
1. void cuadrados(){
2. int contador;
3. for( contador=1; contador<10; contador++)
4. printf("%d\n",contador*contador);
5. }
6. void main( void )
7. {
8. cuadrados();
9. }
En la funcin cuadrados no esta definido ningn parmetro, y por otra parte tampoco se emplea la
sentencia
return para regresar de la funcin.

El tipo de dato devuelto por estas funciones puede ser void , considerado como un tipo especial
de dato. En estos casos, la sentencia return se puede escribir como return o se puede omitir
directamente. Por ejemplo:
void imprime_cabecera();
{
printf("esta funcin slo imprime esta lnea");
return;
}
equivale a:
void imprime_cabecera();
{
printf("esta funcin slo imprime esta lnea");
}


Acceso a una funcin .

Para que una funcin realice la tarea para la cual fue creada, debemos acceder o llamar a la misma.
Cuando se llama a una funcin dentro de una expresin, el control del programa se pasa a sta y slo
regresa a la siguiente expresin de la que ha realizado la llamada cuando encuentra una instruccin
return o, en su defecto, la llave de cierre al final de la funcin.
Generalmente, se suele llamar a las funciones desde la funcin main , lo que no implica que dentro de
una funcin se pueda acceder a otra funcin. Cuando queremos acceder a una funcin, debemos
hacerlo mediante su nombre seguido de la lista de argumentos que utiliza dicha funcin encerrados
entre parntesis.

mbito y clases de almacenamiento .
Como hemos visto en unidades anteriores, en C, las variables se pueden clasificar de acuerdo a su tipo
de dato. Por ejemplo, una variable puede ser de tipo entero (int) o de tipo carcter (char) . Sin embargo,
las variables tambin pueden clasificarse de acuerdo a su mbito, es decir, la parte del programa en la
que la variable es reconocida. De acuerdo con su mbito, las variables pueden ser locales o globales

Variables locales
Cuando declaramos variables dentro de la funcin principal del programa, es decir, dentro de la funcin
main , estn nicamente asociadas a esta funcin, en otras palabras, son variables locales de la funcin
main y no se puede acceder a ellas a travs de ninguna otra funcin.
Al igual que sucede con las variables declaradas dentro de la funcin main , cualquier variable que
declaremos dentro de una funcin, es local a esa funcin, es decir, su mbito esta confinado a dicha
funcin.


Variables globales.

A diferencia de las variables locales cuyo mbito estaba confinado a la funcin donde estaban
declaradas, el mbito de las variables globales se extiende desde el punto en el que se definen hasta el
final del programa. En otras palabras, si definimos una variable al principio del programa, cualquier
funcin que forme parte de ste podr utilizarla simplemente haciendo uso de su nombre.
La utilizacin de variables globales proporciona un mecanismo de intercambio de informacin entre
funciones sin necesidad de utilizar argumentos. Por otra parte, las variables globales mantienen el valor
que se les ha asignado dentro de su mbito, incluso despus de finalizar las funciones que modifican
dicho valor.

Variables estticas.

Otro tipo de almacenamiento son las variables estticas identificadas por la palabra reservada static .
Las variables estticas pueden ser tanto locales como globales. Una variable esttica local, al igual que
una variable automtica, est nicamente asociada a la funcin en la que se declara con la salvedad de
que su existencia es permanente.

Variables de registro
Cuando declaramos una variable como variable de registro, le estamos diciendo al compilador que
queremos que la variable se almacene en un lugar de rpido acceso, generalmente en los registros de la
unidad central de procesamiento del ordenador. Para declarar una variable como variable de registro,
debemos colocar la palabra reservada register antes de la declaracin de la variable. Veamos algunos
ejemplos:
register int contador:
register char a;
Slo se pueden declarar variables como register si son variables automticas (locales) o argumentos
formales de una funcin.

Funciones y arreglos.

Cuando se usan un arreglo como un argumento a la funcin, se pasa slo la direccin del arreglo y no
la copia
del arreglo entero. Para fines prcticos podemos considerar el nombre del arreglo sin ningn ndice
como la
direccin del arreglo. Considerar el siguiente ejemplo en donde se pasa un arreglo a la funcin imp_rev,
observar que no es necesario especificar la dimensin del arreglo cuando es un parmetro de la funcin.
1. void imp_rev(char s[])
2. {
3. int t;
4. for( t=strlen(s)1; t>=0; t)
5. printf("%c",s[t]);
6. }
7.void main( void )
8. {
9. char nombre[]="Facultad";
10. imp_rev(nombre);
11. }

Manejo de la memoria de forma DINAMICA en ANSI C .

La memoria dinmica en C es creada a travs de funciones definidas en la librera estndar de C, estas
funciones son malloc, calloc, realloc y free.
void *malloc(size_t size);
Esta funcin sirve para asignar memoria de forma dinmica. Asigna tantos bytes como se indica el
parmetro size. funciiona de la forma siguiente:
int *i;
i = (int *)malloc(sizeof(int));

El operador (int *) sirve para hacer la conversin de puntero genrico a puntero entero, ya que la
funcion retorna un puntero void Si la asignacin no se ha podido realizar, devuelve el valor nulo.
void *calloc(size_t nmemb, size_t size);

Esta funcin funciona de modo similar a malloc, pero est hecha para asignar espacio a matrices,
nmemb indica el nmero de elementos que sta tendr, y size el tamao de cada elemento.
void *realloc(void *ptr, size_t size);
Esta funcin redimensiona el espacio asignado de forma dinmica anteriormente a un puntero.
Si el puntero tiene el valor nulo sta acta como malloc. Si la reasignacin no se pudo hacer con xito,
devuelve un puntero nulo, dejando intacto el puntero que se pasa por parmetro.
void free(void *ptr);

































ASIGNACIN


1. Hacer funciones que puedan realizar las siguientes operaciones con matrices:
1. Suma,
2. Resta,
3. Multiplicacin,
4. Multiplicacin por un escalar
5.Clculo de transpuesta,
6. Clculo de matriz inversa.


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int n1, m1, n2, m2,n,m;
float M1[50][50],M2[50][50],M[50][50];
void introMAX1(void);
void introMAX2(void);
void resta(void);
void suma(void);
void multiMAX(void);
void multiplicar(float);
void imprimir(void);
void transpuesta(void);
void inversa(void);
int main()
{
int a, k, j, i;
float e;
printf("\nOPERACIONES CON MATRICES: \n\n");
printf("1. Sumar \n");
printf("2. Restar \n");
printf("3. Multiplicar \n");
printf("4. Multiplicar por escalar\n");
printf("5. Calculo de transpuesta\n");
printf("6. Calculo de matriz inversa\n");
printf("\nQUE OPERACION DESEA REALIZAR : ");
do{
scanf("%i",&a);
}while(!((a>=1)&&(a<=6)));
switch(a){
case 1: introMAX1();
introMAX2();
suma();
imprimir();
break;
case 2:
introMAX1();
introMAX2();
resta();
imprimir();
break;
case 3:
introMAX1();
introMAX2();
multiMAX();
imprimir();
break;
case 4:
introMAX1();
printf("\nIntroduzca un escalar : ");
scanf("%f",&e);
multiplicar(e);
imprimir();
break;
case 5:
transpuesta();
imprimir();
break;
case 6:
inversa();
imprimir();
break;
}
return 0;
}
//declaracion de funciones
//funcion para introducir los valores de la matriz global m1
void introMAX1()
{
int i, j;
printf("\nDigite la dimension que desea para la matriz A: \n");
printf("\nIntroduzca filas : ");
scanf("%i",&n1);
printf("Introduzca columnas : ");
scanf("%i",&m1);
printf("\nDigite los valores que desea de la matriz B: \n\n");
for(i = 0;i<n1;i++)
{
for(j=0; j<m1;j++)
{
printf(" A[%i][%i] = ",i,j);
scanf("%f", &M1[i][j]);
}
printf("\n");
}
}
//funcion para introducir los valores de la matriz global m1
void introMAX2()
{
int i, j;
printf("\nintroduzca las dimenciones\n");
printf("\nfilas : ");
scanf("%i",&n2);
printf("columnas : ");
scanf("%i",&m2);
printf("\nintroduzca los valores de la matriz\n\n");
for(i = 0;i<n2;i++)
{
for(j=0; j<m2;j++)
{
printf(" B[%i][%i] = ",i,j);
scanf("%f", &M2[i][j]);
}
printf("\n");
}
}
//esta funcion imprime la matriz m
void imprimir()
{
int i, j;
printf("\n\n");
for(i = 0;i<n;i++)
{
printf("| ");
for(j=0; j<m;j++)
{
printf("%0.4f ", M[i][j]);
}
printf(" |\n");
}
}
//
void suma()
{
int i, j;
if(!((n1==n2)&&(m1==m2)))
printf("\n\nLas dimensiones de las matrices deben de ser iguales\n\n");
else
{
n=n1;m=m1;
for(i = 0;i<n1;i++)
{
for(j=0; j<m1;j++)
{
M[i][j] = M1[i][j] + M2[i][j];
}
}
}
}
void resta()
{
int i, j;
if(!((n1==n2)&&(m1==m2)))
printf("\n\nLas dimensiones de las matrices deben de ser iguales\n\n");
else
{
n=n1;m=m1;
for(i = 0;i<n;i++)
{
for(j=0; j<m;j++)
{
M[i][j] = M1[i][j] - M2[i][j];
}
}
}
}
void multiMAX()
{
int i,j,k;
if(m1!=n2)
printf("\nLas dimensiones de las matrices deben de ser iguales\n");
else
{
n = n1;
m = m2;
for(i = 0;i<n;i++)
for(j=0; j<m;j++)
M[i][j] = 0.0;
for(i=0;i<n1;i++)
for(j=0;j<m2;j++)
for(k=0;k<m1;k++)
{
M[i][j] += M1[i][k]*M2[k][j];
}
}
}
void multiplicar(float E)
{
int i,j;
n = n1;
m = m1;
for(i = 0;i<n;i++)
for(j=0; j<m;j++)
M[i][j] = M1[i][j]*E;
}
void transpuesta()
{
printf("Numeros a utiizar para hacer la transpuesta: \n 1,9,-3,3 \n 80,29,-12,0 \n 34,21,16,-1 \n 2,1,15,-
13 \n");
int matriz[4][4]={ {1,9,-3,3}, {80,29,-12,0}, {34,21,16,-1}, {2,1,15,-13} };
int f=0,c=0,aux=0;
for(f=0;f<4;f++)
{
printf("\n");
for(c=0;c<4;c++)
{
printf("[%d][%d] ",f,c);
printf("%d\t",matriz[f][c]);}
}
for(f=0;f<4;f++){
for(c=f+1;c<4;c++)
{
aux=matriz[f][c];
matriz[f][c]=matriz[c][f];
matriz[c][f]=aux;
}
printf("\n");
for(f=0;f<4;f++)
{
printf("\n");
for(c=0;c<4;c++)
{
printf("[%d][%d] ",f,c);
printf("%d\t",matriz[f][c]);
}
}
}

printf("\n");
}
void inversa()
{
int i, j, k, l, fila, cola, filb, colb;
printf("\nLas dimensiones de las matrices A y B deben de ser iguales\n");
printf ("\n\nDigite el numero de filas de A : ");
scanf ("%d",&fila);
printf ("\nDigite el numero de columnas de A: ");
scanf ("%d",&cola);
printf ("\nDigite el numero de filas de B : ");
scanf ("%d",&filb);
printf ("\nDigite el numero de columnas de B : ");
scanf ("%d",&colb);
puts ("\n");
if (cola==filb) {
float A[fila][cola], B[filb][colb], C[fila][colb], p;
for (i=0;i<fila;i++) {
for (j=0;j<cola;j++){
printf ("\nDigite un numero A[%d][%d]=",i,j);
scanf ("%f",&A[i][j]);
}
}
for (i=0;i<filb;i++) {
for (j=0;j<colb;j++){
printf ("\nDigite un numero B[%d][%d]=",i,j);
scanf ("%f",&B[i][j]);
}
}
for (i=0;i<fila;i++) {
for (j=0;j<colb;j++){
for (k=0;k<cola;k++){
C[i][j]+=A[i][k]*B[k][j];
}
}
}printf ("\nEl resultado de la multiplicacion de las matrices A y B es:\n");
for (i=0;i<fila;i++) {
for (j=0;j<colb;j++){
printf ("\t\t%.3f",C[i][j]);
}
puts ("\n");
}
if (fila==colb){
printf ("\nLa matriz inversa de A y B es:\n");
for (k=0;k<fila;k++){
p=1/C[k][k];
for (i=0;i<fila;i++){
if (i!=k){
for (j=0;j<colb;j++){
if (j!=k){
C[i][j]-=(C[i][k]*C[k][j]*p);
}
}
}
}
for (l=0;l<colb;l++){
C[k][l]*=p;
}
for (l=0;l<=fila;l++){
C[l][k]=(p*C[l][k]*(-1));
}
C[k][k]=p;
}for (i=0;i<fila;i++){
for (j=0;j<colb;j++)
printf ("\t\t%.3f",C[i][j]);
puts ("\n");
}
}
else{
printf ("La matriz no posee inversa");
}
}
else {
printf ("\nLas matrices no se pueden multiplicar\n\n");
}
}



2. Hacer una funcin que calcule el factorial de un nmero.

# #include <stdio.h>

double fact(int);

int main()
{
int n=1,i;
double producto;

printf("\nIntroducir un numero entero:");
scanf("%d",&n);
for (i=2; i<=n; i++)
producto=fact(n);
printf("El factorial es=%0.0f\n",producto);
return 0;
}

double fact(int z)
{

if(z>1)
return z*fact(z-1);
else
return 1;
}







3. Hacer una funcin que calcule la raz cuadrada utilizando el mtodo de Newton.

#include <stdio.h>
#include <math.h>
#define OK 0
#define ERR 1
#define PREC 0.000001
#define TOL 1.0e-15

/* Escriban un programa que calcule la raz cuadrada de un nmero usando el mtodo de Newton de
aproximacin por intervalos. Para el clculo de la raz cuadrada de 25 el programa toma como
intervalo inicial: [0, 25].
1.Calcula el punto medio del intervalo [0, 25]: 12.5. Como 12.5 > 25, toma como nuevo intervalo:
[0, 12.5]
2.Calcula el punto medio del intervalo [0, 12.5]: 6.25. Como 6.25 > 25, toma como nuevo intervalo:
[0, 6.25]
3.Calcula el punto medio de [0, 6.25]: 3.125. Como 3.125 < 25, toma como nuevo intervalo:
[3.125, 6.25]
4....
Finalmente, el bucle termina cuando el valor absoluto de la diferencia entre el nmero y el punto medio
al cuadrado es menor que una cierta constante, y escribe 4.9999... como solucin. */

double numero; /* Variable global */
double newtonRaiz(double xinf, double xsup);
double auxRaiz(double x);

int main()
{
printf("Introduzca un numero real:\t");
scanf("%lf",&numero);
printf("La raiz cuadrada de %g es %.6f\n", numero,newtonRaiz(0,numero));
return OK;
}

double newtonRaiz(double xinf, double xsup){

int iteraciones = 0;
const int MAXITER = 100; /* Ambito reducido a esta funcion */

if(fabs(auxRaiz(xinf))<TOL) return xinf;
if(fabs(auxRaiz(xsup))<TOL) return xsup;

while(fabs(xsup-xinf) > PREC && iteraciones < MAXITER){
double xmed, fxmed; /* Ambito reducido a este bloque */
xmed = 0.5*(xinf+xsup);
fxmed = auxRaiz(xmed);
if(fabs(fxmed)<TOL)
return xmed;
else if(auxRaiz(xinf)*fxmed<0)
xsup = xmed;
else
xinf = xmed;
iteraciones++;
}

if(iteraciones == MAXITER)
fprintf(stderr,"Newton ha alcanzado el maximo numero de iteraciones %d", MAXITER);
return 0.5*(xinf+xsup);
}

double auxRaiz(double x){
return x*x-numero;
}



4. Hacer una Base de Datos para una empresa de 100 empleados, donde estn
categorizados por: nombre completo, ISSS, NIT, DUI, NUP, nmero de empleado (cdigo: 00xx
es jefe, 01xx es ordenanza, 02xx es operario, 03xx vigilante, 04xx cocinero) y salario dependiendo
el cdigo. Los datos se deben de mantener en un archivo binario, y al momento de cargar el
programa, se debe de crear la estructura respectiva, claro se debe usar memoria dinmica
para agregar empleados o despedir. Tambin se debe de tener un MENU, que
despliegue en pantalla: Introducir empleado, borrar empleado, mostrar datos de empleado
(Cdigo, Nombre completo, nmero de ISSS, nmero de NUP, nmero de DUI, calculo de salario
con el detalle de descuentos), mostrar todos.



#include<stdio.h>
#include<stdlib.h>
void agregar(void);
void eliminar(void);
void mostrar(void);

struct empleados{
char nombre[50];
char iss[20];
char nit[50];
char dui[20];
char nup[30];
char numero[20];
char salario[30];

};
int main() {
int n,a,b,c,d,e,f,g;
printf("\n Aqui se encuentras los datos de los 100 empleados que conforman la empresa\n");
printf("\n\t Cathy\n");
printf("Si desea conocer los datos de algunos de ellos le presentamos las siguientes \nopciones: \n");
printf("1.Agregar empleado. \n");
printf("2.Eliminar al empleado. \n");
printf("3.Mostrar los datos de el empleado. \n");
printf("Escoga una opcion: \n");
do{
scanf("%i",&n);
}while(!((n>=1)&&(n<=3)));
switch(n){
case 1:
agregar();
break;
case 2:
eliminar();

break;
case 3:
mostrar();
break;

}
return 0;
}
void agregar()
{
int b,c,d,e,f,g;
printf("Digite los datos. \n");
printf("Nombre completo: \n");
scanf("%d",&b);
printf("ISS: \n");
scanf("%d", &c);
printf("NIT: \n");
scanf("%d",&d);
printf("DUI: \n");
scanf("%d", &e);
printf("Numero de empleado: \n");
scanf("%d",&f);
printf("Salario dependiendo del cdigo: \n");
scanf("%d",&g);

}
void eliminar()
{
int n;
printf("Digite el numero de el empleado que desea eliminar: \n");
scanf("%d", &n);
}

void mostrar()
{
int n;
printf("Digite el numero de l empleado del cual desea conocer los datos: \n");
scanf("%d", &n);
}
















CONCLUSION

Las estructuras y arreglos, se da como conclusin que realmente funcionan de una forma muy practica
para la solucin de problemas sencillos y de forma ms prctica, incluso en aplicaciones en lo que es
respecto a las funciones para simplemente hacer una llamada y lograr un mejor servicio para el usuario
haciendo un uso ms eficiente de las herramientas a utilizar.

Este ltimo laboratorio se aprendi a utilizar las estructuras y las funciones de una manera rpida
haciendo todo el trabajo ms fcil con lo cual se resolvi la asignacin correspondiente.
Se conoce ahora un poco ms de las ventajas que ofrece el lenguaje de programacin en C y como
explotarlo para nuestro beneficio.