METODOS NUMERICOS

INSTITUTO POLITÉCNICO NACIONAL.

ESCUELA SUPERIOR MECÁNICA Y ELÉCTRICA.

Sección de Estudios de Posgrado e Investigación.

Departamento de Ingeniería Eléctrica.

11

PROGRAMACIÓN Y

MÉTODOS

NUMÉRICOS.

TRABAJO 1.

PROFR. M. en C. JESÚS REYES GARCÍA.

¡ NÁJERA GUTIÉRREZ WILLIAMS

MÉXICO, DISTRITO FEDERAL 31 MAYO, 2011.

PROGRAMACIÓN Y MÉTODOS NUMÉRICOS. 2011

2

ÍNDICE. INTRODUCCIÓN A LA PROGRAMACIÓN. .............................................................................................................. 5

PROGRAMA PARA LA SOLUCIÓN DE UNA ECUACIÓN 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” NÚMEROS. .......................... 8

Diagrama de flujo. ................................................................................................................................................. 8

Programa................................................................................................................................................................... 9

PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE NÚMEROS 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 NÚMERO DE UNA LISTA DE

NÚMEROS. .................................................................................................................................................................. 17


Programa................................................................................................................................................................ 18

PROGRAMA PARA ORDENAR NÚMEROS DE FORMA ASCENDENTE (TAREA)........................... 19


Programa................................................................................................................................................................ 20

PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NÚMEROS (MÉTODO 1)................. 21

Diagrama de flujo ............................................................................................................................................... 21

Programa................................................................................................................................................................ 22

PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NÚMEROS (MÉTODO 2)................. 23


Programa................................................................................................................................................................ 25

PROGRAMA PARA ORDENAR NÚMEROS POR EL MÉTODO DE LA BURBUJA. ............................ 28


3


Programa................................................................................................................................................................ 30

MÉTODOS NUMÉRICOS. ............................................................................................................................................ 32

SOLUCIÓN DE ECUACIONES LINEALES(Métodos directos). .................................................................... 33

MÉTODO DE ELIMINACIÓN DE GAUSS. ........................................................................................................ 33


Programa................................................................................................................................................................ 35

MÉTODO DE GAUSS-JORDAN. ........................................................................................................................... 37


Programa................................................................................................................................................................ 39

INVERSIÓN DE MATRICES ....................................................................................................................................... 41

MÉTODO DE GAUSS-JORDAN. ........................................................................................................................... 41


Programa................................................................................................................................................................ 43

SOLUCIÓN DE ECUACIONES LINEALES (Métodos iterativos). ............................................................... 46

MÉTODO ITERATIVO DE GAUSS. ..................................................................................................................... 46


Programa................................................................................................................................................................ 50

MÉTODO ITERATIVO DE GAUSS-SEIDEL. .................................................................................................... 53


Programa................................................................................................................................................................ 57

SOLUCIÓN DE SISTEMAS DE ECUACIONES NO LINEALES. ....................................................................... 60

MÉTODO DE NEWTON-RAPHSON................................................................................................................... 60


Programa................................................................................................................................................................ 63

AJUSTE DE CURVAS..................................................................................................................................................... 66

MÉTODO DE MÍNIMOS CUADRADOS. ............................................................................................................ 66


Programa................................................................................................................................................................ 68

INTERPOLACIÓN POR MÉTODO DE LAGRANGE. ..................................................................................... 71


Programa................................................................................................................................................................ 75

SOLUCIÓN DE ECUACIONES DIFERENCIALES. ............................................................................................... 78


4


Programa................................................................................................................................................................ 79

MÉTODO MODIFICADO DE EULER. ................................................................................................................ 80


Programa................................................................................................................................................................ 81

MÉTODO DE RUNGE KUTTA. ............................................................................................................................. 81


Programa................................................................................................................................................................ 83


5

INTRODUCCIÓN A LA PROGRAMACIÓN.


6

PROGRAMA PARA LA SOLUCIÓN DE UNA ECUACIÓN DE SEGUNDO GRADO

DE LA FORMA AX2+BX+C=0.

Hacer el diagrama de flujo y programa para resolver una ecuación de segundo grado

de la forma aX2+bX+c=0.

Diagrama de flujo.

Figura 1.Diagrama de flujo para programa para la solución de ecuaciones de segundo grado.

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 raíces 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 raíces son reales y distintas: X1, X2

X1=-b/2.0*a X2=-x1

Las raíces son reales

e iguales

FIn


7

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("Solución de una ecuación 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; /*operación dentro de la raiz*/ if(disc<0) /*condición 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) /*evalúa 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 raíces son reales y distintas"); gotoxy(2,16);printf("x1=%f,x2%f",x1,x2); } Else /*opción para valor igual a cero*/ { x1=-b/(2.0*a); x2=x1; /*calcula el valor para ambos resultados*/ gotoxy(2,15);printf("Las raíces 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*/ }


8

PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE “N”

NÚMEROS.

Hacer el diagrama de flujo y programa para obtener el promedio de una lista de “n” números.

Diagrama de flujo.

Figura 2.Diagrama para solución de ecuaciones de segundo grado.

Inicio

n

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

x[i]

sum=0.0

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

sum=sum+x[i]

prom

Fin

Prom=sum/n


9

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 número 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); /*ecuación 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 operación*/ } 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*/ }


10

PROGRAMA PARA OBTENER EL PROMEDIO DE UNA LISTA DE NÚMEROS

CON FUNCIONES.

Realizar un programa para obtener el promedio de una lista de “n” números utilizando

funciones que agrupen el programa:

Diagrama de flujo.

a) b)

c)

Figura 3.Solución de ecuaciones de segundo grado con funciones : a) main b) función de lectura y c)Función de promedio .

prom(a,n)

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

sum=sum+a[i]

sum=0.0

prom=sum/n

Fin

leevec(a,n,x,2,3)

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

a[i]

Fin

Inicio

n

leevec(a, n, 3, 2)

prom(a, n)

prom

FIn


11

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 función 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 función promedio*/ gotoxy(2,15); printf("El promedio es:prom=%f", res); gotoxy(2,24); printf("Presione cualquier tecla para continuar"); getch(); /*espera un tecleo para continuar*/

} void leervec(float a[20], int n, char nom[5], int col, int fil) {

int i; /*declara la variable entera*/ 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); /*ecuación para incrementar filas*/

} } float prom(float a[20], int n) {

int i; /*declara la variable entera*/ float sum; /*declara la variable flotante*/ sum=0.0; /*inicia la suma en cero*/ for(i=1;i<=n;i++) /*inicia el contador para realizar la suma*/ { sum=sum+a[i]; /*ecuación para realizar la suma*/ } res=sum/n; /*obtiene el promedio*/ return(res); /*devuelve el valor del promedio*/

}


12

PROGRAMA PARA MULTIPLCAR MATRICES.

Realizar el diagrama de flujo y programa para realizar la multiplicación de matrices.

Diagrama de flujo.

Figura 4.Programa para multiplicar matrices .

1

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin

Inicio

nca, nfa ,

ncb

a[i][j]

for(j=1;j<=nfa;j

++)

b[i][j]

for(i=1;i<=nfa;i

++)

for(i=1;i<=nfa;i

++)

c[i][j]=0.0

c[i][j]=c[i][j]+

a[l][j]*b[l][j]

for(j=1;j<=nfa;j

++)

for(j=1;j<=nfa;j

++)

for(l=1;l<=nca;l

++)

for(i=1;i<=nfa;i

++) 1


13

Programa:

#include"stdio.h" #include"conio.h" main() {

int i,j,l,nfa,nca,ncb,col1; /*declara las variables enteras*/ float a[20][20], b[20][20],c[20][20]; /*declara las variables flotantes*/ gotoxy(2,1);printf("nfa=");scanf("%d",&nfa); /*guarda el número de filas de a*/ gotoxy(20,1);printf("nca=");scanf("%d",&nca); /*guarda el número de columnas de a*/ gotoxy(40,1);printf("ncb=");scanf("%d",&ncb); /*guarda el número 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); /* posicionamiento en pantalla*/ 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]; /*operación 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*/ {


14

gotoxy(col1,i+20); /* posicionamiento en pantalla*/ 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 multiplicación de matrices por medio del llamado de funciones.

Diagrama de flujo.

a) b)

Inicio

nfa,nca,ncb

Leemat(a,nfa,nca,10)

Leemat(b,nca,ncb,10)

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

mostrar(c,20, nfa, ncb))

Fin

leemat(a,n,x,2,3)

a[i][j]

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

Fin

for(j=1;j<=n;j++)


15

c) d) Figura 5.Multiplicación de matrices por funciones : a)main, b)lectura de matriz, c)multiplicación, d) mostrar.

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();

}

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin


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

for(i=1;i<=nfa;i+

+)

for(i=1;i<=nfa;i+

+)

c[i][j]=0.0

for(l=1;l<=nca;l+

+)

c[i][j]=c[i][j]+ a[l][j]*b[l][j]

Fin


16

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; /*declara las variables enteras */ 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]; /*ecuación para suma de matrices */ } } }

} void mostrar(float c[20][20],int fil, int nfa, int ncb) {

int i, j, col, col1; /*declara las variables enteras */ 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 */ } }

}


17

PROGRAMA PARA ENCONTRAR EL MENOR Y MAYOR NÚMERO DE UNA

LISTA DE NÚMEROS.

Elaborar un programa para encontrar el menor y el mayor número de una lista de “n”

elementos.

Diagrama de flujo.

Figura 6.Programa para encontrar el mayor y menor número.

Inicio

leevector()

menor=x[i]

mayor=x[i]

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

x[i]<menor

x[i]>mayor

menor=x[i]

mayor=x[i] menor=x[i]

menor mayor mayor

Fin


18

Programa.

#include "stdio.h" #include "conio.h" #include "stdlib.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 tiene tu lista? "); scanf("%d",&n); /*Se Captura el número de elementos a ordenar*/ leervec(x,n,"x",2,3); /*Se llama la función para leer el vector*/ men=menor(x,n); /*Se llama la función para encontrar el número menor*/ may=mayor(x,n); /*Se llama la función para encontrar el número 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; /*declara las variables enteras*/ gotoxy(col,fil); for(i=1;i<=n;i++) /*Se inicia un contador para todos los números 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 próxima iteración*/ } } float menor(float x[20], int n) { int i; /*declara la variabl e entera*/ float men; /*Se define la variable donde se guardará el número 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; /*declara la variable entera*/ float may; /*declara la variable flotante*/ may=x[1]; /*asigna el primer valor como mayor*/ for(i=2;i<=n;i++) /*inicia el contador para recorrido de numeros*/ { if(x[i]>may) /*condicion para numero mayor*/ { may=x[i]; } } /*asigna el valor mayor*/ return (may); /*devuelve el numero mayor*/ }


19

PROGRAMA PARA ORDENAR NÚMEROS DE FORMA ASCENDENTE (TAREA).

Realizar un programa para ordenar una lista de números.

Diagrama de flujo.

a) b)

c) d)

Figura 7.Programa para ordenar números con funciones a)main, b)leer, c)operar y d)mostrar.

most

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

a[i]

Fin

Operamat(a,n

)

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

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

a[j]<[i]

temp=a[j] a[j]=a[i]

a[i]=temp

Fin

Leemat(a,n)

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

a[i]

Fin

Inicio

n

Leemat(a,n)

Operamat(a,n)

most

Fin


20

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(); }


21

PROGRAMA PARA ORDENAR UNA LISTA COMPLETA DE NÚMEROS

(MÉTODO 1).

Diagrama de flujo

a) b)

c) d)

Figura 8.Ordenar números con funciones a) main, b)leer c)ordenar y c) mostrar.

most(a,n)

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

Fin

a[i]

Ord(a,n)

men=x[i];pmen=

1

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

men=x[i] pmen=j

x[j]<men

aux=x[i ]

x[i]=x[pmen] x[pmen]=aux

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

Fin

Leemat(a,n)

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

Fin

a[i]

Inicio

n

Leemat(a ,n)

Ord(a ,n)

most(a .n)

Fin


22

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; /*declara la variable entera*/ float a[20]; /*declara la variable flotante*/ 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(); /*espera un tecleo para continuar*/

} void leemat(float a[20], int n) {

int i; /declara la variables entera* */ printf("\nIntroduce los %d valores para ordenar:\n", n); 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; /*declara las variables enteras */ float men, aux; /*declara las variables flotantes */ for(i=1;i<=n;i++) /* inicia contador para los numeros*/ { men=a[i]; /*asigna el valor menor */ pmen=i; for(j=i+1;j<=n;j++) /*inicia el contador para los numeros de la lista*/ { if(a[j]<men) /*inicia la condicion para numero menor */ { men=a[j]; /*asigna el numero menor */ pmen=j; /* toma la posicion del numero*/ }


23

} aux=a[i]; /*toma el primer valor */ a[i]=a[pmen]; /*coloca el numero menor en posicion*/ a[pmen]=aux; /*coloca al numero restante en la posicion del menor */ }

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

int i; /*declara las variables enteras */ 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 NÚMEROS

(MÉTODO 2).

Diagrama de flujo.

a) b)

Leemat(a,n)

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

a[i]

Fin

Inicio

n

Leemat(a,n)

Ord(a,n)

most(a.n)

Fin


24

c)

most(a,n)

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

a[i]

Fin


25

d)

Figura 9.Programa para ordenar números a)main, b)leer, c) mostrar, d) ordenar

Programa.

#include"conio.h" #include"stdio.h" #include"stdlib.h" void leemat(float [20],int); void ord(float [20],int);

ordena(a,n)

pmen=i

pmay=i men=x[i] may=x[i ]

for(j=i+1;j<n+1;j++)

x[i]<men

pmen=j men=x[j]

x[j]<may

pmay=j may=x[j]

aux=x[i ] x[i]=x[pmen]

x[pmen]=aux

pmay=i

pmay=pmen

aux=x[n+1-i ] x[n+1+i ]=x[pmay]

x[pmay]=aux

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


26

void most(float [20],int); main() {

int n; float a[20]; printf("PROGRAMA PARA ORDENAR EN FORMA DESCENDENTE UNA LISTA DE NÚMEROS"); printf("\nDame el numero de valores a ordenar "); scanf("%d",&n); leemat(a,n); ord(a,n); most(a, n); printf("\nPresiona una tecla para continuar"); getch();



} void ord(float a[20], int n) {

int i,j, pmen, pmay; /*variables enteras */ float men, aux, may; /*variables flotantes */ for(i=1;i<=n/2;i++) /*contador para recorrido de numeros */ { pmen=i; /*posicion del num menor */ pmay=i; /*posicion del num mayor */ men=a[i]; /*numero menor */ may=a[i]; /*numero mayor */ for(j=i+1;j<=n+1-i;j++) /*recorrido para numero menor */ { if(a[j]<men) /*condicion para numero menor */ { pmen=j; /*guarda la posicion del numero */ men=a[j]; /*asigna el valor del menor */ } else { if(a[j]>may) /*condicion para mayor */ {


27

pmay=j; /*posicion mayor */ may=a[j]; /*asigna el valor mayor */ } } } aux=a[i]; /*guarda el valor del numero inicial */ a[i]=a[pmen]; /*asigna el valor de la posicion menor */ a[pmen]=aux; /*guarda el numero restante en la posicion anterior */ if(pmay==i) /*posicion del mayor */ { pmay=pmen; /*asigna el menor */ } aux=a[n+1-i]; /*recorre el valor del valor anterior */ a[n+1-i]=a[pmay]; /*asigna el valor mayor */ a[pmay]=aux; /*guarda el valor anterior */ }



}


28

PROGRAMA PARA ORDENAR NÚMEROS POR EL MÉTODO DE LA BURBUJA.

Diagrama de flujo.

a) b)

c)

most(a,n)

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

a[i]

Fin

Leemat(a,n)

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

a[i]

Fin

Inicio

n

Leemat(a,n)

burbuja(a,n)

most(a.n)

Fin


29

d)

Figura 10.Metodo de la burbuja a)main, b)leer, c)mostrar, d) burbuja .

burbuja

S=’v’

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’

While(s==’v’) Fin


30

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"); printf("\nDame el numero de valores a ordenar "); 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*/ printf("\nPresiona una tecla para continuar"); getch();



} void burbuja(float a[20], int n) {

int i,ban; /*variables enteras*/ float aux; /*variables flotantes*/ char s; /*variables caracter*/ s='v'; /*asigna un valor de referencia*/ while(s=='v') /*condicion para seguir ordenando*/ { ban=0; /*asigna valor de referencia*/ for(i=1;i<=n-1;i++) /*inicia contador para los numeros*/ { if(a[i]>a[i+1]) /*si el actual mayor al siguiente*/ { aux=a[i]; /*guarda el valor actual en aux*/ a[i]=a[i+1]; /*se guarda el valor siguiente en el lugar actual*/ a[i+1]=aux; /*se guarda el valor mayor*/


31

break; /*termina el proceso*/ } Else /*opcion alterntiva*/ { if(i==n-1) /*si llega al penultimo numero*/ { ban=1; /*cambia el valor de referencia*/ } } } if(ban==1) /*si cambia el valor de referencia*/ { s='f'; /*cambia el valor referencia para continuar while*/ } }



}


32

MÉTODOS NUMÉRICOS.


33

SOLUCIÓN DE ECUACIONES LINEALES(Métodos directos).

MÉTODO DE ELIMINACIÓN DE GAUSS.

Realizar el programa para obtener la solución de un sistema de ecuaciones por eliminación de

Gauss.

Diagrama de flujo.

a) b)

c)

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin


leemat(a,n,x,2,3)

a[i][j]

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

Fin

for(j=1;j<=n;j++)

Inicio

n

Leemat()

egauss()

mostrar()

Fin


34

d)

Figura 11.Solución de ecuaciones lineales a)main, b)leer, c)mostrar, c) gauss .

egauss

aux=a[i][i ]

a[i ][j]=a[i][j]/aux

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]

x[i]=a[i][n+1]

for(j=i+1;j<=n;j++)

x[i]=x[i ]-

a[i ][j]*x[j]

Fin

for(j=1;j<=n+1;j+

+)

for(j=i+1;j<=n;j++)

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

++)

for(k=1;k<=n+1;k

++)


35

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 dimensión del sistema de ecuaciones a trabajar*/ leermat(a,n,5); /*Ejecuta la función para leer la matriz*/ egauss(a,n,x); /*Ejecuta la función para realizar la eliminación por Gauss*/ mostrar(x,n); /*Ejecuta la función para mostrar el resultado de la matriz en pantalla*/ printf("\nPresiona una tecla para salir"); 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 función*/ nf=n; /*El número de filas es igual al número de ecuaciones*/ nc=n+1; /* ecuación para incremento de columnas*/ printf("Dame la matriz aumentada"); for(i=1;i<=nf;i++) /*Se inicia el FOR contando hasta el número 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 próxima columna*/ } }

} void egauss(float a[20][21], int n, float x[20]) /*Se declaran las variables a insertar dentro de la función*/ {

int i,j,k; /*Se declaran las variables enteras a utilizar*/ float aux; /*Se declara la variable auxiliar flotante a utilizar en la función*/ 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*/


36

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 próxima 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]; /*Operación para obtención de resultado*/ } }

} void mostrar(float x[20],int n) /*Se declaran la función 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*/ }

}


37

MÉTODO DE GAUSS-JORDAN.

Diagrama de flujo.

a) b)

c)

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin


leemat(a,n,x,2,3)

a[i][j]

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

Fin

for(j=1;j<=n;j++)

Inicio

n

Leemat(a,n)

gjordan(a,n)

most(a,n)

Fin


38

d)

Figura 12.Solución Gauss-Jordan a)main, b)leer, c)mostrar, d)Gauss-Jordan.

gjordan

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

aux=a[i][j]

a[i][j]=a[i][j]/aux

j!=i

aux=a[j][i]

for(k=i;k<=n+1;k++)

a[i][j]=a[j][k]-a[i][k]*aux

for(j=1;j<=n+1;j++)

for(j=1;j<=n+1;j++)

Fin


39

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*/ void mostrar(float [20],int ); /*Prototipo para mostrar el resultado*/ main() {

int n; float a[20][21], x[20]; printf("\nPROGRAMA QUE RESUELTE SISTEMAS DE ECUACIONES, MÉTODO GAUSS-JORDAN"); 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 función con los valores adquiridos desde "main"*/ {

int i, j, col, nf, nc; /*Declara las variables a utilizar a lo largo de la función*/ nf=n; /*El número de filas es igual al número de ecuaciones*/ nc=n+1; /*El número de columnas es el número de ecuaciones más la columna de resultados*/ printf("Dame la matriz aumentada"); for(i=1;i<=nf;i++) /*Se inicia el FOR contando hasta el número 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 próxima columna*/ } }

} void gjordan(float a[20][21], int n, float x[20]) { int i,j,k; /*Declara las variables enteras de la función*/ float aux; /*Declara la función flotante auxiliar de la función*/ for(i=1;i<=n;i++) /*Declara el FOR para el recorrido de las filas*/ {


40

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) /*Condición 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 función 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*/ }

}


41

INVERSIÓN DE MATRICES

MÉTODO DE GAUSS-JORDAN.

Diagrama de flujo.

a) b)

c)

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin


leemat(a,n,x,2,3)

a[i][j]

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

Fin

for(j=1;j<=n;j++)

Inicio

n

Leemat(a,n)

invmat(a,n)

most(a,n)

Fin


42

d)

invmat

for(j=1;j<=n;j++

)

x[i][j]=a[i]

[j]

for(i=1;i<=n;i++

)

i==j

x[i][n+j]=

1.0

x[i][n+j=0

.0

for(j=1;j<=n;j++

)

for(j=i;j<=2*n;j++)

aux=x[i]i]

x[i][j]=x[i][j]/

aux

for(i=1;i<=n;i++

)

1

2 3

for(i=1;i<=n;i++

)


43

Figura 13.Inversion matrices Gauss-Jordan a)main, b)leer, c) mostrar, 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); printf("\nPresiona una tecla para salir"); getch();

} void leermat(float a[20][20],int n,int fil) { int i,j,col,nf,nc; nc=n; /*El número de columnas es el mismo que el número de ecuaciones*/ nf=n; /*El número de filas es el mismo que el número 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*/

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

for(j=1;j<=n;j++)

b[i][j]=x[i][i][j+n]

3 aux=x[j][i

]

for(k=j;k<=2*n;k++)

aux=x[j][i

]

i !=j

for(j=1;j<=n;j++) 2


44

{ 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*/ } } 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*/ { if(i==j) /*Condición 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 triángulo 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) /*Condición para no operar el elemento de diagonal*/ { aux=x[j][i]; /*se toma el elemento de esta rutina*/


45

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*/ } } } } 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*/ { 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; /*Ecuación de incremento en las filas* for(j=1;j<=ncb;j++) /*Se inicia el contador par alas columnas*/ { col1=col+10*j; /*ecuación 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; } } }


46

SOLUCIÓN DE ECUACIONES LINEALES (Métodos iterativos).

MÉTODO ITERATIVO DE GAUSS.

Diagrama de flujo.

a) b)

c)

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin


leemat(a,n,x,2,3)

a[i][j]

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

Fin

for(j=1;j<=n;j++)

Inicio

n

Leemat(a,n)

itegau(a,n)

most(a,n)

Fin


47

d)

i tegau(a,n)

b[i][j]=a[i ][j]

aux=a[i][j]

i==j

b[i][j]=b[i][n+1]/aux b[i][j]=-b[i ][j]/aux

for(j=1;j<=n+1;j++)

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

for(j=1;j<=n;j++)

Xs [i]=-b[i][j]

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

1

for(j=1;j<=n;j++)


48

for(j=1;j<=n;j++)

1

for(j=1;j<=n;j++)

Xc[i]=b[j][j]

i !=k

Xc[j]=Xc[j]+b[j][k]*Xs[k]

for(k=1;k<=n;k++)

ban=1

for(j=1;j<=n;j++)

|Xc[j]-Xs[j]|>Eps

ban=o

break

2

3 4


49

Figura 14.Metodo i terativo de Gauss. a) main, b) leer, c) mostrar, d)i terativo.

4

ban==0

El sistema

no converge

Return(0)

Fin

2

ban==1

El sistema

converge

mostvec Xs [j]=Xc[j]

return(1)

Break,

for(j=1;j<=n;j++)

3


50

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); void mostrar(float [20],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 iteración*/ } } } 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*/


51

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) /*condición 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 ecuación*/ } 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 operación del elemento calculado*/ } } } ban=1; /*Condición 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 condición para comprobar la convergencia*/ break; /*Termina la condición if*/ } } if(ban==1) /*Determina la convergencia del sistema*/


52

{ clrscr(); /*Limpia la pantalla*/ printf("\nEl sistema converge"); mostrar(xs,n); /*Llama la función para mostrar los resultados obtenidos*/ return(1); /*Devuelve 1*/ break; /*Termina la condición if*/ } Else /*Evalua cuando no se cumple la condición 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 condición 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 función 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 xc[%d]= %f",i,xc[i]); /*Se presenta el elemento deseado*/ } }


53

MÉTODO ITERATIVO DE GAUSS-SEIDEL.

Diagrama de flujo.

a) b)

c)

for(i=1;i<=nfa;i++

)

for(j=1;j<=nfa;j++

)

c[i][j]

Fin


leemat(a,n,x,2,3)

a[i][j]

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

Fin

for(j=1;j<=n;j++)

Inicio

n

Leemat(a,n)

seidel(a,n)

most(a,n)

Fin


54

d)

seidel(a ,n)

b[i][j]=a[i ][j]

aux=b[i ][j]

i==j

b[i][j]=b[i][n+1]/aux b[i][j]=-b[i ][j]/aux

for(j=1;j<=n+1;j++)

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

for(j=1;j<=n;j++)

Xs [i]=-b[i][j] Xs1[i]=xs [i]

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

for(j=1;j<=n;j++)

1


55

for(j=1;j<=n;j++)

1

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]-Xs1[j]|>Eps

ban=o break

2

3 4

Xs [j]=xc[j]


56

Figura 15.Método Gauss-Seidel , a) main, b) leer, c) mostrar y c) Gauss-Seidel .

2

ban==1

El sistema

converge

mostvec Xs [j]=Xc[j] Xs [j]=xc[j]

return(1)

Break,

for(j=1;j<=n;j++)

3

4

ban==0

El sistema

no converge

Return(0)

Fin


57

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); void mostrar(float [20],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; /*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 próxima columna*/ } }

} 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*/


58

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) /*condición 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 operación*/ { if(j!=k) /*evita al elemento pivote*/ { xc[j]=xc[j]+b[j][k]*xs[k]; /*realize la operación 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) /*condición para satisfacer el margen de error*/ { ban=0; /*cambio de referencia para determinar convergencia*/ break; /*termina la condición if*/ }


59

} if(ban==1) /*determina si converge o no el sistema*/ { clrscr(); /*limpia la pantalla*/ printf("\nEl sistema converge"); mostrar(xs,n); /*muestra el arreglo con los resultados*/ return(1); /*devuelve 1 */ break; /*termina la condición if*/ } else /condición 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) /*condición para el término del número de interaciones*/ { clrscr(); /*limpia pantalla*/ printf("El sistema no converge"); return(0); /*devuelve cero*/ } } void mostrar(float xc[20],int n) /*Se declaran la función 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 xc[%d]= %f",i,xc[i]); /*Se presenta el elemento deseado*/ } }


60

SOLUCIÓN DE SISTEMAS DE ECUACIONES NO LINEALES.

MÉTODO DE NEWTON-RAPHSON.

Diagrama de flujo.

#include “conio.h” #include “stdlib.h” #include “math..h” #include “stdio.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’&&it<ni

t)

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

S!=0

1

S!=1

El sistema

no

converge

Fin

2

Inicio


61

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

|dx[i]>Eps

S!=1

Break;

S!==0

El sistema

converge

Mostvec(x,n,”x”,20,2)

S=’f’

It=it+1

for(j=1;j<=n;j++)

X[j]=x[j]+jx[j]

2

1


62

Figura 16.Solución de ecuaciones no Lineales Ne wton Raphson.

egauss

aux=a[i][i]

a[i ][j]=a[i][j]/aux

aux=a[j][i]

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]

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

x[i]=x[i ]-a[i][j]*x[j]

Fin

for(j=1;j<=n+1;j++)

for(j=i+1;j<=n;j++)

for(k=1;k<=n+1;k++)

for(j=i+1;j<=n;j++)


63

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 función 1 a trabajar*/ #define f2(x1,x2)((2.0*x2)-x1-2.0) /*define la función 2 a trabajar*/ #define df1x1(x1,x2)(-4.0) /*define la derivada de f1 respecto a x*/ #define df1x2(x1,x2)(2.0*x2) /*define la derivada de f1 respecto a y*/ #define df2x1(x1,x2)(-1.0) /*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 función 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 ecuación"); leevec(n, y); printf("\nDame los valores iniciales X de tu ecuación"); 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 operación para el primer resultado*/ a[2][3]=y[2]-f2(x[1],x[2]); /*determina la operación para el segundo resultado*/ a[1][1]=df1x1(x[1],x[2]); /*determina la operación de primer localidad de la matriz*/ a[1][2]=df1x2(x[1],x[2]); /*determina la operación de segund localidad de la matriz*/ a[2][1]=df2x1(x[1],x[2]); /*determina la operación de tercer localidad de la matriz*/ a[2][2]=df2x2(x[1],x[2]); /*determina la operación 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*/ } }


64

if(s1==0) /*si el margen de error se satisface*/ { printf("\nEl sistema converge"); 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 interación/ 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) /*condición para el término de iteraciones en while*/ { printf("\nEl sistema no converge"); } printf("\nPresiona una tecla para continuar"); 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; /*Declara las variables enteras de la función*/ float aux; /*Declara la función flotante auxiliar de la función*/ for(i=1;i<=n;i++) /*Declara el FOR para el recorrido de las filas*/ { 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) /*Condición para operar todos los elementos diferentes al pivote*/ { aux=a[j][i]; /*Elemento pivote*/


65

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*/ { 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 función 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("\ndx[%d]= %f",i,dx[i]); /*Se presenta el elemento deseado*/ }

}


66

AJUSTE DE CURVAS.

MÉTODO DE MÍNIMOS CUADRADOS.

Diagrama de flujo.

a) b)

c)

most(a,n)

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

a[i]

Fin

Leemat(a,n)

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

a[i]

Fin

Inicio

n

Leemat(a,n)

mincua(a,n)

most(a,n)

Fin


67

d)

Figura 17.Mínimos cuadrados, a) main, b)leer c) mostrar d) Mínimos cuadrados .

sumx[i ]=0.0

sumx[i ]=sumx[i ]+pow(x[j],i -1)

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

sumxy[i]=0.0

sumxy[i]=sumxy[i ]+pow(x[j],i-

1)*y[j]

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

sx[i][n+2]=sumxy[i ]

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

K=i

sx[i][j]=sumx[k]

K=k+1

for(j=1;j<=m;j++)

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

for(j=1;j<=m;j++)

for(j=1;j<=n+1;j++)

Egauss(sx,n+1,a)

mincua(a ,n)


68

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 ); void mostrar(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); printf("\nPresiona una tecla para salir"); getch(); } void leermat(float a[20],int n) /*Encabezado de la función con los valores adquiridos desde "main"*/ { int i; /*Declara las variables a utilizar a lo largo de la función*/ for(i=1;i<=n;i++) /*Se inicia el FOR contando hasta el número de filas totales*/ { 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*/


69

} } 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 formación 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; /*Declara las variables enteras de la función*/ float aux; /*Declara la función flotante auxiliar de la función*/ for(i=1;i<=n;i++) /*Declara el FOR para el recorrido de las filas*/ { 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) /*Condición 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*/ } } } }


70

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 r[20],int n) /*Se declaran la función 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++) /*Se inicia un contador para desplegar en pantalla los resultados*/ { printf("\na[%d]=%f",i-1,r[i]); /*Se presenta el elemento deseado*/ }

}


71

INTERPOLACIÓN POR MÉTODO DE LAGRANGE.

Diagrama de flujo.

a) b)

c)

most

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

a[i]

Fin

Leemat

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

a[i]

Fin

Inicio

n

Leemat(x,n)

Lagrange(x,y,n,,pol)

most(pol,n)

Fin

Leemat(y,n)


72

d)

f[1]=1.0

i!=j

f(i)=f[i]*(x[i]-x[i])

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

K=1

for(j=1;j<=n;j++)

i!=j

V[k]=j K=k+1

for(j=1;j<=n+1;j++)

f[1]=y[i]/f[i]

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

1

4 5

Lagrange


73

V1[1]=0.0 V1[2]=V[1]

for(k=2;k<=n-1;k++)

V2[l+1]=v1[l]*(-x[v[k]])

for(l=2;l<=n;l++)

V3[l]=v1[l]+v2[l]

1

p[j][k]=0.0

forkj=1;k<=n;k++)

for(j=1;j<=n;j++)

V1[k]=0.0 V2[k]=0.0 V3[k]=0.0

forkj=1;k<=n;k++)

p[i][i ]=v1[l]*f[i ]

for(l=2;l<=n;l++) for(k=2;k<=n-1;k++)

2

3

4


74

Figura 18.Interpolación de Lagrange a) main, b) leer, c) mostrar, d) Lagrange.

for(l=1;l<=k+1;l++)

V1[l]=v1[l] V2[l]=0.0

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

Pol[l]=0.0

2

3

3

Pol[l]=pol[l]+p[k][l]

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

Fin


75

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]); void mostrar(float [20],int ); main() {

int n; float x[20], y[20], pol[20]; printf("\nInterpolacion de curvas, Metodo de Lagrange"); printf("\nDame el número 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 función con los valores adquiridos desde "main"*/ { int i; /*Declara las variables a utilizar a lo largo de la función*/ for(i=1;i<=n;i++) /*Se inicia el FOR contando hasta el número de filas totales*/ { 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; /*declara las variables enteras*/ 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 operación en cero*/ for(j=1;j<=n;j++) /*contador para segundo elemento dentro de operaciones*/ { if(i!=j) /*evita restar dos números iguales*/ { f[i]=f[i]*(x[i]-x[j]); /*operaciónes para denominador*/ } } f[i]=y[i]/f[i]; /*divide ultimo valor entre operación realizada


76

} 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;


77

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 función 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++) /*Se inicia un contador para desplegar en pantalla los resultados*/ { printf("\na[%d]=%f",i-1,r[i]); /*Se presenta el elemento deseado*/ } }


78

SOLUCIÓN DE ECUACIONES DIFERENCIALES. METODO DE EULER.

Diagrama de flujo.

a) b)

c)

Figura 19.Metodo de Euler, a)main, b) euler, c) mostrar.

most

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

a[i]

Fin

euler

x[1]=x0; y[1]=y0;

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

y[i+1]=y[i]+dydx(x[i],y[i])*h; x[i+1]=x[i]+h;

Fin

Inicio

Xo,Yo,h

euler

Fin.

Most(x,n”x”)

Most(y,n”y”)


79

Programa.

#include<stdio.h> #include<conio.h> #define dydx(x,y)(4*(exp(0.8*x))-(0.5*y)) /*Define la función 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; /*declara la variable entera*/ 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*/ { y[i+1]=y[i]+dydx(x[i],y[i])*h; /*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*/ } }


80

MÉTODO MODIFICADO DE EULER.

Diagrama de flujo.

a) b)

c) Figura 20.Metodo de euler modificado, a) main, b) mostrary c) eulermodificado

euler

x[1]=x0; y[1]=y0;

y[i+1]=y[i]+dydx(x[i],y[i])*h; x[i+1]=x[i]+h;

Fin

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;

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

most

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

a[i ]

Fin

Inicio

Xo,Yo,h, i t

eulermod

Fin.

Most(x,n”x”)

Most(y,n”y”)


81

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);printf("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*/ } }


82

MÉTODO DE RUNGE KUTTA.

Diagrama de flujo.

a) b)

Figura 21.solución por Runge kutta: a) main, b) rkutta .

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;

X[i]=x3; Y[i]=yn;

Fin

Inicio

a,b,y n

rkutta

Fin.


83

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*/ } }

METODOS NUMERICOS

Documents