Metodos Numericos

INSTITUTO POLITCNICO NACIONAL.
ESCUELA SUPERIOR MECNICA Y ELCTRICA.
Seccin de Estudios de Posgrado e Investigacin.

Departamento de Ingeniera Elctrica.
PROGRAMACIN Y
MTODOS
NUMRICOS.
TRABAJO 1.
PROFR. M. en C. JESS REYES GARCA.
11
NJERA GUTIRREZ WILLIAMS
MXICO, DISTRITO FEDERAL
31 MAYO, 2011.
PROGRAMACIN Y MTODOS NUMRICOS.
2011
NDICE.
INTRODUCCIN A LA PROGRAMACIN............................................................................................................... 5
PROGRAMA PARA LA SOLUCIN DE UNA ECUACIN DE SEGUNDO GRADO DE LA FORMA
ax2+bx+c=0. .................................................................................................................................................................. 6
Diagrama de flujo. ................................................................................................................................................. 6
Programa................................................................................................................................................................... 7
PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE n NMEROS. .......................... 8
Diagrama de flujo. ................................................................................................................................................. 8
Programa................................................................................................................................................................... 9
PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE NMEROS CON
FUNCIONES................................................................................................................................................................ 10
Diagrama de flujo. .............................................................................................................................................. 10
Programa................................................................................................................................................................ 11
PROGRAMA PARA MULTIPLCAR MATRICES.............................................................................................. 12
Programa: .............................................................................................................................................................. 13
PROGRAMA PARA MULTIPLCAR MATRICES (FUNCIONES)................................................................ 14
Programa................................................................................................................................................................ 15
PROGRAMA PARA ENCONTRAR EL MENOR Y MAYOR NMERO DE UNA LISTA DE
NMEROS................................................................................................................................................................... 17
Programa................................................................................................................................................................ 18
PROGRAMA PARA ORDENAR NMEROS DE FORMA ASCENDENTE (TAREA)........................... 19
Programa................................................................................................................................................................ 20
PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NMEROS (MTODO 1)................. 21
Diagrama de flujo ............................................................................................................................................... 21
Programa................................................................................................................................................................ 22
PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NMEROS (MTODO 2)................. 23
Programa................................................................................................................................................................ 25
PROGRAMA PARA ORDENAR NMEROS POR EL MTODO DE LA BURBUJA. ............................ 28
2011

Programa................................................................................................................................................................ 30
MTODOS NUMRICOS............................................................................................................................................. 32
SOLUCIN DE ECUACIONES LINEALES(Mtodos directos). .................................................................... 33
MTODO DE ELIMINACIN DE GAUSS. ........................................................................................................ 33
Programa................................................................................................................................................................ 35
MTODO DE GAUSS-JORDAN. ........................................................................................................................... 37
Programa................................................................................................................................................................ 39
INVERSIN DE MATRICES....................................................................................................................................... 41
MTODO DE GAUSS-JORDAN. ........................................................................................................................... 41
Programa................................................................................................................................................................ 43
SOLUCIN DE ECUACIONES LINEALES (Mtodos iterativos). ............................................................... 46
MTODO ITERATIVO DE GAUSS. ..................................................................................................................... 46
Programa................................................................................................................................................................ 50
MTODO ITERATIVO DE GAUSS-SEIDEL. .................................................................................................... 53
Programa................................................................................................................................................................ 57
SOLUCIN DE SISTEMAS DE ECUACIONES NO LINEALES. ....................................................................... 60
MTODO DE NEWTON-RAPHSON................................................................................................................... 60
Programa................................................................................................................................................................ 63
AJUSTE DE CURVAS..................................................................................................................................................... 66
MTODO DE MNIMOS CUADRADOS. ............................................................................................................ 66
Programa................................................................................................................................................................ 68
INTERPOLACIN POR MTODO DE LAGRANGE. ..................................................................................... 71
Programa................................................................................................................................................................ 75
SOLUCIN DE ECUACIONES DIFERENCIALES. ............................................................................................... 78
2011

Programa................................................................................................................................................................ 79
MTODO MODIFICADO DE EULER. ................................................................................................................ 80
Programa................................................................................................................................................................ 81
MTODO DE RUNGE KUTTA.............................................................................................................................. 81
Programa................................................................................................................................................................ 83
2011
INTRODUCCIN A LA PROGRAMACIN.
2011
PROGRAMA PARA LA SOLUCIN DE UNA ECUACIN DE SEGUNDO GRADO

DE LA FORMA AX 2+BX+C=0.
Hacer el diagrama de flujo y programa para resolver una ecuacin de segundo grado
de la forma aX 2+bX+c=0.
Diagrama de flujo.
Inicio
a,b,c.
disc=b*b-4*a*c
disc<0.0
x1r=-b/(2.0*a)
x1i=sqrt(fabs(disc)/2.0*a
x2r=x1r
x2i=-x1i
Las races son complejas

y conjugadas
x1r,x1i,
x2r,x2i
disc<0.0
X1=(-b+sqrt(disc)/2.0*a)
X2=(-b-sqrt(disc)/2.0*a)
Las races son reales

y distintas:
X1, X2
X1=-b/2.0*a
X2=-x1
Las races son reales

e iguales
FIn
Fi gura 1.Dia grama de flujo pa ra progra ma pa ra la soluci n de ecua ciones de segundo gra do.
2011
Programa.
#include"conio.h"
#include"stdlib.h"
#include"math.h"
main()
{
float a,b,c,x1,x2,x1r,x1i,x2r,x2i,disc;
/*Se declaran las funciones flotantes*/
gotoxy(20,1);printf("Solucin de una ecuacin de segundo grado");
gotoxy(2,2); printf("a=");scanf("%f",&a);
/*se guarda el primer coeficiente*/
gotoxy(20,2); printf("b=");scanf("%f",&b);
/*Se guarda el segundo coeficiente*/
gotoxy(40,2); printf("c=");scanf("%f",&c);
/*se guarda el tercer coeficiente^/
disc=b*b-4.0*a*c;
/*operacin dentro de la raiz*/
if(disc<0)
/*condicin para raices complejas*/
{
x1r=-b/(20*a);x1i=sqrt(fabs(disc))/2.0*a;
/*opera el absoluto de la raiz*/
x2r=x1r; x2i=-x1i;
/*Iguala los valres conjugados*/
gotoxy(2,15);printf("las raices son complejas y conjugadas");
gotoxy(2,16);printf("x1r=%f,x1r=%f,x2r=%f,x2i=%f",x1r,x1i,x2r,x2i);
}
else if(disc>0)
/*evala los valores reales*/
{
x1=(-b+sqrt(b*b-4.0*a*c))/(2.0*a);
/*obtiene el primer resultado*/
x2=(-b-sqrt(b*b-4.0*a*c))/(2.0*a);
/*obtiene el segundo resultado*/
gotoxy(2,15);printf("Las races son reales y distintas");
gotoxy(2,16);printf("x1=%f,x2%f",x1,x2);
}
Else
/*opcin para valor igual a cero*/
{
x1=-b/(2.0*a); x2=x1;
/*calcula el valor para ambos resultados*/
gotoxy(2,15);printf("Las races son reales e iguales");
gotoxy(2,16);printf("x1=%f,x2=%f",x1,x2);
}
gotoxy(2,24);printf("presione cualquier tecla para continuar");
getch();
/*espera a recibir una tecla para continuar*/
}
2011
PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE N

NMEROS.
Hacer el diagrama de flujo y programa para obtener el promedio de una lista de n nmeros.
Diagrama de flujo.
Inicio
for(i=1;i<=n;i++)
x[i]
sum=0.0
for(i=1;i<=n;i++)
sum=sum+x[i]
Prom=sum/n
prom
Fin
Fi gura 2.Dia grama pa ra solucin de ecua ciones de segundo gra do.
2011
Programa.
#include"stdlib.h"
#include"conio.h"
#include"stdio.h"
#include"math.h"
main()
{
int n,i;
/*declara las variables enteras*/
float sum,prom, x[50];
/*declara las variables flotantes*/
gotoxy(2,1);printf("Programa para evaluar el promedio de una lista de numeros "),
gotoxy(3,2);printf("Dame el numero de elementos a sumar ");
scanf("%d",&n);
/*guarda el nmero de elementos a sumar*/
gotoxy(4,3);
for(i=1;i<=n;i++)
/*ciclo para guardar cada valor a sumar*/
{
printf("Dame el valor X[%i]=",i);scanf("%f",&x[i]);
gotoxy(4,3+i);
/*ecuacin para incrementar espacio en filas*/
}
sum=0.0;
/*inicia la suma en cero*/
for(i=1;i<=n;i++)
/*inicia el contador para suma*/
{
sum=sum+x[i];
/*realiza la operacin*/
}
prom=sum/n;
/*obtiene el promedio*/
gotoxy(2,15);printf("El promedio es:prom=%f",prom);
gotoxy(2,24);printf("presione cualquier tecla para salir");
getch();
/*espera un tecleo para continuar*/
}
2011
PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE NMEROS

CON FUNCIONES.
Realizar un programa para obtener el promedio de una lista de n nmeros utilizando
funciones que agrupen el programa:
Diagrama de flujo.
Inicio
n
leevec(a,n,x,2,3)
leevec(a, n, 3, 2)
for(i=1;i<=n;i++)
prom(a, n)
prom
a)
FIn
a[i]
Fin
b)
prom(a,n)
sum=0.0
for(i=1;i<=n;i++)
sum=sum+a[i
]
prom=sum/n
c)
Fin
Fi gura 3.Solucin de ecua ciones de segundo grado con funciones : a) main b) funcin de lectura y c)Funcin de promedio .
10
2011
Programa.
#include"conio.h"
#include"stdlib.h"
#include"stdio.h"
#include"math.h"
void leervec(float[20], int, char[5], int, int); /*prototipo funcion leer vector*/
float prom(float[20], int);
/*prototipo funcin promedio*/
float res;
main()
{
int n;
/*declara la variable entera*/
float x[50];
/*declara la variable flotante*/
gotoxy(10,1); printf("Programa para obtener el promedio de una lista de numeros");
gotoxy(2,2); printf("Dame el numero de elementos en la lista "); scanf("%d",&n);
leervec(x,n,"x",3,4);
/*llama la funcion leer vector*/
prom(x,n);
/*llama la funcin promedio*/
gotoxy(2,15); printf("El promedio es:prom=%f", res);
gotoxy(2,24); printf("Presione cualquier tecla para continuar");
getch();
}
void leervec(float a[20], int n, char nom[5], int col, int fil)
{
int i;
gotoxy(col,fil);
/*posicionamiento del texto*/
for(i=1;i<=n;i++)
/*inicia contador para realizar la suma*/
{
printf("%s[%d]=",nom,i);
scanf("%f",&a[i]);
/*pide cada valor a sumar*/
gotoxy(col,fil+i);
/*ecuacin para incrementar filas*/
}
}
float prom(float a[20], int n)
{
int i;
float sum;
sum=0.0;
for(i=1;i<=n;i++)
{
sum=sum+a[i];
}
res=sum/n;
return(res);
}
11

/*inicia la suma en cero*/
/*inicia el contador para realizar la suma*/
/*ecuacin para realizar la suma*/
/*obtiene el promedio*/
/*devuelve el valor del promedio*/
2011
PROGRAMA PARA MULTIPLCAR MATRICES.

Realizar el diagrama de flujo y programa para realizar la multiplicacin de matrices.
Diagrama de flujo.
Inicio
nca , nfa ,
ncb
for(i=1;i<=nfa;i
++)
for(j=1;j<=nfa;j
++)
a[i][j]
for(j=1;j<=nfa;j
++)
for(j=1;j<=nfa;j
++)
b[i][j]
1
1
for(i=1;i<=nfa;i
++)
for(i=1;i<=nfa;i
++)
c[i][j]=0.0
for(i=1;i<=nfa;i++
)
for(j=1;j<=nfa;j++
)
for(l=1;l<=nca;l
++)
c[i][j]=c[i][j]+
a[l][j]*b[l][j]
Fi gura 4.Progra ma pa ra mul tiplica r matri ces .
12
c[i][j]
Fin
2011
Programa:
#include"stdio.h"
#include"conio.h"
main()
{
int i,j,l,nfa,nca,ncb,col1;
float a[20][20], b[20][20],c[20][20];
/*declara las variables flotantes*/
gotoxy(2,1);printf("nfa=");scanf("%d",&nfa);
/*guarda el nmero de filas de a*/
gotoxy(20,1);printf("nca=");scanf("%d",&nca); /*guarda el nmero de columnas de a*/
gotoxy(40,1);printf("ncb=");scanf("%d",&ncb); /*guarda el nmero de columnas de b*/
gotoxy(36,2);printf("Matriz a");
for(i=1;i<=nfa;i++)
/*inicia el contador para filas*/
{
col1=2;
/*inicia el valor de columnas*/
for(j=1;j<=nca;j++)
/*inicia el contador para columnas*/
{
gotoxy(col1,i+2);
/* posicionamiento en pantalla*/
scanf("%f",&a[i][j]);
/*guarda cada valor*/
col1=col1+10;
/*incrementa el valor de las columnas*/
}
}
gotoxy(36,10);printf("Matriz b");
for(i=1;i<=nca;i++)
/*inicia el contador para las filas*/
{
col1=2;
/*inicia las columnas en 2 */
for(j=1;j<=ncb;j++)
/*inicia el contador de las columnas */
{
gotoxy(col1,i+10);
scanf("%f",&b[i][j]);
/*guarda cada valor */
col1=col1+10;
/* incrementa el valor de la columna*/
}
}
for(i=1;i<=nfa;i++)
/* contador para filas*/
{
for(j=1;j<=ncb;j++)
/*contador para columnas */
{
c[i][j]=0.0;
/*inicia la suma en cero */
for(l=1;l<=nca;l++)
/*inicia el contador para recorrido de suma */
{
c[i][j]=c[i][j]+a[i][l]*b[l][j];
/*operacin de suma */
}
}
}
gotoxy(33,17);printf("matriz c=a*b");
/*muestra el titulo pantalla */
for(i=1;i<=nfa;i++)
/*inicia el contador para filas */
{
col1=2;
/*inicia las columnas en 2 */
for(j=1;j<=ncb;j++)
/* inicia el contador de columnas*/
{
13
2011
gotoxy(col1,i+20);
printf("%f",c[i][j]);
/*titulo en pantalla */
col1=col1+10;
/*incrementa el valor de columna */
}
}
gotoxy(2,30);printf("presione cualquier tecla para continuar");
getch();
/*espera un tecleo para continuar */
return 0;
}
PROGRAMA PARA MULTIPLCAR MATRICES (FUNCIONES).

Elabore un programa para realizar la multiplicacin de matrices por medio del llamado de
funciones.
Diagrama de flujo.
Inicio
nfa,nca,ncb
leemat(a,n,x,2,3)
Leemat(a,nfa,nca,10)
for(i=1;i<=n;i++)
Leemat(b,nca,ncb,10)
for(j=1;j<=n;j++)
multimat(a,b,c,nfa,nca)
a[i][j]
Fin
a)
14
mostrar(c,20, nfa, ncb))
b)
Fin
2011
multimat(a,b,c, nca, nfa, ncb)
for(i=1;i<=nfa;i+
+)
for(i=1;i<=nfa;i+
+)
for(i=1;i<=nfa;i++
)
c[i][j]=0.0
for(j=1;j<=nfa;j++
)
for(l=1;l<=nca;l+
+)
c[i][j]
c[i][j]=c[i][j]+ a[l][j]*b[l][j]
Fin
c)
Fin
d)
Fi gura 5.Multipli ca cin de matri ces por funciones : a)main, b)lectura de ma tri z, c)mul tipli caci n, d) mos tra r.
Programa.
#include"stdio.h"
#include"conio.h"
#include"stdlib.h"
void leermat(float [20][20],int,int,int);
/*prototipo leer matriz */
void multimat(float [20][20],float [20][20],float [20][20], int ,int , int ); /* prototipo multip*/
void mostrar(float [20][20],int, int, int);
/*prototipo muestra matriz */
main()
{
int nfa, nca, ncb;
/*declara las variables enteras */
float a[20][20],b[20][20],c[20][20];
/* declara las variables flotantes*/
printf("Programa para multiplicar matrices");
printf("\nDame el numero de filas de la matriz A = ");
scanf("%d",&nfa);
/*obtiene el numero de filas de a */
printf("\nDame el numero de columnas de la matriz A = ");
scanf("%d",&nca);
/*numero de columnas de a */
printf("\nDame el numero de columnas de B = ");
scanf("%d",&ncb);
/*numero de columnas de b */
leermat(a,nfa,nca,10); //Lee mi matriz A
/*llama la funcion de leer matriz */
leermat(b,nca,ncb,14); //lee mi matriz B
/*llama la funcion de leer matriz */
multimat(a,b,c, nca, nfa, ncb);
/* llama la funcion de multiplicar matrices*/
mostrar(c,20,nfa, ncb);
/*llama la funcion de mostrar matriz */
getch();
}
15
2011
void leermat(float A[20][20],int nf, int nc,int fil)

{
int i, j, col;
/*declara los valores enteros a utilizar en la funcion*/
printf("Dame tu matriz");
for(i=1;i<=nf;i++)
/*inicia el contador para las filas */
{
col=2;
/*inicia las columnas en dos */
for(j=1;j<=nc;j++)
/* inicia el contador de columnas*/
{
gotoxy(col,fil+i);
/*posicionamiento en pantalla */
scanf("%f",&A[i][j]);
/*guarda cada valor de la matriz */
col=col+5;
/*incrementa el valor de las columnas */
}
}
}
void multimat(float a[20][20],float b[20][20],float c[20][20], int nca,int nfa, int ncb)
{
int i,j,l;
for(i=1;i<=nfa;i++)
/*inicia el contador para las filas */
{
for(j=1;j<=ncb;j++)
/*inicia el contador para las columnas */
{
c[i][j]=0.0;
/*inicia la suma en cero */
for(l=1;l<=nca;l++)
/*contador para recorrido de la suma */
{
c[i][j]=c[i][j]+a[i][l]*b[l][j];
/*ecuacin para suma de matrices */
}
}
}
}
void mostrar(float c[20][20],int fil, int nfa, int ncb)
{
int i, j, col, col1;
col=2;
/*inicia las columnas en dos */
gotoxy(col,fil);printf("matriz c=a*b");
for(i=1;i<=nfa;i++)
/*inicia contador para las filas */
{ fil=fil+i;
/*incrementa el valor de las filas */
col1=col;
/*designa valor a las columnas */
for(j=1;j<=ncb;j++)
/*inicia contador para las columnas */
{
gotoxy(col1,fil);
/*posicionamiento en pantalla */
printf("%f",c[i][j]);
col1=col1+10;
/*incrementa el valor de columnas */
}
}
}
16
2011
PROGRAMA PARA ENCONTRAR EL MENOR Y MAYOR NMERO DE UNA

LISTA DE NMEROS.
Elaborar un programa para encontrar el menor y el mayor nmero de una lista de n
elementos.
Diagrama de flujo.
Inicio
leevector()
menor=x[i]
mayor=x[i]
For(i=2;i<=n;i++)
x[i]<menor
x[i]>mayor
menor=x[i]
menor=x[i]
menor
mayor
mayor
Fin
Fi gura 6.Progra ma pa ra encontra r el ma yor y menor nmero.
17
mayor=x[i]
2011
Programa.
#include "s tdio.h"
#include "conio.h"
#include "s tdlib.h"
void leervec(float[20], int, char[5], int, int);
float menor(float [20], int);
float mayor(float [20], int);
main()
{
int n;
float may, men, x[20];
gotoxy(12,1);printf("Programa que compara una lista de numeros ");
printf("\nCuantos el ementos ti ene tu lista? ");
scanf("%d",&n);
/*Se Captura el nmero de elementos a ordenar*/
leervec(x,n,"x",2,3);
/*Se llama la funcin para leer el vector* /
men=menor(x,n);
/*Se llama la funcin para encontrar el nmero menor*/
may=mayor(x,n);
/*Se llama la funcin para encontrar el nmero mayor* /
gotoxy(4,15);printf("Tu numero mayor es %f",may);
gotoxy(4,16);printf("Tu numero menor es %f",men);
gotoxy(2,19);printf("Presiona para una tecla para continuar");
getch();
}
void leervec(float x[20], int n, char nom[5], int col, int fil)
{
int i;
gotoxy(col,fil);
for(i=1;i<=n;i++)
/*Se inicia un contador para todos los nmeros de la lista*/
{ printf("%s[%d]=",nom,i);
scanf("\n%f",&x[i]);
/*se guarda cada elemento*/
gotoxy(col,fil+i);
/*Se incrementa un valor a la fila de l a prxima iteracin*/ }
}
float menor(float x[20], int n)
{
int i;
/*declara la variabl e entera*/
float men;
/*Se defi ne la variable donde se guardar el nmero menor*/
men=x[1];
/*el primer valor a analizar es*/
for(i=2;i<=n;i++) /*inicia el contador para cada elemento* /
{ if(x[i]<men) /*condicion para numero menor*/
{ men=x[i]; } } /*asigna el valor del numero menor* /
return (men);
/* regresa el valor menor*/
}
float mayor(float x[20], int n)
{
int i;
float may ;
may=x[1];
for(i=2;i<=n;i++)
{
if(x[i]>may)
{ may=x[i]; } }
return (may);
}
18

/*asigna el primer v alor como mayor*/
/*inicia el contador para recorrido de numeros*/
/*condicion para numero mayor*/
/*asigna el valor mayor*/
/*devuelve el numero mayor* /
2011
PROGRAMA PARA ORDENAR NMEROS DE FORMA ASCENDENTE (TAREA).

Realizar un programa para ordenar una lista de nmeros.
Diagrama de flujo.
Inicio
Leemat(a,n)
Leemat(a,n)
Operamat(a,n)
for(i=1;i<=n;i++)
most
a[i]
Fin
a)
Fin
b)
Operamat(a,n
)
For(i=0;i<=n-1;i++)
For(j=i+1;j<=n;j++)
most
For(i=0;i<=n;i++)
a[j]<[i]
temp=a[j]
a[j]=a[i]
a[i]=temp
a[i]
Fin
c)
Fin
d)
Fi gura 7.Progra ma pa ra ordena r nmeros con funciones a )main, b)leer, c)opera r y d)mostra r.
19

Programa.
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
main()
{
int a[20];
int j, i, temp, n;
printf("Dame el numero de valores a ordenar ");
scanf("%d",&n);
printf("\nIntroduce los %d valores para ordenar:\n", n);
for(i=0; i<n; i++)
{
printf("%d: ", i+1);
scanf("%d", &a[i]);
printf("\n");
}
for(i=0; i<(n-1); i++)
{
for (j=i+1; j<n; j++)
{
if(a[j]<a[i])
{
temp=a[j];
a[j]=a[i];
a[i]=temp;
}
}
}
printf("El vector ordenado es:\n");
for(i=0; i<n ; i++) {
printf("%d ", a[i]);
}
printf("\nPresiona una tecla para salir");
getch();
}
20
2011
2011
PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NMEROS

(MTODO 1).
Diagrama de flujo
Ini cio
Leemat(a,n)
Leemat(a ,n)
for(i=1;i<=n;i++)
Ord(a ,n)
a[i]
mos t(a .n)
a)
Fin
Fi n
b)
Ord(a ,n)
For(i=1;i <=n;i ++)

men=x[i];pmen=
1
For(j=1+i ;j<=n;j++)
most(a,n)
x[j]<men
men=x[i]
pmen=j
For(i=0;i<=n;i++)
a[i]
aux=x[i ]
x[i]=x[pmen]
x[pmen]=aux
Fi n
c)
d)
Fin
Fi gura 8.Ordena r nmeros con funciones a) main, b)leer c)ordena r y c) mos tra r.
21

Programa.
#include "conio.h"
#include "stdio.h"
#include "stdlib.h"
void leemat(float [20], int);
void ord(float [20], int);
void most(float [20], int);
main()
{
int n;
float a[20];
printf("Programa para ordenar de forma descendente una lista de numeros");
printf("\nDame el numero de valores a ordenar ");
scanf("%d",&n);
/*guarda el numero de valores*/
leemat(a,n);
/*llama la funcion leer matriz*/
ord(a,n);
/*llama la funcion ordenar numeros*/
most(a, n);
/*llama la funcion de mostrar numeros*/
printf("\nPresiona una tecla para continuar");
getch();
}
void leemat(float a[20], int n)
{
int i;
/declara la variables entera* */
for(i=1; i<=n; i++)
/*contador para los numeros */
{
printf("%d: ", i);
scanf("%f", &a[i]);
/*guarda los numeros de la lista */
printf("\n");
}
}
void ord(float a[20], int n)
{
int i,j, pmen;
float men, aux;
for(i=1;i<=n;i++)
{
men=a[i];
pmen=i;
for(j=i+1;j<=n;j++)
{
if(a[j]<men)
{
men=a[j];
pmen=j;
}
22

/*declara las variables flotantes */
/* inicia contador para los numeros*/
/*asigna el valor menor */
/*inicia el contador para los numeros de la lista*/
/*inicia la condicion para numero menor */
/*asigna el numero menor */
/* toma la posicion del numero*/
2011
}
aux=a[i];
a[i]=a[pmen];
a[pmen]=aux;
}
2011
/*toma el primer valor */

/*coloca el numero menor en posicion*/
/*coloca al numero restante en la posicion del menor */
void most(float a[20], int n)

{
int i;
printf("Los numeros ordenados son:\n");
for(i=1; i<=n ; i++)
/*inicia el contador para mostrar numeros */
{
printf("\n%f", a[i]);
/*muestra en pantalla*/
}
}
PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NMEROS

(MTODO 2).
Diagrama de flujo.
Inicio
n
Leemat(a,n)
Leemat(a,n)
for(i=1;i<=n;i++)
Ord(a,n)
a[i]
most(a.n)
Fin
a)
23
b)
Fin
most(a,n)
For(i=1;i<=n;i++)
a[i]
c)
24
Fin
2011
2011
ordena(a ,n)
for(i =1;i <=n/2;i ++)
Fi n
pmen=i
pma y=i
men=x[i]
ma y=x[i ]
for(j=i+1;j<n+1;j++)
x[i]<men
pmen=j
men=x[j]
x[j]<ma y
pma y=j
ma y=x[j]
aux=x[i ]
x[i]=x[pmen]
x[pmen]=aux
pma y=i
pma y=pmen
aux=x[n+1-i ]
x[n+1+i ]=x[pma y]
x[pma y]=aux
d)
Fi gura 9.Progra ma pa ra ordena r nmeros a)main, b)leer, c) mos tra r, d) ordena r
Programa.
#include"conio.h"
#include"stdio.h"
#include"stdlib.h"
void leemat(float [20],int);
void ord(float [20],int);
25
2011
void most(float [20],int);

main()
{
int n;
float a[20];
printf("PROGRAMA PARA ORDENAR EN FORMA DESCENDENTE UNA LISTA DE NMEROS");
scanf("%d",&n);
leemat(a,n);
ord(a,n);
most(a, n);
getch();
}
{
int i;
for(i=1; i<=n; i++)
{
printf("%d: ", i);
scanf("%f", &a[i]);
printf("\n");
}
}
void ord(float a[20], int n)
{
int i,j, pmen, pmay;
float men, aux, may;
for(i=1;i<=n/2;i++)
{
pmen=i;
pmay=i;
men=a[i];
may=a[i];
for(j=i+1;j<=n+1-i;j++)
{
if(a[j]<men)
{
pmen=j;
men=a[j];
}
else
{
if(a[j]>may)
{
26
/*variables enteras */
/*variables flotantes */
/*contador para recorrido de numeros */
/*posicion del num menor */
/*posicion del num mayor */
/*numero menor */
/*numero mayor */
/*recorrido para numero menor */
/*condicion para numero menor */
/*guarda la posicion del numero */
/*asigna el valor del menor */
/*condicion para mayor */
pmay=j;
may=a[j];
2011
/*posicion mayor */
/*asigna el valor mayor */
}
aux=a[i];
a[i]=a[pmen];
a[pmen]=aux;
if(pmay==i)
{
pmay=pmen;
}
aux=a[n+1-i];
a[n+1-i]=a[pmay];
a[pmay]=aux;
}
/*guarda el valor del numero inicial */

/*asigna el valor de la posicion menor */
/*guarda el numero restante en la posicion anterior */
/*posicion del mayor */
/*asigna el menor */
/*recorre el valor del valor anterior */
/*asigna el valor mayor */
/*guarda el valor anterior */

{
int i;
for(i=1; i<=n ; i++)
{
}
}
27
2011
PROGRAMA PARA ORDENAR NMEROS POR EL MTODO DE LA BURBUJA.

Diagrama de flujo.
Inicio
n
Leemat(a,n)
Leemat(a,n)
for(i=1;i<=n;i++)
burbuja(a,n)
a[i]
most(a.n)
Fin
a)
Fin
b)
most(a,n)
For(i=1;i<=n;i++)
a[i]
Fin
c)
28
2011
burbuja
S=v
While(s==v)
Fin
for(i=1;i<=n;i++)
x[i]>x[i+1]
aux=x[i];
x[i]=x[i+1]
x[i+1]=aux;
break;
i==n-1
ban=1
i==n-1
s=f
d)
Fi gura 10.Metodo de la burbuja a)main, b)leer, c)mostra r, d) burbuja .
29
2011
Programa.
#include"conio.h"
#include"stdio.h"
#include"stdlib.h"
void leemat(float [20], int);
void burbuja(float [20], int);
void most(float [20], int);
main()
{
int n;
/*declara variables enteras*/
float a[20];
printf("PROGRAMA PARA ORDENAR UNA LISTA DE NUMEROS, METODO BURBUJA");
scanf("%d",&n);
/*obtiene el numero de elementos*/
leemat(a,n);
/*llama la funcion leer matriz*/
burbuja(a,n);
/*llama la funcion ordenar burbuja*/
most(a,n);
/*llama la funcion mostrar*/
getch();
}
{
int i;
for(i=1; i<=n; i++)
{
printf("%d: ", i);
scanf("%f", &a[i]);
printf("\n");
}
}
void burbuja(float a[20], int n)
{
int i,ban;
float aux;
char s;
s='v';
while(s=='v')
{
ban=0;
for(i=1;i<=n-1;i++)
{
if(a[i]>a[i+1])
{
aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
30
/*variables enteras*/
/*variables flotantes*/
/*variables caracter*/
/*asigna un valor de referencia*/
/*condicion para seguir ordenando*/
/*asigna valor de referencia*/
/*inicia contador para los numeros*/
/*si el actual mayor al siguiente*/
/*guarda el valor actual en aux*/
/*se guarda el valor siguiente en el lugar actual*/
/*se guarda el valor mayor*/
break;
}
Else
{
if(i==n-1)
{
ban=1;
}
}
}
if(ban==1)
{
s='f';
}
}
/*termina el proceso*/
/*opcion alterntiva*/
/*si llega al penultimo numero*/
/*cambia el valor de referencia*/
/*si cambia el valor de referencia*/

/*cambia el valor referencia para continuar while*/

{
int i;
for(i=1; i<=n ; i++)
{
}
}
31
2011
MTODOS NUMRICOS.
32
2011
2011
SOLUCIN DE ECUACIONES LINEALES(Mtodos directos).

MTODO DE ELIMINACIN DE GAUSS.
Realizar el programa para obtener la solucin de un sistema de ecuaciones por eliminacin de
Gauss.
Diagrama de flujo.
Inicio
leemat(a,n,x,2,3)
n
for(i=1;i<=n;i++)
Leemat()
for(j=1;j<=n;j++)
egauss()
a[i][j]
mostrar()
a)
Fin
Fin
b)
for(i=1;i<=nfa;i++
)
for(j=1;j<=nfa;j++
)
c[i][j]
c)
33
Fin
2011
egauss
For(i=1;i <=n;i
++)
aux=a [i]
[i ]
for(j=1;j<=n+1;j+
+)
a[i ][j]=a [i][j]

/a ux
for(j=i+1;j<=n;j++)
aux=a [j][i]
for(k=1;k<=n+1;k
++)
a[j][k]=a[j][k]a[j][k]*aux
x[n]=a[n][n+1]/a[
n][n]
for(k=1;k<=n+1;k
++)
x[i]=a [i][n+1]
Fi n
d)
for(j=i+1;j<=n;j++)
x[i]=x[i ]a[i ][j]*x[j]
Fi gura 11.Solucin de ecuaciones lineales a)main, b)leer, c)mostra r, c) gauss .
34
2011
Programa.
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"
void egauss(float [20][21], int , float [20]);
void leermat(float [20][21],int, int);
void mostrar(float [20],int );
main()
{
int n;
float a[20][21], x[20];
printf("\nPrograma que resuelve ecuaciones lineales por eliminacion de Gauss");
printf("\nDame el numero de ecuaciones a operar ");
scanf("%d",&n);
/*Guarda la dimensin del sistema de ecuaciones a trabajar*/
leermat(a,n,5);
/*Ejecuta la funcin para leer la matriz*/
egauss(a,n,x); /*Ejecuta la funcin para realizar la eliminacin por Gauss*/
mostrar(x,n); /*Ejecuta la funcin para mostrar el resultado de la matriz en pantalla*/
getch();
/*Espera un tecleo para continuar*/
}
void leermat(float a[20][21],int n, int fil)
/* valores adquiridos desde "main"*/
{
int i, j, col, nf, nc;
/*Declara las variables a utilizar a lo largo de la
funcin*/
nf=n;
/*El nmero de filas es igual al nmero de ecuaciones*/
nc=n+1;
/* ecuacin para incremento de columnas*/
printf("Dame la matriz aumentada");
for(i=1;i<=nf;i++)
/*Se inicia el FOR contando hasta el nmero de filas totales*/
{
col=2;
/*Se define un calor de columna para empezar a capturar*/
for(j=1;j<=nc;j++)
/*Se inicia el FOR para las columnas totales*/
{
gotoxy(col,fil+i);
/*Se fijan las coordenadas de pantalla*/
scanf("%f",&a[i][j]); /*Se captura el valor de cada elemento de la matriz*/
col=col+5;
/*Se avanzan cinco espacios para la prxima columna*/
}
}
}
void egauss(float a[20][21], int n, float x[20]) /*Se declaran las variables a insertar dentro
de la funcin*/
{
int i,j,k;
/*Se declaran las variables enteras a utilizar*/
float aux; /*Se declara la variable auxiliar flotante a utilizar en la funcin*/
for(i=1;i<=n-1;i++) /*determinan las filas a operar*/
{
aux=a[i][i];
/*guarda el elemento pivote para obtener el elemento unidad*/
35
2011
for(j=i;j<=n+1;j++)
/*determina las columnas a operar*/
{
a[i][j]=a[i][j]/aux;
/*divide cada elemento de la fila entre el pivote*/
}
for(j=i+1;j<=n;j++)
/*Determina las columnas a operar*/
{
aux=a[j][i];
/*determina el pivote para operar la prxima fila*/
for(k=i;k<=n+1;k++)
{
a[j][k]=a[j][k]-a[i][k]*aux; /*resta del elemento el primero de su fila por el pivote*/
}
}
}
x[n]=a[n][n+1]/a[n][n]; /*Se divide a la columna resultado entre el pivote*/

for(i=n-1;i>=1;i--)
/*Se inicia un contador en decremento*/
{
x[i]=a[i][n+1];
/*Se localiza la columna de resultados */
for(j=i+1;j<=n;j++) /*Contador para cada resultado*/
{
x[i]=x[i]-a[i][j]*x[j]; /*Operacin para obtencin de resultado*/
}
}
void mostrar(float x[20],int n) /*Se declaran la funcin y los elementos a insertar*/

{
int i;
/*Se declara una variable entera*/
printf("\nLos resultados son:");
for(i=1;i<=n;i++)
/*Se inicia un contador para desplegar en pantalla los resultados*/
{
printf("\n x[%d]= %f",i,x[i]); /*Se presenta el elemento deseado*/
}
}
36
2011
MTODO DE GAUSS-JORDAN.
Diagrama de flujo.
Inicio
leemat(a,n,x,2,3)
n
for(i=1;i<=n;i++)
Leemat(a,n)
for(j=1;j<=n;j++)
gjordan(a,n)
a[i][j]
most(a,n)
a)
Fin
Fin
b)
for(i=1;i<=nfa;i++
)
for(j=1;j<=nfa;j++
)
c[i][j]
c)
37
Fin
2011
gjordan
Fin
for(i=1;i<n;i++)
aux=a[i][j]
for(j=1;j<=n+1;j++)
a[i][j]=a[i][j]/aux
for(j=1;j<=n+1;j++)
j!=i
aux=a[j][i]
for(k=i;k<=n+1;k++)
a[i][j]=a[j][k]-a[i][k]*aux
d)
Fi gura 12.Solucin Gauss-Jordan a )main, b)leer, c)mos tra r, d)Gauss-Jordan.
38
2011
Programa.
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"
void leermat(float [20][21],int ,int ); /*Prototipo de la funcion para leer matrices*/
void gjordan(float [20][21], int , float [20]); /*Prototipo para realizar Gauss_Jordan*/
/*Prototipo para mostrar el resultado*/
main()
{
int n;
float a[20][21], x[20];
printf("\nPROGRAMA QUE RESUELTE SISTEMAS DE ECUACIONES, MTODO GAUSSJORDAN");
printf("\nDame el numero de ecuaciones a operar ");
scanf("%d",&n);
leermat(a,n,5);
gjordan(a,n,x);
mostrar(x,n);
printf("\n\n\nPresiona una tecla para salir");
getch();
}
void leermat(float a[20][21],int n, int fil) /*Encabezado de la funcin con los valores
adquiridos desde "main"*/
{
int i, j, col, nf, nc;
/*Declara las variables a utilizar a lo largo de la
funcin*/
nf=n;
/*El nmero de filas es igual al nmero de ecuaciones*/
nc=n+1;
/*El nmero de columnas es el nmero de ecuaciones ms la
columna de resultados*/
printf("Dame la matriz aumentada");
for(i=1;i<=nf;i++)
{
col=2;
for(j=1;j<=nc;j++) /*Se inicia el FOR para las columnas totales*/
{
gotoxy(col,fil+i); /*Se fijan las coordenadas de pantalla*/
col=col+5;
}
}
}
void gjordan(float a[20][21], int n, float x[20])
{
int i,j,k;
/*Declara las variables enteras de la funcin*/
float aux;
/*Declara la funcin flotante auxiliar de la funcin*/
for(i=1;i<=n;i++) /*Declara el FOR para el recorrido de las filas*/
{
39
2011
aux=a[i][i];
/*Se determina el elemento pivote*/
for(j=i;j<=n+1;j++) /*Se coloca el FOR para contar las columnas*/
{
a[i][j]=a[i][j]/aux; /*Se divide la fila entre el elemento pivote*/
}
for(j=1;j<=n;j++) /*Se inicia un nuevo contador para cada fila*/
{
if(j!=i)
/*Condicin para operar todos los elementos diferentes al pivote*/
{
aux=a[j][i];
/*Elemento pivote*/
for(k=i;k<=n+1;k++) /*Contador para cada elemento de cada fila*/
{
a[j][k]=a[j][k]-a[i][k]*aux; /*Se resta a cada elemento, el multiplo del pivote*/
}
}
}
}
for(i=1;i<=n;i++) /*Se inicia un contador para el arreglo de resultados*/
{
x[i]=a[i][n+1]; /*Se asigna como resultado el ltimo valor de cada fila*/
}
}
void mostrar(float x[20],int n) /*Se declaran la funcin y los elementos a insertar*/

{
int i;
for(i=1;i<=n;i++)
{
printf("\n x[%d]= %f",i,x[i]); /*Se presenta el elemento deseado*/
}
}
40
2011
INVERSIN DE MATRICES
MTODO DE GAUSS-JORDAN.
Diagrama de flujo.
Inicio
leemat(a,n,x,2,3)
n
for(i=1;i<=n;i++)
Leemat(a,n)
for(j=1;j<=n;j++)
invmat(a,n)
a[i][j]
most(a,n)
Fin
a)
Fin
b)
for(i=1;i<=nfa;i++
)
for(j=1;j<=nfa;j++
)
c[i][j]
Fin
c)
41
2011
invmat
for(i=1;i<=n;i++
)
for(j=1;j<=n;j++
)
x[i][j]=a[i]
[j]
for(i=1;i<=n;i++
)
for(j=1;j<=n;j++
)
i==j
x[i][n+j]=
1.0
x[i][n+j=0
.0
for(i=1;i<=n;i++
)
aux=x[i]i]
2
for(j=i;j<=2*n;j++)
x[i][j]=x[i][j]/
aux
d)
42
2011
for(j=1;j<=n;j++)
i !=j
3
aux=x[j][i
]
for(i =1;i <=n;i ++)
for(k=j;k<=2*n;k++)
for(j=1;j<=n;j++)
aux=x[j][i
]
b[i][j]=x[i][i][j+n]
Fi gura 13.Inversion ma tri ces Gauss-Jordan a)main, b)leer, c) mos tra r, d) inversion.
Programa.
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void invmat(float [20][20] ,int ,float [20][20]);
void leermat(float [20][20] ,int ,int );
void mostrar(float [20][20] ,int ,int);
main()
{
int n;
float a[20][20], b[20][20];
printf("\nPROGRAMA PARA INVERTIR MATRICES, METODO GAUSS JORDAN");
printf("\nDame la dimension de la matriz ");
scanf("%d",&n);
leermat(a,n,5);
invmat(a,n,b);
mostrar(b,14,n);
getch();
}
void leermat(float a[20][20],int n,int fil)
{
int i,j,col,nf,nc;
nc=n;
/*El nmero de columnas es el mismo que el nmero de ecuaciones*/
nf=n;
/*El nmero de filas es el mismo que el nmero de ecuaciones*/
printf("Dame los elementos de la matriz");
for(i=1;i<=nf;i++)
/*Se inicia el contador para las filas de la matriz*/
43
{
col=2;
for(j=1;j<=nc;j++)
/*Se inicia el contador para los elementos de cada fila*/
{
gotoxy(col,fil+i);
scanf("%f",&a[i][j]);
/*Se captura el elemento deseado*/
col=col+5;
/*Se recorren 5 espacios a lo largo de la fila*/
}
}
void invmat(float a[20][20],int n,float b[20][20])

{
int i,j,k;
float aux, x[20][40];
for(i=1;i<=n;i++) /*Se inicia un contador para las filas*/
{
for(j=1;j<=n;j++) /*Se inicia un contador para las columnas*/
{
x[i][j]=a[i][j]; /*se translada cada elemento a la matriz a*/
}
}
{
{
if(i==j)
/*Condicin para cuando el elemento esta en la diagonal*/
{
x[i][n+j]=1.0; /*Coloca 1.0 en la diagonal*/
}
else
{
x[i][n+j]=0.0; /*Coloca 0.0 en tringulo superior e inferior*/
}
}
}
for(i=1;i<=n;i++) /*Contador para las filas*/
{
aux=x[i][i];
/*Se seleciona el elemento pivote*/
for(j=1;j<=2*n;j++) /*Opera todos las columnas de cada fila*/
{
x[i][j]=x[i][j]/aux; /*Divide a cada elemento entre el pivote*/
}
for(j=1;j<=n;j++) /*Se inicia el contador para las columnas*/
{
if(i!=j)
/*Condicin para no operar el elemento de diagonal*/
{
aux=x[j][i];
/*se toma el elemento de esta rutina*/
44
2011
2011
for(k=i;k<=2*n;k++) /*Se inicia un contador para las columnas*/

{
x[j][k]=x[j][k]-x[i][k]*aux; /*Se resta el AUX junto al elemento de la rutina al propio
elemento de la rutina*/
}
}
}
}
{
{
b[i][j]=x[i][j+n]; /*Se guardan los elementos de la matriz invertida en el arreglo B*/
}
}
}
void mostrar(float b[20][20],int fil, int n)
{
int i,j,col,col1,fil1,nfa,ncb; /*Se declaran las variables a utilizar*/
col=2;
nfa=n;
ncb=n;
gotoxy(col,fil);
printf("Matriz Invertida");
for(i=1;i<=nfa;i++) /*Se inicia el contador para las filas*/
{
fil1=fil+2*i;
/*Ecuacin de incremento en las filas*
for(j=1;j<=ncb;j++) /*Se inicia el contador par alas columnas*/
{
col1=col+10*j;
/*ecuacin para el increment de las columnas*/
gotoxy(col1,fil1); /*Posicionamiento del resultado*/
printf("%f",b[i][j]); /*Muestra en pantalla el resultado*/
col1=col1+10;
}
}
}
45
2011
SOLUCIN DE ECUACIONES LINEALES (Mtodos iterativos).

MTODO ITERATIVO DE GAUSS.
Diagrama de flujo.
Inicio
leemat(a,n,x,2,3)
n
for(i=1;i<=n;i++)
Leemat(a,n)
for(j=1;j<=n;j++)
itegau(a,n)
a[i][j]
most(a,n)
Fin
a)
Fin
b)
for(i=1;i<=nfa;i++
)
for(j=1;j<=nfa;j++
)
c[i][j]
c)
46
Fin
2011
i tegau(a ,n)
for(i =1;i <=n;i ++)
for(j=1;j<=n+1;j++)
b[i][j]=a[i ][j]
for(i =1;i <=n;i ++)
aux=a [i][j]
for(j=1;j<=n;j++)
i ==j
b[i][j]=b[i][n+1]/aux
b[i][j]=-b[i ][j]/aux
for(j=1;j<=n;j++)
Xs [i]=-b[i][j]
d)
47
2011
1
for(j=1;j<=n;j++)
for(j=1;j<=n;j++)
Xc[i]=b[j][j]
for(k=1;k<=n;k++)
i !=k
Xc[j]=Xc[j]+b[j][k]*Xs [k]
ban=1
for(j=1;j<=n;j++)
|Xc[j]-Xs[j]|>Eps
ban=o
brea k
48
2011
ban==1
El sistema
converge
for(j=1;j<=n;j++)
mos tvec
Xs [j]=Xc[j]
return(1)
Break,
ban==0
El sistema
no converge
Return(0)
Fin
Fi gura 14.Metodo i tera ti vo de Gauss. a) main, b) leer, c) mostra r, d)i tera ti vo.
49
2011
Programa.
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"
#include "math.h"
int itegau(float [20][21], int , float [20] , float , int, float [20]);
void leemat(float [20][21], int , int);
main()
{
int n,nit;
float eps, a[20][21], x[20],xs[20];
printf("Solucion de ecuaciones, Metodo iterativo");
printf("\nDame el numero de ecuaciones a resolver ");
scanf("%d",&n);
printf("\nDame la tolerancia permitida: ");
scanf("%f",&eps);
printf("\nDame el maximo de iteraciones permitidas: ");
scanf("%d",&nit);
clrscr();
printf("\nDame la matriz aumentada: ");
leemat(a, n, 4);
clrscr();
itegau( a, n, x, eps, nit, xs);
printf("\n\nPresiona una tecla para salir");
getch();
}
void leemat(float a[20][21], int n, int fil)
{
int i,j,col;
/*Se declaran las variables enteras a utilizar*/
for(i=1;i<=n;i++)
/*Se inicia un contador para las filas*/
{
col=2;
for(j=1;j<=n+1;j++) /*Se inicia un contador par alas columnas*/
{
gotoxy(col,i+fil); /*Posicionamiento de la captura*/
scanf("%f",&a[i][j]); /*Captura en a la localidad de memoria*/
col=col+10; /*incremento de la columna por iteracin*/
}
}
}
int itegau(float a[20][21], int n, float x[20], float eps, int nit, float xs[20])
{
int i, j, k, ban;
/*Se declaran las variables enteras*/
float aux, b[20][21], xc[20],xs1[20]; /*Se declaran las variables flotantes*/
50
2011
for(i=1;i<=n;i++) /*se inicia un contador par alas filas*/

{
for(j=1;j<=n+1;j++) /*Se inicia un contador para las columnas*/
{
b[i][j]=a[i][j];
/*Se translada cada valor capturado a a la matriz b.
}
}
for(i=1;i<=n;i++) /*contador para cada fila*/
{
aux=b[i][i];
/*Se define al elemento pivote*/
for(j=1;j<=n;j++) /*Se inicia el contador para las columnas*/
{
if(i==j)
/*condicin para evitar al element pivote*/
{
b[i][j]=b[i][n+1]/aux; /*Se divide cada elemento entre el povite*/
}
else
{
b[i][j]=-b[i][j]/aux;
/*Si el elemento se invierte el signo*/
}
}
}
for(i=1;i<=n;i++)
/* se inicia un contador para las filas*/
{
xs[i]=b[i][i];
/*se elige al elemento pivote en cada ecuacin*/
}
for(i=1;i<=nit;i++)
/*Se inicia contador de filas hasta las iteraciones*/
{
for(j=1;j<=n;j++)
/*Se inicia el contador para las columnas*/
{
xc[j]=b[j][j];
/*Se toma el valor obtenido como pivote*/
for(k=1;k<=n;k++) /*se inicia un contador para las operaciones*/
{
if(j!=k)
/*Se evita al element identico*/
{
xc[j]=xc[j]+b[j][k]*xs[k];
/*Se realiza la operacin del elemento calculado*/
}
}
}
ban=1;
/*Condicin para comprobar convergencia del sistema*/
for(j=1;j<=n;j++)
/*Se inicia contador para cada elemento calculado*/
{
if(fabs(xc[j]-xs[j])>eps) /*Se compara con el error*/
{
ban=0;
/*Se cambia la condicin para comprobar la convergencia*/
break;
/*Termina la condicin if*/
}
}
if(ban==1)
/*Determina la convergencia del sistema*/
51
2011
{
clrscr();
/*Limpia la pantalla*/
printf("\nEl sistema converge");
mostrar(xs,n);
/*Llama la funcin para mostrar los resultados obtenidos*/
return(1);
/*Devuelve 1*/
break;
/*Termina la condicin if*/
}
Else
/*Evalua cuando no se cumple la condicin de error*/
{
for(j=1;j<=n;j++)
/*Inicia un contador para cada Xc*/
{
xs[j]=xc[j];
/*Transforma los valores calculados a supuestos o iniciales*/
}
}
}
if(ban==0)
/*Evalua la condicin de convergencia despues de n iteraciones*/
{
clrscr();
/*Limpia pantalla*/
printf("El sistema no converge");
return(0);
/*Devuelve el valor cero*/
}
}
void mostrar(float xc[20],int n) /*Se declaran la funcin y los elementos a insertar*/
{
int i;
for(i=1;i<=n;i++)
{
printf("\n xc[%d]= %f",i,xc[i]); /*Se presenta el elemento deseado*/
}
}
52
2011
MTODO ITERATIVO DE GAUSS-SEIDEL.

Diagrama de flujo.
Inicio
leemat(a,n,x,2,3)
n
for(i=1;i<=n;i++)
Leemat(a,n)
for(j=1;j<=n;j++)
seidel(a,n)
a[i][j]
most(a,n)
Fin
a)
Fin
b)
for(i=1;i<=nfa;i++
)
for(j=1;j<=nfa;j++
)
c[i][j]
c)
53
Fin
2011
seidel(a ,n)
for(i =1;i <=n;i ++)
for(j=1;j<=n+1;j++)
b[i][j]=a[i ][j]
for(i =1;i <=n;i ++)
aux=b[i ][j]
for(j=1;j<=n;j++)
i ==j
b[i][j]=b[i][n+1]/aux
b[i][j]=-b[i ][j]/aux
for(j=1;j<=n;j++)
Xs [i]=-b[i][j]
Xs 1[i]=xs [i]
d)
54
2011
1
for(j=1;j<=n;j++)
for(j=1;j<=n;j++)
Xc[i]=b[j][j]
for(k=1;k<=n;k++)
Xs [j]=xc[j]
i !=k
Xc[j]=Xc[j]+b[j][k]*Xs [k]
ban=1
for(j=1;j<=n;j++)
2
|Xc[j]-Xs 1[j]|>Eps
ban=o
brea k
55
2011
ban==1
for(j=1;j<=n;j++)
El sistema
converge
Xs [j]=Xc[j]
Xs [j]=xc[j]
mos tvec
return(1)
Break,
3
4
ban==0
El sistema
no converge
Return(0)
Fi n
Fi gura 15.Mtodo Gauss-Seidel , a) main, b) leer, c) mostra r y c) Gauss-Seidel .
56

Programa.
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"
#include "math.h"
int seidel(float [20][21], int , float [20] , float , int, float [20]);
void leemat(float [20][21], int , int);
main()
{
int n,nit;
float eps, a[20][21], x[20],xs[20];
printf("Solucion de ecuaciones, Metodo iterativo");
printf("\nDame el numero de ecuaciones a resolver ");
scanf("%d",&n);
printf("\nDame la tolerancia permitida: ");
scanf("%f",&eps);
printf("\nDame el maximo de iteraciones permitidas: ");
scanf("%d",&nit);
clrscr();
printf("\nDame la matriz aumentada: ");
leemat(a, n, 4);
clrscr();
seidel( a, n, x, eps, nit, xs);
printf("\n\nPresiona una tecla para salir");
getch();
}
void leemat(float a[20][21], int n, int fil)
{
int i,j,col;
for(i=1;i<=n;i++)
{
col=2;
for(j=1;j<=nc;j++) /*Se inicia el FOR para las columnas totales*/
{
gotoxy(col,fil+i); /*Se fijan las coordenadas de pantalla*/
col=col+5;
}
}
}
int seidel(float a[20][21], int n, float x[20], float eps, int nit, float xs[20])
{
int i, j, k, ban;
/*Se declaran las variables enteras*/
float aux, b[20][21], xc[20],xs1[20];
/*Se declaran las variables flotantes*/
57
2011
for(i=1;i<=n;i++)
/*se inicia el contador para las filas*/
{
for(j=1;j<=n+1;j++)
/*Se inicia el contador para las columnas*/
{
b[i][j]=a[i][j];
/*Transfiere cada valor a a la matriz b*/
}
}
for(i=1;i<=n;i++)
/*inicia el contador para las filas*/
{
aux=b[i][i];
/*localiza al elemento pivote*/
for(j=1;j<=n;j++)
/*Inicia el contador para las columnas*/
{
if(i==j)
/*condicin para el elemento pivote*/
{
b[i][j]=b[i][n+1]/aux; /*divide al ltimo de la matriz aumentada entre pivote*/
}
else
{
b[i][j]=-b[i][j]/aux;
/*divide entre pivote y cambia de signo*/
}
}
}
for(i=1;i<=n;i++)
/*inicia un contador para los elementos supuestos*/
{
xs[i]=b[i][i];
/*elemento supuesto igual al pivote*/
xs1[i]=xs[i];
/*supuesto 1 (auxiliar) igual a supuesto*/
}
for(i=1;i<=nit;i++) /*inicia contador para las filas*/
{
for(j=1;j<=n;j++) /*inicia contador para las columnas*/
{
xc[j]=b[j][j];
/*identifica al valor calculado*/
for(k=1;k<=n;k++) /*inicia contador para cambio en la operacin*/
{
if(j!=k)
/*evita al elemento pivote*/
{
xc[j]=xc[j]+b[j][k]*xs[k]; /*realize la operacin de despeje*/
}
}
xs[j]=xc[j];
/*el supuesto es igual al calculado*/
}
ban=1;
/*referencia para determiner convergencia*/
for(j=1;j<=n;j++)
/*inicia contador para valores a comparer en error*/
{
if(fabs(xc[j]-xs1[j])>eps) /*condicin para satisfacer el margen de error*/
{
ban=0;
/*cambio de referencia para determinar convergencia*/
break;
/*termina la condicin if*/
}
58
2011
2011
}
if(ban==1)
/*determina si converge o no el sistema*/
{
clrscr();
/*limpia la pantalla*/
mostrar(xs,n);
/*muestra el arreglo con los resultados*/
return(1);
/*devuelve 1 */
break;
/*termina la condicin if*/
}
else
/condicin sin cambio de referencia*/
{
for(j=1;j<=n;j++) /*inicia contador para cambiar los valores supuestos*/
{
xs[j]=xc[j];
/*cada supuesto es igual al calculado*/
xs1[j]=xs[j];
/*cada supuesto 1(auxiliary) igual al supuesto*/
}
}
}
if(ban==0)
/*condicin para el trmino del nmero de interaciones*/
{
clrscr();
/*limpia pantalla*/
printf("El sistema no converge");
return(0);
/*devuelve cero*/
}
}
void mostrar(float xc[20],int n) /*Se declaran la funcin y los elementos a insertar*/
{
int i;
for(i=1;i<=n;i++)
{
printf("\n xc[%d]= %f",i,xc[i]); /*Se presenta el elemento deseado*/
}
}
59
2011
SOLUCIN DE SISTEMAS DE ECUACIONES NO LINEALES.

MTODO DE NEWTON-RAPHSON.
Diagrama de flujo.
Ini cio
#include conio.h
#include s tdlib.h
#include ma th..h
#include s tdio.h
#define f1(x1.x2)(x2*x2*2-4.0*x1-4.0)
#define f2(x1,x2)(2-0*x2,-x1-2.0)
#define df1(x1.x2)(-4.0)
#define df1x1(x1,x2)(2.0*x2)
#define df2x1(x1,x2)(-1.0)
#define df2x2(x1,x2)(2.0)
n,nit,Eps
leevec(y,n,y,2,z)
leevec(x,n,x,20,2)
S=t
It=0
While(s ==t&&i t<ni

t)
S!=1
El sistema
no
converge
a[1][3]=y[1]-f1(x[1],x[2])
a[2][3]=y[2]-f2(x[1],x[2])
a[1][1]=df1x1(x[1],x[2])
a[1][2]=df1x2(x[1],x[2])
a[2][1]=df2x1(x[1],x[2])
a[2][2]=df2x2)x[1],x[2])
egauss
Fi n
S!=0
60
2011
for(i=1;i<=n;i++)
|dx[i]>Eps
S!=1
Break;
S!==0
It=it+1
El sistema
converge
for(j=1;j<=n;j++)
Mostvec(x,n,x,20,2)
X[j]=x[j]+jx[j]
S=f
61
egauss
For(i=1;i <=n;i ++)
aux=a [i][i]
for(j=1;j<=n+1;j++)
a[i ][j]=a [i][j]/au

x
for(j=i+1;j<=n;j++)
aux=a [j][i]
for(k=1;k<=n+1;k++)
a[j][k]=a[j][k]a[j][k]*aux
x[n]=a[n][n+1]/a[n][n]
for(k=1;k<=n+1;k++)
x[i]=a [i][n+1]
Fi n
for(j=i+1;j<=n;j++)
x[i]=x[i ]-a [i][j]*x[j]

Fi gura 16.Solucin de ecuaciones no Li neales Ne wton Raphson.
62
2011
2011
Programa.
#include "conio.h"
#include "stdlib.h"
#include "math.h"
#include "stdio.h"
#define f1(x1,x2)((x2*x2)-(4.0*x1)-4.0) /*define la funcin 1 a trabajar*/
#define f2(x1,x2)((2.0*x2)-x1-2.0)
/*define la funcin 2 a trabajar*/
/*define la derivada de f1 respecto a x*/
#define df1x2(x1,x2)(2.0*x2)
/*define la derivada de f1 respecto a y*/
/*define la derivada de f2 respecto a x*/
#define df2x2(x1,x2)(2.0)
/*define la derivada de f2 respecto a y*/
void leevec(int , float [20] );
/*declara la funcion de leervector*/
void gjordan(float [5][6], int , float [5]);
/*declara la function de gaussjordan*/
void mostrar(float dx[5],int n);
/*declara la funcin de mostrar vector*/
main()
{
int n, nit, it, i ,s, s1, j;
/*declara las variables enteras a trabajar*/
float eps, x[5], y[5], a[5][6], dx[5];
/*declara las variables flotantes a trabajar*/
printf("\nSolucion de Ecuaciones No Lineales");
printf("\nDame el numero de ecuaciones a trabajar ");
scanf("%d",&n);
printf("\nDame el numero maximo de iteraciones ");
scanf("%d",&nit);
printf("\nDame el margen de error: ");
scanf("%f",&eps);
clrscr();
printf("\nDame los valores Y de tu ecuacin");
leevec(n, y);
printf("\nDame los valores iniciales X de tu ecuacin");
leevec(n, x);
s='t';
it=0; /*vacia el valor de interaciones*/
while(s=='t'&& it<nit)
/*ciclo while para controlar las iteraciones y error satisfecho*/
{
a[1][3]=y[1]-f1(x[1],x[2]);
/*determina la operacin para el primer resultado*/
a[2][3]=y[2]-f2(x[1],x[2]);
/*determina la operacin para el segundo resultado*/
a[1][1]=df1x1(x[1],x[2]);
/*determina la operacin de primer localidad de la matriz*/
a[1][2]=df1x2(x[1],x[2]);
/*determina la operacin de segund localidad de la matriz*/
a[2][1]=df2x1(x[1],x[2]);
/*determina la operacin de tercer localidad de la matriz*/
a[2][2]=df2x2(x[1],x[2]); /*determina la operacin de cuarta localidad de la matriz*/
gjordan(a, n, dx);
/*resuelve la matriz aumentada*/
s1=0;
/*define elemento para detectar el error*/
for(i=1;i<=n;i++) /*inicia contador para cada resultado*/
{
if(fabs(dx[i])>eps) /*compara el margen de error*/
{
s1=1;
/*cambia el valor para mostrar resultados*/
break;
/*termina ciclo if*/
}
}
63
if(s1==0)
/*si el margen de error se satisface*/
{
mostrar(dx,n); /*muestra el conjunto de resultados*/
s='f';
/*cambia el valor inicial de referencia while*/
}
else
/*si el margen de error no se cumple*/
{
it=it+1;
/*incrementa el valor de interacin/
for(j=1;j<=n;j++) /*inicia el contador para cada resiltado*/
{
x[j]=x[j]+dx[j];
/*se realiza el incremento a los valores iniciales*/
}
}
}
if(s1==1) /*condicin para el trmino de iteraciones en while*/
{
printf("\nEl sistema no converge");
}
getch();
/*detiene pantalla*/
void leevec(int n, float y[20])

{
int i;
for(i=1;i<=n;i++)
{
printf("\n[%d]= ",i);scanf("%f",&y[i]);
}
}
void gjordan(float a[5][6], int n, float dx[5])
{
int i,j,k;
float aux;
{
aux=a[i][i];
{
}
{
if(j!=i)
{
aux=a[j][i];
/*Elemento pivote*/
64
2011
2011

{
}
}
}
}
{
dx[i]=a[i][n+1]; /*printf("\n dx[%d]= %f",i,dx[i]);*/ /*Se asigna como resultado el ltimo
valor de cada fila*/
}
void mostrar(float dx[5],int n) /*Se declaran la funcin y los elementos a insertar*/

{
int i;
for(i=1;i<=n;i++)
{
printf("\ndx[%d]= %f",i,dx[i]); /*Se presenta el elemento deseado*/
}
}
65
2011
AJUSTE DE CURVAS.
MTODO DE MNIMOS CUADRADOS.
Diagrama de flujo.
Inicio
n
Leemat(a,n)
Leemat(a,n)
for(i=1;i<=n;i++)
mincua(a,n)
most(a,n)
a[i]
Fin
a)
b)
most(a,n)
For(i=1;i<=n;i++)
a[i]
Fin
c)
66
Fin
2011
mi ncua(a ,n)
for(i =1;i <=2*n+1;i ++)
sumx[i ]=0.0
for(j=1;j<=m;j++)
sumx[i ]=sumx[i ]+pow(x[j],i -1)
for(i =1;i <=n+1;i ++)

for(i =1;i <=n+1;i ++)
sumxy[i]=0.0
s x[i][n+2]=sumxy[i ]
for(j=1;j<=m;j++)
for(i =1;i <=n+1;i ++)
K=i
sumxy[i]=sumxy[i ]+pow(x[j],i1)*y[j]
for(j=1;j<=n+1;j++)
s x[i][j]=sumx[k]
K=k+1
d)
Ega uss(sx,n+1,a)
Fi gura 17.Mni mos cuadrados, a) main, b)leer c) mos tra r d) Mnimos cuadrados .
67
2011
Programa.
#include "conio.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
void mincua(float [20], float [20], int , int , float [20]);
void gjordan(float [20][21], int , float [20]);
void leermat(float [20],int );
main()
{
int n, m;
float x[20],y[20], a[10];
printf("\nAjuste de curvas: Minimos cuadrados");
printf("\nDame el grado de polinomio a trabajar ");
scanf("%d",&n);
printf("\nDame el numero de puntos a trabajar ");
scanf("%d",&m);
clrscr();
printf("\nDame los elementos X de la lista\n");
leermat(x, m);
printf("\nDame los elementos Y de la lista\n");
leermat(y, m);
mincua(x, y, m, n, a);
mostrar(a, n+1);
getch();
}
void leermat(float a[20],int n) /*Encabezado de la funcin con los valores adquiridos desde
"main"*/
{
int i;
/*Declara las variables a utilizar a lo largo de la funcin*/
for(i=1;i<=n;i++)
{
scanf("%f",&a[i]); /*Se captura el valor de cada elemento de la matriz*/
}
}
void mincua(float x[20], float y[20], int m, int n, float a[20])
{
int i, j, k;
/*se declaran las variables enteras*/
float sumx[20], sumxy[20], sx[20][21]; /*se declaran las variables flotantes*/
for(i=1;i<=2*n+1;i++)
/*inicia contador para las sumatorias*/
{
sumx[i]=0.0;
/*iguala a cero el valor de sumx*/
for(j=1;j<=m;j++)
/*inicia contador para los puntos dados a trabajar+/
{
sumx[i]=sumx[i]+pow(x[j],i-1); /*sumatoria para elementos solos*/
68
2011
}
for(i=1;i<=n+1;i++) /*contador para la sumatoria de elementos multiplicados*/
{
sumxy[i]=0.0;
/*inicia en cero la sumatoria*/
for(j=1;j<=m;j++) /*contador para trabajar todos los puntos dados*/
{
sumxy[i]=sumxy[i]+(pow(x[j],i-1))*y[j]; /*inicia la sumatoria de elementos*/
}
}
for(i=1;i<=n+1;i++) /*inicia contador para la formacin de matriz de sumatorias*/
{
sx[i][n+2]=sumxy[i]; /*coloca cada valor de sumatoria de numeros multiplicados*/
}
for(i=1;i<=n+1;i++) /*inicia contador para filas dentro de la matriz*/
{
k=i;
for(j=1;j<=n+1;j++) /*inicia contador columnas dentro de la matriz*/
{
sx[i][j]=sumx[k]; /*coloca cada elemento dentro de localidad correspondiente*/
k=k+1;
}
}
gjordan(sx, n+1, a); /*resuelve la matriz aumentada*/
}
void gjordan(float a[20][21], int n, float x[20])
{
int i,j,k;
float aux;
{
aux=a[i][i];
{
}
{
if(j!=i)
{
aux=a[j][i];
/*Elemento pivote*/
{
}
}
}
}
69
2011

{
x[i]=a[i][n+1]; /*Se asigna como resultado el ltimo valor de cada fila*/
}
}
void mostrar(float r[20],int n) /*Se declaran la funcin y los elementos a insertar*/
{
int i;
/*Se declara una variable entera para el contador*/
printf("\n\n\nLos coeficientes del polinomio son : ");
for(i=1;i<=n;i++)
{
printf("\na[%d]=%f",i-1,r[i]); /*Se presenta el elemento deseado*/
}
}
70
2011
INTERPOLACIN POR MTODO DE LAGRANGE.

Diagrama de flujo.
Inicio
Leemat(x,n)
Leemat
Leemat(y,n)
for(i=1;i<=n;i++)
Lagrange(x,y,n,,pol)
a[i]
most(pol,n)
Fin
Fin
a)
b)
most
For(i=1;i<=n;i++)
a[i]
Fin
c)
71
2011
Lagrange
for(i=1;i<=n;i++)
f[1]=1.0
for(j=1;j<=n+1;j++)
i!=j
f(i)=f[i]*(x[i]-x[i])
f[1]=y[i]/f[i]
for(i=1;i<=n;i++)
K=1
for(j=1;j<=n;j++)
i!=j
V[k]=j
K=k+1
d)
72
2011
1
for(j=1;j<=n;j++)
forkj=1;k<=n;k++)
p[j][k]=0
.0
forkj=1;k<=n;k++)
V1[k]=0.0
V2[k]=0.0
V3[k]=0.0
V1[1]=0.0
V1[2]=V[1]
for(k=2;k<=n-1;k++)
for(k=2;k<=n-1;k++)
for(l =2;l <=n;l ++)
V2[l+1]=v1[l]*(-x[v[k]])
p[i][i ]=v1[l]*f[i ]
for(l=2;l<=n;l++)
V3[l]=v1[l]+v2[
l]
73
for(l=1;l<=k+1;l++)
V1[l]=v1[l]
V2[l]=0.0
For(l=1;l<=n;l++)
Fin
Pol[l]=0.0
For(k=1;k<=n;k++)
Pol[l]=pol[l]+p[k][l]
Fi gura 18.Interpola cin de Lagra nge a) main, b) leer, c) mos tra r, d) Lagra nge.
74
2011
2011
Programa.
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"
void leermat(float a[20],int n);
void lagrange(float x[20], float y[20], int n, float [20]);
main()
{
int n;
float x[20], y[20], pol[20];
printf("\nInterpolacion de curvas, Metodo de Lagrange");
printf("\nDame el nmero de puntos a trabajar");
scanf("%d",&n);
printf("\nDame el conjunto de puntos de x: ");
leermat(x,n);
printf("\nDame el conjunto de puntos de y: ");
leermat(y,n);
lagrange( x, y, n, pol);
mostrar(pol , n);
}
void leermat(float a[20],int n) /*Encabezado de la funcin con los valores adquiridos desde
"main"*/
{
int i;
/*Declara las variables a utilizar a lo largo de la funcin*/
for(i=1;i<=n;i++)
{
scanf("%f",&a[i]); /*Se captura el valor de cada elemento de la matriz*/
}
}
void lagrange(float x[20], float y[20], int n, float pol[20])
{
int i,j, k, l;
float f[20], p[20][20], v[20], v1[20],v2[20],v3[20]; /*declara las variables flotantes*/
for(i=1;i<=n;i++)
/*inicia contador para primer elemento dentro de operaciones+/
{
f[i]=1.0;
/*inicia la operacin en cero*/
for(j=1;j<=n;j++) /*contador para segundo elemento dentro de operaciones*/
{
if(i!=j)
/*evita restar dos nmeros iguales*/
{
f[i]=f[i]*(x[i]-x[j]);
/*operacines para denominador*/
}
}
f[i]=y[i]/f[i]; /*divide ultimo valor entre operacin realizada
75

}
for(j=1;j<=n;j++) /*inicia contador para las filas*/
{
for(k=1;k<=n;k++)
/*inicia contador para las columnas*/
{
p[j][k]=0.0;
/*cada elemento de p igual a cero*/
}
}
for(i=1;i<=n;i++)
{
k=1;
for(j=1;j<=n;j++)
{
if(i!=j)
{
v[k]=j;
k=k+1;
}
}
for(j=1;j<=n;j++)
{
for(k=1;k<=n;k++)
{
p[i][j]=0.0;
}
}
for(k=1;k<=n;k++)
{
v1[k]=0.0;
v2[k]=0.0;
v3[k]=0.0;
}
v1[1]=1.0;
v1[2]=-(x[v[1]]);
for(k=2;k<=n-1;k++)
{
for(l=1;i<=k;l++)
{
v2[l+1]=v1[l]*(-x[v[k]]);
}
for(l=1;l<=k+1;l++)
{
v3[l]=v1[l]+v2[l];
}
for(l=1;l<=k+1;l++)
{
v1[l]=v3[l];
v2[l]=0.0;
76
2011
2011
v3[l]=0.0;
}
}
}
for(l=1;l<=n;l++) /*inicia contador para las columnas de p y elemento de pol*/
{
pol[l]=0.0; /*inicia cada elemento de pol en cero*/
for(k=1;k<=n;k++) /*contador para las filas del arreglo*/
{
pol[l]=pol[l]+p[k][l]; /*realiza la suma del elemento anterior mas uno del arreglo p*/
}
}
}
void mostrar(float r[20],int n) /*Se declaran la funcin y los elementos a insertar*/
{
int i;
/*Se declara una variable entera para el contador*/
printf("\n\n\nLos coeficientes del polinomio son : ");
for(i=1;i<=n;i++)
{
printf("\na[%d]=%f",i-1,r[i]); /*Se presenta el elemento deseado*/
}
}
77
2011
SOLUCIN DE ECUACIONES DIFERENCIALES.

METODO DE EULER.
Diagrama de flujo.
euler
Inicio
Xo,Yo,h
x[1]=x0;
y[1]=y0;
euler
for(i=1;i<=n;i++)
Most(x,nx)
y[i+1]=y[i]+dydx(x[i],y[i])*h;
x[i+1]=x[i]+h;
Most(y,ny)
Fin.
a)
Fin
b)
most
For(i=1;i<=n;i++)
a[i]
Fin
c)
Fi gura 19.Metodo de Euler, a)main, b) euler, c) mos tra r.
78
2011
Programa.
#include<stdio.h>
#include<conio.h>
#define dydx(x,y)(4*(exp(0.8*x))-(0.5*y)) /*Define la funcin a trabajar*/
void most(float [50], int, char [5], int, int);
void euler(float [50], float [50], int, float, float, float);
main()
{
int n;
float x0, y0, h, x[50], y[50];
gotoxy(2,1);printf("Ingresa el numero de puntos a calcular= ");scanf("%d",&n);
gotoxy(2,3);printf("Valor inicial de x= ");scanf("%f",&x0);
gotoxy(2,5);printf("Valor inicial de y= ");scanf("%f",&y0);
gotoxy(2,7);printf("Ingresa el valor del incremento en x= ");scanf("%f",&h);
euler(x,y,n,x0,y0,h);
gotoxy(36,9);printf("Lista de puntos evaluados");
most(x,n,"x",2,11);
most(y,n,"y",20,11);
return 0;
void euler(float x[50], float y[50], int n, float x0, float y0, float h)
{
int i;
x[1]=x0;
/*asigna el valor inicial de x*/
y[1]=y0;
/*asigna el valor inicial de y*/
for(i=1;i<=n;i++)
/*inicia el contador para operaciones*/
{
/*obtiene el valor proximo de y*/
x[i+1]=x[i]+h;
/*obtiene el valor proximo de x*/
}
}
void most(float a[50], int n, char nom[5], int col, int fil)
{
int i;
/*variable entera*/
gotoxy(col,fil);
for(i=1;i<=n;i++)
/*inicia el contador para colocar*/
{
printf("%s[%d] = %f",nom,i,a[i]); /*muestra en pantalla*/
gotoxy(col,fil+i);
/*posicionamiento en pantalla*/
}
}
79
2011
MTODO MODIFICADO DE EULER.

Diagrama de flujo.
Ini cio
Xo,Yo,h, i t
mos t
eulermod
For(i=1;i <=n;i ++)
Mos t(x,nx)
a[i ]
Mos t(y,ny)
Fi n.
a)
Fi n
b)
euler
x[1]=x0;
y[1]=y0;
for(i=1;i<=n;i++)
x[i+1]=x[i]+h;
for(j=1;j<=n;j++)
g=dydx(x[i],y[i]);
f=dydx(x[i]+h,yp[j]);
yp[j+1]=y[i]+((dydx(x[i],y[i])+dydx((x[i]+h),yp[j]))/2)*h;
y[i+1]=yp[it+1];
x[i+1]=x[i]+h;
c)
Fin
Fi gura 20.Metodo de euler modi ficado, a) main, b) mos tra ry c) eulermodi ficado
80
2011
Programa.
#include<stdio.h>
#include<conio.h>
#include<math.h>
#define dydx(x,y)(4*(exp(0.8*x)) -(0.5*y))
void most(float [50], int, char [5], int, int);
void eulermod(float [50], float [50], int, float, float, float, int);
main()
{
int n, it;
float x0, y0, h, x[50], y[50];
gotoxy(2,1);printf("Ingresa el numero de puntos a calcular= ");scanf("%d",&n);
gotoxy(2,3);printf("Valor inicial de x= ");scanf("%f",&x0);
gotoxy(2,5);printf("Valor inicial de y= ");scanf("%f",&y0);
gotoxy(2,7);printf("Ingresa el valor del incremento en x= ");scanf("%f",&h);
gotoxy(2,9);printf("Numero de iteraciones para cada calculo= ");scanf("% d",&it);
eulermod(x,y,n,x0,y0,h,it);
gotoxy(36,11);pri ntf("Lista de puntos evaluados");
most(x,n,"x",2,13); most(y,n,"y",20,13);
return 0;
void eulermod(float x[50], float y[50], int n, float x0, float y0, float h, int it)
{
int i,j,k;
/*variables enteras */
float yp[50],f,g;
/*variables flotantes*/
x[1]=x0;
/*asigna el valor inicial de x*/
y[1]=y0;
/*asigna el valor inicial de y*/
for(i=1;i<=n;i++)
/*contador para valores de y*/
{
k=1;
/*inicia cada interacion*/
yp[1]=y[i]+dydx(x[i],y[i])*h;
/*calcula valor de y*/
for(j=1;j<=it;j++)
/*contador para las iteraciones*/
{
g=dydx(x[i],y[i]);
/*calcula funcion evaluada*/
f=dydx(x[i]+h,yp[j]);
/*evalua la funcion con y calculada*/
yp[j+1]=y[i]+((dydx(x[i],y[i])+dydx((x[i]+h),yp[j]))/2)*h; /*yp*/
}
y[i+1]=yp[it+1];
/*valor proximo de y*/
x[i+1]=x[i]+h;
/*valor proximo de x*/
}
}
void most(float a[50], int n, char nom[5], int col, int fil)
{
int i;
/*variable entera*/
gotoxy(col,fil);
for(i=1;i<=n;i++)
/*inicia el contador para colocar*/
{
printf("%s[%d] = %f",nom,i,a[i]); /*muestra en pantalla*/
gotoxy(col,fil+i);
/*posicionamiento en pantalla*/
}
}
81
2011
MTODO DE RUNGE KUTTA.

Diagrama de flujo.
rkutta(a,b,Yo,n)
Xo=a;
Yo=n;
for(i=1;i<=n;i++)
k1=f1(x0,y0);
x1=x0+(h/2);y1=y0 +(k1*h/2);
k2=f1(x1,y1);
x2=x1; y2=y0+(k2 *h/2);
k3=f1(x2,y2);
x3=x0+h; y3=y0 +(h*k3);
k4=f1(x3,y3);
yn=y0+((h/6)*(k1+2 *k2+2 *k3+k4));
y0=yn; x0=x3;
Inicio
X[i]=x3;
Y[i]=yn;
a,b,y n
rkutta
Fin
Fin.
a)
b)
Fi gura 21.solucin por Runge kutta : a) main, b) rkutta .
82
2011
Programa.
#include "conio.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#define f1(x1,x2)(4*(exp(0.8*x1))-(0.5*x2)) /*funcion: y'=4*e^(0.8*x)-(0.5*y)*/
void rkutta(float , float , float , int );
main()
{
int n;
float a, b, y;
printf("\n\tSolucion de Ecuaciones Diferenciales");
printf("\n\n\t\tMetodo de Runge-Kutta");
printf("\n\nDame el valor X inicial a trabajar: ");
printf("\n\tXo: ");scanf("%f",&a);
printf("\nDame el valor X final a trabajar: ");
printf("\n\tXf: ");scanf("%f",&b);
printf("\nDame el valor inicial de Y: ");
printf("\n\tYo: ");scanf("%f",&y);
printf("\nDame el numero de iteraciones a trabajar: ");
scanf("%d",&n);
rkutta(a,b,y,n);
printf("\n\n\nPresiona una tecla para salir"); getch();
}
void rkutta(float a, float b, float y, int n)
{
int i, col, fil;
/*variables enteras*/
float h, x0, x1,x2,x3,k1,k2,k3,k4,y0,y1,y2,y3,yn; /*variables flotantes*/
h=(b-a)/n;
/*calcula el incremento*/
x0=a; y0=y;
/*asigna los valores iniciales de X y Y*/
col=6; fil=6;
/*inicia las columnas y filas*/
clrscr();
/*limpia pantalla*/
gotoxy(4,4);printf("Tu tabla de resultados es:");
for(i=1;i<=n;i++)
/*contador para las operaciones*/
{
k1=f1(x0,y0);
/*calcula la primer constante*/
x1=x0+(h/2);y1=y0+(k1*h/2);
/*prox valor de X en K2*/
k2=f1(x1,y1);
/*calcula la segunda constante*/
x2=x1; y2=y0+(k2*h/2);
/*calcula la prox X para K3*/
k3=f1(x2,y2);
/*calcula la tercera constante k3*/
x3=x0+h; y3=y0+(h*k3);
/*calcula la prox X para K4*/
k4=f1(x3,y3);
/*calcula la cuarta constante K4*/
yn=y0+((h/6)*(k1+2*k2+2*k3+k4));
/*calcula el prox valor de Y*/
y0=yn; x0=x3;
/*indica los nuevos valores inciales*/
gotoxy(col,fil); printf("X[%d]=%f",i,x0); printf("\t Y[%d]=%f",i,y0); /*muestra resultados*/
fil=fil+1;
/*incrementa un valor a la cifra*/
}
}
83

Metodos Numericos

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Metodos Numericos

Încărcat de

Drepturi de autor:

Formate disponibile

INSTITUTO POLITCNICO NACIONAL.

ESCUELA SUPERIOR MECNICA Y ELCTRICA.

Seccin de Estudios de Posgrado e Investigacin.

NJERA GUTIRREZ WILLIAMS

MXICO, DISTRITO FEDERAL

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

Diagrama de flujo. .............................................................................................................................................. 28

PROGRAMACIN Y MTODOS NUMRICOS.

Diagrama de flujo. .............................................................................................................................................. 78

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA LA SOLUCIN DE UNA ECUACIN DE SEGUNDO GRADO

Las races son complejas

Las races son reales

Las races son reales

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE N

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE NMEROS

PROGRAMACIN Y MTODOS NUMRICOS.

/*declara la variable entera*/

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA MULTIPLCAR MATRICES.

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA MULTIPLCAR MATRICES (FUNCIONES).

mostrar(c,20, nfa, ncb))

PROGRAMACIN Y MTODOS NUMRICOS.

multimat(a,b,c, nca, nfa, ncb)

mostrar(c,20, nfa, ncb))

PROGRAMACIN Y MTODOS NUMRICOS.

void leermat(float A[20][20],int nf, int nc,int fil)

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA ENCONTRAR EL MENOR Y MAYOR NMERO DE UNA

PROGRAMACIN Y MTODOS NUMRICOS.

/*declara la variable entera*/

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA ORDENAR NMEROS DE FORMA ASCENDENTE (TAREA).

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NMEROS

For(i=1;i <=n;i ++)

PROGRAMACIN Y MTODOS NUMRICOS.

/*declara las variables enteras */

PROGRAMACIN Y MTODOS NUMRICOS.

/*toma el primer valor */

void most(float a[20], int n)

PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NMEROS

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMACIN Y MTODOS NUMRICOS.

for(i =1;i <=n/2;i ++)

Fi gura 9.Progra ma pa ra ordena r nmeros a)main, b)leer, c) mos tra r, d) ordena r

PROGRAMACIN Y MTODOS NUMRICOS.

void most(float [20],int);

/*condicion para mayor */

PROGRAMACIN Y MTODOS NUMRICOS.

/*guarda el valor del numero inicial */

void most(float a[20], int n)

PROGRAMACIN Y MTODOS NUMRICOS.

PROGRAMA PARA ORDENAR NMEROS POR EL MTODO DE LA BURBUJA.

/declara la variable entera/

/declara la variable entera/

/declara las variables enteras /

/toma el primer valor /

/condicion para mayor /

/guarda el valor del numero inicial /

/si cambia el valor de referencia/

x[n]=a[n][n+1]/a[n][n]; /Se divide a la columna resultado entre el pivote/

void mostrar(float x[20],int n) /Se declaran la funcin y los elementos a insertar/

void mostrar(float x[20],int n) /Se declaran la funcin y los elementos a insertar/

for(k=i;k<=2n;k++) /Se inicia un contador para las columnas*/

for(i=1;i<=n;i++) /se inicia un contador par alas filas/

for(k=i;k<=n+1;k++) /Contador para cada elemento de cada fila/

void mostrar(float dx[5],int n) /Se declaran la funcin y los elementos a insertar/