Sei sulla pagina 1di 62

Instituto Politcnico Nacional

Escuela Superior de Ingeniera Mecnica y Elctrica Unidad Zacatenco Ingeniera en Comunicaciones y Electrnica

ASIGNATURA:
ANALISIS NUMERICOS

NOMBRE DEL TRABAJO:


TRABAJO DE INVESTIGACION SEGUNDO DEPARTAMENTAL

NOMBRE DEL PROFESOR:


ING. JOSE ANTONIO BERNAL MENDOZA

INTEGRANTES:
AVILA MACIAS JESUS EDUARDO GONZALEZ LOPEZ FERNANDO GUARNEROS DE LA TORRE HECTOR GUTIERREZ VICTOR RAUL MICHEL JULIAN ALEJANDRO

GRUPO: 4CV7

10/ NOVIEMBRE/ 2001

INDICE

INTRODUCCION ................................................................................................................................... 3 OBJETIVOS4 MARCO TEORICO4

METODO DE LU ............................................................................................................. 5
PROBLEMAS ................................................................................................................................ 7 CODIGO FUENETE...................................................................................................................... 15

METODO DE CHOLESKY .......................................................................................... 16


CODIGO FUENTE........................................................................................................................ 22

METODO DE CHEBYSHEV ........................................................................................ 26


PROBLEMAS..27 CODIGO FUENTE..30

METODO DE HERMITE ............................................................................................. 32


PROBLEMAS .............................................................................................................................. 36

INTERPOLACION DE NEWTON...38
PROBLEMAS39. CODIGO FUENTE41

CONCLUSIONES ........................................................................................................... 60 GLOSARIO ..................................................................................................................... 60 BOBLIOGRAFIA ........................................................................................................... 62

Pgina 2

INTRODUCCIN Muchas veces en el campo de la ingeniera, ciencia y vida diaria, se encuentran diversos problemas, los cuales deben ser analizados desde el enfoque que los mtodos numricos pueden dar, ms aun, si dicho mtodo numrico, es enfrentado a polinomios, de difcil trato. Sabemos que para resolver una ecuacin, existen diferentes mtodos, algunos de ellos ya los hemos utilizado en repetidas ocasiones, estos mtodos son Mtodo de sustitucin 1 Se d espeja una incgnita en una de las ecuaciones. 2 Se sustituye la expresin de esta incgnita en la otra ecuacin, obteniendo un ecuacin con una sola incgnita. 3 Se resuelve la ecuacin. 4 El valor obtenido se sustituye en la ecuacin en la que apareca la incgnita despejada. 5 Los dos valores obtenidos constituyen la solucin del sistema. Mtodo de igualacin 1 Se despeja la misma incgnita en ambas ecuaciones. 2 Se igualan las expresiones, con lo que obtenemos una ecuacin con una incgnita. 3 Se resuelve la ecuacin. 4 El valor obtenido se sustituye en cualquiera de las dos expresiones en las que apareca despejada la otra incgnita. 5 Los dos valores obtenidos constituyen la solucin del sistema. Mtodo de reduccin 1 Se preparan las dos ecuaciones, multiplicndolas por los nmeros que convenga. 2 La restamos, y desaparece una de las incgnitas.

Pgina 3

3 Se resuelve la ecuacin resultante. 4 El valor obtenido se sustituye en una de las ecuaciones iniciales y se resuelve. 5 Los dos valores obtenidos constituyen la solucin del sistema. En este trabajo se llevo a cabo la investigacin de nuevos mtodos matemticos, para poder resolver ecuaciones de cualquier tipo. Era lgico esperar un grado mayor de razonamiento, para poder aplicar estos mtodos, ya que conforme avanzamos, encontraremos cada vez un nivel mayor de dificultad para resolver este tipo de problemas, sin embargo con los conocimientos previos que tenemos, ser ms que suficiente para poder aplicar estos mtodos y no tener problema alguno. Recordamos que los mtodos que se aplicaron en esta investigacin son: El mtodo de LU Cholesky Chebyshev Hermite Y la interpolacion de Newton para 2 ecuaciones

Los cuales fueron detalladamente explicados de tal forma que fueran claros para nuestros lectores. OBJETIVOS -GENERAL Este trabajo busca ensear la implementacin de distintos mtodos para la resolucin de sistemas de ecuaciones tales como Lu, Cholesky, Chebyshev y Hermite; adems del estudio de mtodos de interpolacin, tales como el mtodo de Newton. -PARTICULAR El objetivo particular de este trabajo tiene como principal meta, el lograr explicar en base a un marco terico, desarrollo de mtodo, problemas de ejemplo y una implementacin en el compilador Turbo o C o DevC++, para cada uno de los mtodos que ms adelante se explicaran. MARCO TEORICO Muchas veces, de una funcin slo conocemos un conjunto de valores. Esto puede suceder, por ejemplo, porque son los resultados de un experimento gobernado por una ley que desconocemos. Si queremos calcular el valor de la funcin para una abscisa diferente de las conocidas, debemos utilizar otra funcin que la aproxime y, naturalmente, el valor que obtengamos ser una aproximacin del valor real. Tambin puede suceder que sepamos la expresin analtica de la
Pgina 4

funcin, pero sea lo suficientemente complicada como para calcular aproximaciones a los valores de la funcin a partir de otros ya conocidos. Existen varias formas de hacer esto, pero la ms sencilla y una de las ms utilizadas es la interpolacin1, que consiste en construir una funcin que pase por los valores conocidos (llamados polos) y utilizar sta como aproximacin de la funcin primitiva. Si se utilizan polinomios como funciones de aproximacin, hablamos de interpolacin polinmica. DESARROLLO METODO DE LU

Su nombre se deriva de las palabras inglesas Lower" y Upper, que en espaol se traducen como Inferior y Superior. Estudiando el proceso que se sigue en la descomposicin LU es posible comprender el por qu de este nombre, analizando cmo una matriz original se descompone en dos matrices triangulares, una superior y otra inferior. La descomposicin LU involucra solo operaciones sobre los coeficientes de la matriz [A], proporcionando un medio eficiente para calcular la matriz inversa o resolver sistemas de lgebra lineal. Primeramente se debe obtener la matriz [L] y la matriz [U]. [L] es una matriz diagonal inferior con nmeros 1 sobre la diagonal. [U] es una matriz diagonal superior en la que sobre la diagonal no necesariamente tiene que haber nmeros 1. El primer paso es descomponer o transformar [A] en [L] y [U], es decir obtener la matriz triangular inferior [L] y la matriz triangular superior [U].

Pgina 5

PASOS PARA ENCONTRAR LA MATRIZ TRIANGULAR SUPERIOR (MATRIZ [U] 1. Hacer cero todos los valores abajo del pivote sin convertir este en 1. 2. Para lograr lo anterior se requiere obtener un factor el cual es necesario para convertir a cero los valores abajo del pivote. 3. Dicho factor es igual al nmero que se desea convertir en cero entre el nmero pivote. 4. Este factor multiplicado por -1 se multiplica luego por el pivote y a ese resultado se le suma el valor que se encuentra en la posicin a cambiar (el valor en la posicin que se convertir en cero). Esto es: - factor * pivote + posicin a cambiar PASOS PARA ENCONTRAR LA MATRIZ TRIANGULAR NFERIOR (MATRIZ [L]) Para encontrar la matriz triangular inferior se busca hacer ceros los valores de arriba de cada pivote, as como tambin convertir en 1 cada pivote. Se utiliza el mismo concepto de factor explicado anteriormente y se ubican todos los factores debajo de la diagonal segn corresponda en cada uno. Esquemticamente se busca lo siguiente:

Originalmente se tena:

Debido a que [A] = [L][U], al encontrar [L] y [U] a partir de [A] no se altera en nada la ecuacin y se tiene lo siguiente

Pgina 6

Por lo tanto, si Ax = b, entonces LUx = b, de manera que Ax = LUx = b. PASOS PARA RESOLVER UN SISTEMA DE ECUACIONES POR EL MTODO DE DESCOMPOSICIN L 1. Obtener la matriz triangular inferior L y la matriz triangular superior U. 2. Resolver Ly = b (para encontrar y). 3. El resultado del paso anterior se guarda en una matriz nueva de nombre y. 4. Realizar Ux = y (para encontrar x). 5. El resultado del paso anterior se almacena en una matriz nueva llamada x, la cual brinda los valores correspondientes a las incgnitas de la ecuacin.

PROBLEMAS RESUELTOS 1.- Encontrar los valores de x1, x2 y x3 para el siguiente sistema de ecuaciones:

NOTA: Recurdese que si la matriz es 2x2 se har 1 iteracin; si es 3x3, 2 iteraciones; si es 4x4, 3 iteraciones; y as sucesivamente. SOLUCIN: 4 -2 -1 9

Pgina 7

[A] = 5 1

1 2

-1 -4

[B] =

7 12

ITERACIN 1 factor 1 = (a21 / a11) = 5 / 4 = 1.25 factor 2 = (a31 / a11) = 1 / 4 = 0.25 Encontrando [U] fila 2 = - (factor 1) * (fila 1) + (fila 2) fila 3 = - (factor 2) * (fila 1) + (fila 3) a11 = a11 a12 = a12 a13 = a13 a21 = - (1.25) * (4) + (5) = 0 a22 = - (1.25) * (- 2) + (1) = 3.5 a23 = - (1.25) + (- 1) + (- 1) = 0.25 a31 = - (0.25) * (4) + (1) = 0 a32 = - (0.25) * (- 2) + (2) = 2.5 a33 = - (0.25) * (- 1) + (- 1) = - 0.75 4 [U] = 0 0 -2 3.5 2.5 -1 0.25 - 0.75

Pgina 8

Encontrando [L] 1 [L] = 0 0 0 0

1.25 0 0.25 0

ITERACIN 2 factor 3 = (u32 / u22) = 2.5 / 3.5 = 0.7142857143 Encontrando [U] fila 3 = - (factor 3) * (fila 2) + (fila 3) a31 = - (2.5 / 3.5) * (0) + (0) = 0 a32 = - (2.5 / 3.5) * (3.5) + (2.5) = 0 a33 = - (2.5 / 3.5) * (0.25) + (- 0.75) = - 0.9285714286 4 [U] = 0 0 Encontrando [L] -2 3.5 0 -1 0.25 - 0.9285714286

1 [L] =

0 0

1.25 1

0.25 0.7142857143 1

Pgina 9

Ahora ya se tiene la matriz [U] y la matriz [L]. El siguiente paso es resolver Ly = b para encontrar la matriz y. En pocas palabras es como que se pidiera resolver el siguiente sistema de ecuaciones, encontrando los valores de y1, y2 y y3:

Al resolver el sistema anterior, se obtienen los siguientes valores para y1, y2 y y3:

El ltimo paso es resolver Ux = y para encontrar la matriz x. En otras palabras es como que se pidiera resolver el siguiente sistema de ecuaciones, encontrando los valores de x1, x2 y x3:

La solucin del sistema es:

Este es finalmente el valor de x1, x2 y x3; es decir, la respuesta del ejercicio utilizando la descomposicin LU.

Pgina 10

2.- Encontrar los valores de x1, x2 y x3 para el siguiente sistema de ecuaciones:

SOLUCIN: 11 [A] = 5 4 -3 -2 -7 -2 -8 2 [B] = 18 13 2

ITERACIN 1 factor 1 = (a21 / a11) = 5/11 = 0.4545454545 factor 2 = (a31 / a11) = 4/11 = 0.3636363636 Encontrando [U] fila 2 = - (factor 1) * (fila 1) + (fila 2) fila 3 = - (factor 2) * (fila 1) + (fila 3) a11 = a11 a12 = a12 a13 = a13 a21 = - (0.4545454545) * (11) + (5) = 0 a22 = - (0.4545454545) * (- 3) + (- 2) = - 0.6363636365 a23 = - (0.4545454545) + (- 2) + (- 8) = - 7.0909090919 a31 = - (0.3636363636) * (11) + (4) = 0
Pgina 11

a32 = - (0.3636363636) * (- 3) + (- 7) = - 5.909090909 a33 = - (0.3636363636) * (- 2) + (2) = 2.7272727272

11 [U] = 0 0

-3 - 0.6363636365 - 5.909090909

-2 - 7.0909090919 2.7272727272

Encontrando [L] 1 [L] = 0 0 0 0

0.45454545 0 0.36363636 0

ITERACIN 2 factor 3 = (u32/u22) = - 5.909090909 / - 0.6363636365 = 9.285714284 Encontrando [U] fila 3 = - (factor 3) * (fila 2) + (fila 3) a31 = - (9.285714284) * (0) + (0) = 0 a32 = - (9.285714284) * (- 0.6363636365) + (- 5.909090909) = 0 a33 = - (9.285714284) * (- 7.0909090919) + (2.7272727272) = 68.57142857

Pgina 12

11 [U] = 0 0

-3 - 0.6363636365 0

-2 - 7.0909090919 68.57142857

Encontrando [L] 1 [L] = 0 0 0

0.4545454545 1

0.3636363636 9.285714284 1

Ahora ya se tiene la matriz [U] y la matriz [L]. El siguiente paso es resolver Ly = b para encontrar la matriz y. En pocas palabras es como que se pidiera resolver el siguiente sistema de ecuaciones, encontrando los valores de y1, y2 y y3:

Al resolver el sistema anterior, se obtienen los siguientes valores para y1, y2 y y3:

El ltimo paso es resolver Ux = y para encontrar la matriz x. En otras palabras es como que se pidiera resolver el siguiente sistema de ecuaciones, encontrando los valores de x1, x2 y x3:
Pgina 13

La solucin del sistema es:

Este es finalmente el valor de x1, x2 y x3; es decir, la respuesta del ejercicio utilizando la descomposicin LU.

Pgina 14

PROGRAMA DE LU CODIGO FUENTE #include <iostream> #include <iomanip> #include <gsl/gsl_linalg.h> //Librera gsl para calcular lo que queremos using namespace std; //Instruccin para no tener que escribir std::cin int main (int argc, char **argv) { size_t i,j,m; int s; cout<<"\nIntroduce el orden de la matriz: "; cin>>m; gsl_matrix * A = gsl_matrix_alloc(m,m); gsl_permutation * p = gsl_permutation_alloc(m); gsl_matrix *invA = gsl_matrix_alloc(m,m); cout<<"\nIntroduce los elementos de la matriz:"<<endl; for(i=0; i<m*m; i++) { cout<<"A("<<i+1<<")"<<"="; cin>>A->data[i]; } gsl_linalg_LU_decomp (A, p, &s); //Calculo la descomposicin LU gsl_linalg_LU_invert(A,p,invA); // Calculo la inversa de A y la guardo en invA cout<<"\ndet(A) = "<<gsl_linalg_LU_det(A, s)<<endl; cout<<"\nLa inversa de A es:"<<endl; for(i=0; i<m; i++) { for(j=0;j<m; j++) cout<<gsl_matrix_get(invA,i,j)<<setw(10); } cout<<endl; gsl_matrix_free(A); gsl_matrix_free(invA); gsl_permutation_free(p); return(0); }

Pgina 15

METODO DE CHOLESKY En lgebra lineal, la descomposicin de Cholesky o tringulo de Cholesky es una descomposicin de Hermite, definida positiva de la matriz en el producto de una matriz triangular inferior y su transpuesta conjugada. Fue descubierto por Andr-Louis Cholesky para matrices reales. Cuando sea aplicable, la descomposicin de Cholesky es aproximadamente dos veces tan eficiente como la descomposicin LU para resolver sistemas de ecuaciones lineales. En un sentido amplio, metafrico, esto puede considerarse como el anlogo de la matriz de la raz cuadrada de un nmero. Si A tiene entradas reales y es simtrica (o ms generalmente, es hermitiano) y definida positiva, entonces A se puede descomponer como:

Donde L es una matriz triangular inferior con elementos de la diagonal estrictamente positiva, y L * denota la transpuesta conjugada de L . Esta es la descomposicin de Cholesky. La descomposicin de Cholesky es nico: dado un hermitiana, definida positiva matriz A, slo hay una matriz triangular inferior L con entradas diagonales estrictamente positivos tales que A = LL * .Lo contrario es trivial: si A se puede escribir como LL * para algunos invertible L, triangular inferior o de otra manera, entonces A es hermitiana y definida positiva. El requisito de que L tiene entradas de la diagonal estrictamente positiva se puede quitar para ampliar la factorizacin en el caso positivo semidefinida. La declaracin se lee: una matriz cuadrada Atiene una descomposicin de Cholesky si y slo si A es hermitiana y positiva semidefinida. Factorizaciones de Cholesky para matrices semidefinida positiva no son nicas en general. En el caso especial de que A es simtrico definida positiva de la matriz con entradas reales, L tiene entradas reales tambin. La descomposicin de Cholesky se utiliza principalmente para la solucin numrica de ecuaciones lineales Ax = b. Si A es simtrica y definida positiva, entonces podemos resolver Ax = b calculando primero la descomposicin de Cholesky A = LL T, entonces la solucin de Ly = b para y, y, finalmente, la solucin de L T x = y para x. Sistemas de la forma Ax = b con A simtrica y positiva definida surgen muy a menudo en las aplicaciones. Por ejemplo, las ecuaciones normales en al menos lineal plazas problemas son de esta forma. Tambin puede suceder que la
Pgina 16

matriz A proviene de un funcional de energa que debe ser positivo a partir de consideraciones fsicas, lo que ocurre con frecuencia en la solucin numrica de ecuaciones diferenciales parciales. No lineal multivariado funciones pueden ser minimizados por sus parmetros utilizando las variantes del mtodo de Newton se llama cuasi-Newton mtodos. En cada iteracin, la bsqueda da un pasos definido por la resolucin de Hs = -g de s, donde s es el paso, g es el gradiente del vector de derivadas parciales primera de la funcin con respecto a los parmetros, y H es una aproximacin a la matriz hessiana de segundas derivadas parciales formados por repetidas rango 1 actualiza en cada iteracin. Dos conocidas frmulas de actualizacin se llama Davidon-Fletcher-Powell (DFP) y Broydon-Fletcher-GoldfarbShanno (BFGS). La prdida de la condicin definida positiva a travs de errores de redondeo se evita si en lugar de actualizar una aproximacin a la inversa de la de Hesse, una actualizacin de la descomposicin de Cholesky de una aproximacin de la matriz hessiana en s. La descomposicin de Cholesky se usa comnmente en el mtodo de Monte Carlo para la simulacin de sistemas con mltiples variables correlacionadas: La matriz de covarianza se descompone para dar el triangular inferior L. Aplicando esto a un vector de muestras correlacionadas, u, produce un vector de muestras Lu con las propiedades de la covarianza del sistema que se modela. Filtros de Kalman suelen utilizar la descomposicin de Cholesky para elegir un conjunto de los llamados puntos de sigma. El filtro de Kalman sigue el estado medio de un sistema como un vector x de longitud N y covarianza como una N por N de la matriz P. La matriz P es siempre positiva semidefinida, y se puede descomponer en LL T. Las columnas de L pueden sumarse y restarse de la media x para formar un conjunto de 2 N vectores llamados los puntos sigma. Estos puntos sigma totalmente la captura de la media y la covarianza del estado del sistema. El algoritmo de Cholesky, que se utiliza para calcular la matriz descomposicin L , es una versin modificada de la eliminacin de Gauss . El algoritmo recursivo comienza con i : = 1 y de

En el paso i , la matriz A ( i ) tiene la siguiente forma:

Pgina 17

donde I i -1 denota la matriz identidad de dimensin i - 1. Si ahora definimos la matriz L i por

entonces podemos escribir A ( i ) como

donde

Tenga en cuenta que b i b i * es un producto externo, por lo tanto, este algoritmo se llama la versin del producto exterior en (Golub y Van Loan). Repetimos esto para i desde 1 hasta n. Despus de n pasos, se obtiene un ( n +1) = I . Por lo tanto, la matriz triangular inferior L que estamos buscando se calcula como:

El Cholesky-Banachiewicz y algoritmos de Cholesky-Crout Si escribimos la ecuacin A = LL *

se obtiene la siguiente frmula para las entradas de L :

Pgina 18

La expresin en la raz cuadrada es siempre positiva, si A es real y definida positiva. Para el complejo de la matriz hermitiana, la siguiente frmula:

Por lo tanto podemos calcular la ( i , j entrada) si sabemos las entradas a la izquierda y arriba. El clculo es generalmente dispuesto en cualquiera de las siguientes rdenes: El algoritmo de Cholesky-Banachiewicz se inicia desde la esquina superior izquierda de la matriz de L y se procede a calcular la matriz fila por fila. El algoritmo de Cholesky-Crout se inicia desde la esquina superior izquierda de la matriz de L y se procede a calcular la matriz columna por columna.

Una forma alternativa es la factorizacin

Esta forma elimina la necesidad de tomar races cuadradas. Cuando A es definida positiva los elementos de la matriz diagonal D son todos positivos. Sin embargo, esta factorizacin se pueden utilizar para la mayora de las matrices simtricas invertible; un ejemplo de una matriz invertible cuya descomposicin no est definido es aquel en la primera entrada es cero. Si A es real, las relaciones recursivas se aplicarn las siguientes entradas de D y L:
Pgina 19

Para el complejo hermitiano matriz A , la siguiente frmula:

El LDL T y LL T factorizaciones (tenga en cuenta que L es la diferencia entre los dos) puede ser fcilmente relacionada con:

La ltima expresin es el producto de una matriz triangular inferior y su transposicin, como es el LL T factorizacin. Los algoritmos anteriores muestran que cada matriz definida positiva A tiene una descomposicin de Cholesky. Este resultado se puede extender al positivo semidefinido caso por un argumento de la limitacin. El argumento no es totalmente constructivo, es decir, no da algoritmos numricos explcitos para el clculo de factores de Cholesky. Si A es un n -por- n positiva semi-definida de la matriz, entonces la sucesin { A k } = { A + (1 / k ) I n } consiste en matrices definidas positivas. (Esto es una consecuencia inmediata de, por ejemplo, el teorema de espectro para el clculo funcional polinomio.) Adems, en norma del operador. Desde el caso definido positivo, cada una k tiene descomposicin de Cholesky A k = L k L k *. Pr la propiedad de la norma de operador, por lo tanto { L k } es un conjunto acotado en el espacio de Banach de los operadores, por lo tanto, relativamente compacto (porque el espacio vectorial subyacente es de dimensin finita). En consecuencia, tiene una subsucesin convergente, tambin se denota por { L k }, con un lmite L . Se puede comprobar fcilmente que L tiene las propiedades deseadas, es decir, A = LL * y L es triangular inferior con no negativo elementos de la diagonal: para todos los x , y y ,
Pgina 20

Por lo tanto A = LL * . Debido a que el espacio vectorial subyacente es de dimensin finita, todas las topologas en el espacio de los operadores son equivalentes. Por lo tanto L k tiende a L en la norma significa que L k tiende a Lentrywise. Esto a su vez implica que, dado que cada L k es triangular inferior con no negativo elementos de la diagonal, L tambin. La factorizacin de Cholesky se puede generalizar a (no necesariamente finito) matrices con entradas del operador. Vamos a de espacios de Hilbert. Considere la matriz del operador ser una secuencia

que acta sobre la suma directa

donde cada

es un operador acotado . Si A es positiva (semidefinida) en el sentido de que para todos los finitos k y para cualquier

tenemos , entonces existe un operador de la matriz triangular inferior L tal que A = LL * . Uno tambin puede tomar los elementos diagonales de L a ser positivo.

Pgina 21

CODIGO FUENTE PROGRAMA DEL METODO DE CHOLESKY #include <math.h> #include <tina/sys.h> #include <tina/sysfuncs.h> #include <tina/math.h> #include <tina/mathfuncs.h> #define TINY 1.0e-20 static int cholesky1(double **A, int n) { int i, j, k; for (i = 0; i < n; ++i) { for (j = 0; j <= i; ++j) { double sum = A[i][j]; A[j][i] = 0; for (k = 0; k < j; ++k) sum -= A[i][k] * A[j][k]; /* computed previously */ if (i == j) { if (sum < 0) return (0); sum = sqrt(sum); if (fabs(sum) < TINY) return (0); A[i][j] = sum; } else A[i][j] = sum / A[j][j]; } } return (1); } #undef TINY static void cholbksb(double **A, int n, double *x, double *b) { int i, j; double sum; for (i = 0; i < n; i++) { sum = b[i];
Pgina 22

for (j = 0; j < i; ++j) sum -= x[j] * A[i][j]; x[i] = sum / A[i][i]; } for (i = n - 1; i >= 0; i--) { sum = x[i]; for (j = i + 1; j < n; j++) sum -= x[j] * A[j][i]; x[i] = sum / A[i][i]; } } Matrix *matrix_cholesky_decomp(Matrix * A) { if (A == NULL || A->n != A->m) return (NULL); A = matrix_cast_fill(A, double_v); if (!cholesky1 (A->el.double_v, A->n)) { matrix_free((Matrix *) A); return (NULL); } return (A); } Vector *matrix_cholesky_back_sub(Matrix * A, Vector * b) { int n; Vector *x = NULL; Vector *c = NULL; if (A == NULL || A->n != A->m) return (NULL); n = A->n; if (b == NULL || b->n != n) return (NULL); A = matrix_cast_fill(A, double_v); c = vector_cast(b, double_v); x = vector_alloc(n, double_v); cholbksb (A->el.double_v, n, (double *) x->data, (double *) c->data); vector_free(c); matrix_free((Matrix *) A); return (x); } Vector *matrix_cholesky_sol(Matrix * A, Vector * b)
Pgina 23

{ int n; int sucess; Vector *x = NULL; Vector *c = NULL; if (A == NULL || A->n != A->m) return (NULL); n = A->n; if (b == NULL || b->n != n) return (NULL); A = matrix_cast_fill(A, double_v); sucess = cholesky1(A->el.double_v, n); if (sucess) { c = vector_cast(b, double_v); x = vector_alloc(n, double_v); cholbksb(A->el.double_v, n, (double *) x->data, (double *) c->data); vector_free(c); } matrix_free((Matrix *) A); return (x); } Vector *matrix_cholesky_weighted_least_square(Matrix * A, Matrix * W, Vector * b) { Matrix *At; Matrix *M; Matrix *temp; Vector *x; if (A == NULL || A->m != b->n || W == NULL || W->n != W->m || W->m != A->m) return (NULL); A = matrix_cast_fill(A, double_v); /* to maintain precision */ At = matrix_transp(A); x = matrix_vprod(W, b); b = matrix_vprod(At, x); vector_free(x); temp = matrix_prod(W, A); M = matrix_prod(At, temp); matrix_free((Matrix *) temp); x = matrix_cholesky_sol(M, b); vector_free(b); matrix_free((Matrix *) A); matrix_free((Matrix *) At); matrix_free((Matrix *) M); return (x); } Vector *matrix_cholesky_least_square(Matrix * A, Vector * b) {
Pgina 24

Matrix *At; Matrix *M; Vector *x; if (A == NULL || b == NULL || A->m != b->n) return (NULL); A = matrix_cast_fill(A, double_v); /* to keep precision */ At = matrix_transp(A); b = matrix_vprod(At, b); M = matrix_prod(At, A); x = matrix_cholesky_sol(M, b); vector_free(b); matrix_free((Matrix *) A); matrix_free((Matrix *) At); matrix_free((Matrix *) M); return (x); }

Pgina 25

METODO DE CHEBYSHEV Para cada valor de n, cul ser la mejor forma de elegir los nodos? Aquella para la cual el valor mximo de |(x)| sea lo ms pequeo posible: min {max {|(xx1)(x- x2) (x- xn+1)j : a x b} : a x1 < x2 < < xn+1 b} Para resolver esta cuestin podemos restringirnos, haciendo una traslacin y un cambio de escala si es necesario, al intervalo [-1, 1]. La solucin viene dada mediante los polinomios de Chebyshev {Tn+1(x)}, donde Tn+1(x) = cos((n+1) arccos(x)). Recordemos que la funcinTn+1(x) es la solucin polinomica de la ecuacin diferencial (1 - x2)y xy + (n + 1)2y = 0 cuyo coeficiente lder es 2n. La forma ms fcil de construirlos es mediante la relacin de recurrencia: T0(x) = 1; T1(x) = x; Tn+1(x) = 2xTn(x) - Tn-1(x), (n = 1, 2, ). Los polinomios de Chebyshev tienen muchas propiedades interesantes. La que a nosotros nos concierne es que el valor absoluto mximo de 2-n Tn+1(x) para x [-1; 1] es 2-n y que, adems, es el polinomio con menor mximo absoluto de entre todos los polinomios con coeficiente lder igual a 1; en otras palabras, que 2-n Tn+1(x) es la solucin al problema anterior o, equivalentemente, que los mejores nodos posibles son las n + 1 races simples de Tn+1: ( ( ) ( ) )

que se llaman nodos de Chebyshev del intervalo [-1, 1]. Como ya hemos indicado, para trabajar en un intervalo cualquiera hay que hacer un cambio de variable lineal que nos lleve el intervalo [-1, 1] a nuestro intervalo de trabajo [a; b]: [ ] ( ) [ ]

entonces los nodos de Chebyshev en [a; b] son los puntos z(xi) (i = 1, 2, , n +1). Error de interpolacin ( ) ( ) ( ) )( ) ( )

Ntese que segn cmo se elijan los x i el error podr ser mayor o menor

Pgina 26

PROBLEMAS RESUELTOS 1.-Dada la funcin ( ) en el intervalo [-5,5]

Si construimos el polinomio de interpolacin pn(x) en este intervalo, entonces seguro que no hay convergencia en los puntos donde |x|>3.63. Resulta que para ciertas funciones, por ejemplo para f(x)=exp(x), si hay convergencia. Pero para otras no.

El problema con estas ltimas es que sus derivadas van creciendo demasiado en el intervalo considerado, esto es lo que sucede con esta funcin de Runge, que pareca al principio bastante inofensiva. En las figuras que siguen mostramos este comportamiento:

Aproximamos la funcin por el polinomio de interpolacin que pasa por los puntos en asterisco. Se puede observar que la aproximacin es mala cerca de los extremos del intervalo

Ya que la aproximacin es mala en los extremos del intervalo, una idea para mejorar la aproximacin es la de olvidarnos de tomar nodos igualmente
Pgina 27

espaciados y tomar nodos que se concentren ms cerca de los extremos. De este modo al obligar al polinomio pn(x) a pasar por estos puntos quizs se mejore la aproximacin. Su inters en la teora de la aproximacin naci porque Chebyshev que era profesor de matemticas en San Petersburgo, fue profesor all durante 35 aos, viaj en 1852 a Paris y a Inglaterra donde estuvo muy interesado en la mquina de vapor. Poco antes, James Watt haba mejorado mucho el mecanismo de los pistones de la mquina. El mecanismo funciona principalmente porque el pistn, que tiene un movimiento de vaivn rectilneo, se tiene que transformar luego en circular, porque la mquina al final tiene que mover una rueda. Esto se consigue por una serie de varillas articuladas (linkages) que convierten movimiento rectilneo en circular. Sin embargo, a pesar de que Watt haba conseguido una buena aproximacin, se presentaban numerosos problemas. Esto era principalmente porque si miramos el movimiento al revs, es decir, de circular al girar una rueda que se transforme mediante una serie de brazos articulados en rectilneo, el movimiento que resulta nos es completamente lineal, sino que presenta oscilaciones (curva de Watt), ello haca que se resintiera la mquina.

Ahora tomamos los nodos de Chebyshev y la aproximacin se hace en el intervalo [-1 1] (para mayor comodidad ya que los ceros de Chebyshev se definen en este intervalo y no hay que hacer cambio de variable). Obsrvese que los nodos estn ms concentrados hacia los extremos del intervalo.

Pgina 28

Mecanismo de Peaucellier, est formado por una serie de brazos articulados, donde C est fijo y los dems son pivotes movibles. Cuando el punto F' describe una lnea, el otro punto F traza una circunferencia. El polinomio de Chebyshev de grado n se denota Tn (x), y se le da la frmula explcita Tn (x) = cos (n arc cos x) Sin embargo se puede combinar con las identidades trigonomtricas para producir expresiones explicitas para Tn(x): A (x) = 1 T1 (x) = X T2 (X) = 2x2 - 1 (5.6.2) T3 (x) = 4x3 - 3x T4 (x) = 8x4 - 8x2 + 1

Pgina 29

CODIGO FUENTE PROGRAMA DEL METODO DE CHEBYSHEV # Include <iostream.h> # Include <math.h> # Define NMAX 51 # Define MEDIA 0.5 # Define UN 1,0 # Define CUARTO 0,25 # Define DOS 2.0 # Define CERO 0.0 # Define PI 4.0 * atan (1.0) doble funcin (double x); CHEBFT void (doble A, doble B, double * C, int N) { suma doble, F [NMAX]; doble BMA, BPA, FAC, Y; Int J, K; BMA = Media * (B-A); BPA = Media * (B + A); for (K = 1, K <= N, K + +) { Y = cos (PI * (K-MEDIA) / N); F [K] = FUNC (BMA Y * + BPA); } FAC = DOS / N; for (j = 1, J <= N, J + +) { = SUMA CERO; if (K = 1, K <= N, K + +) SUMA + = F [K] * cos ((PI * (J-1 ))*(( K-MEDIA) / N)); C [J] = SUMA * FAC; } } CHEBEV doble (doble A, doble B, double * C, M int, double x) { doble D, DD, SV, Y, Y2; Int J; if ((XA) * (RE)> ZERO) printf ("\ n X, no en el rango \ n \ n".) D = CERO; DD = CERO; Y = (X * DOS-A-B) / (B-A) Y2 = DOS * Y; for (j = M, J> 1, J -) {
Pgina 30

SV = D; D = Y2 * D-DD + C [J]; DD = SV; } return (Y * D-DD + MEDIA * C [1]); } CHINT void (doble A, doble B, double * C, el doble * CINT, int N) { CON doble, FAC, SUM; Int J; CON CUARTO * = (B-A); = SUMA CERO; FAC = UNO; for (j = 2; J <N, J + +) { CINT [J] = CON * (C [J-1]-C [J +1]) / (J-1); SUMA + = FAC * CINT [J]; =- FAC FAC; } CINT [N] = CON C * [N-1] / (N-1); SUMA + = FAC * CINT [N]; CINT [1] = SUMA DOS * / / ajustar la constante de integracin } CHDER void (doble A, doble B, double * C, el doble * CDER, int N) { CON doble; Int J; CDER [N] = CERO; CDER [N-1] = DOS * (N-1) * C [N]; if (N> = 3) for (j = N-2, J> 0, J -) CDER [J] = CDER [J 2] + DOS * J * C [J +1]; CON DOS = / (B-A); for (j = 1, J <= N, J + +) CDER [J] *= CON; }

Pgina 31

METODO DE HERMITE Definimos los polinomios de Hermite por:

son polinomios de grado n. Se tiene que:

es decir, Hn es par si n es par, e impar si n es impar. Los primeros polinomios de Hermite son: H0 (t) = 1 H1 (t) = 2t H2 (t) = 4t2 - 2 H3 (t) = 8t3 -12t H4 (t) = 16t4 - 48t2 + 12 Consideremos la funcin

Su relacin en serie de Taylor ser:

Como:

Se tiene:

Luego

Pgina 32

Se dice que e2tx-x2 es la funcin generatriz de los polinomios de Hermite, vale decir, es aquella funcin de dos variables tal que su desarrollo de Taylor en una de las variables tiene como coeficientes precisamente los polinomios de Hermite. A partir de la ecuacin anterior se pueden encontrar relaciones entre los polinomios de Hermite. La estrategia para hallarlas (para _esta o cualquier otra funcin generatriz de otros polinomios) es tpica: derivar parcialmente respecto a alguna de las variables y luego comparar potencias de x en los desarrollos en Taylor resultantes. 1) Derivando respecto a t

Reordenando la suma en el lado izquierdo

Comparando los coeficientes de las potencias de x en cada serie encontramos:

La cual puede ser reescrito en la forma

Pgina 33

Observemos que, si bien solo tiene sentido considerar polinomios de Hermite con ndice positivo, la expresin anterior puede ser extendida a n = 0, aunque ello haga aparecer un factor H-1. En general, las relaciones de recurrencia que obtendremos pueden considerarse validas para cualquier ndice entero, adoptando la convencin de que los polinomios con subndices negativos tienen algn valor adecuado, por ejemplo, cero. La relacin anterior expresa un polinomio de Hermite en trminos de un operador (en este caso la derivada) aplicado sobre el polinomio de Hermite inmediatamente superior. Un operador que tiene tal propiedad se denomina operador de bajada. En este caso, el operador de bajada de los polinomios de Hermite es (2n) -1dt 2) Derivando respecto a x

Comparando potencias de x:

O bien

3) Podemos utiliza las dos relaciones de recurrencia anteriores para obtener una tercera

Hemos pues encontrado el operador de subida para los polinomios de Hermite, a saber, 2t - dt.
Pgina 34

Derivando la tercera relacin:

Con:

O sea,

Es decir el, los polinomios Hn son una solucin de la ecuacin de Hermite

Consideremos la ecuacin de Hermite, pero generalicmosla ligeramente:

Busquemos soluciones con un cierto desarrollo de Taylor:

Remplazando en la ecuacin de Hermite

es decir, obtenemos una relacin de recurrencia para los coeficientes de la serie:

Se desprenden las siguientes consecuencias:


Pgina 35

a) Hay dos series independientes, la de coeficientes con ndice par, que depende slo de a0, y la de coeficientes con ndice impar, que depende slo de a1. Por tanto, hay dos coeficientes arbitrarios, a0 y a1, y por ende dos soluciones linealmente independientes

b) Lo cual significa que el radio de convergencia de la serie es infinito. Vale decir, las soluciones no tienen singularidades en el plano c) La ecuacin tiene por solucin un polinomio slo si N*. Si es par, hay que tomar a0 0 y a1 = 0. Si es impar, hay que tomar a1 0 y a0 = 0. d) Si N*, y si la solucin es par o impar, entonces desde cierto V0 en adelante, de modo que los av tiene todos el mismo signo para V > V0. Esto es, la serie tiene un crecimiento rpido cuando t PROBLEMAS RESUELTOS 1.- Utilizar el mtodo de Hermite para hallar un polinomio P(x) de grado 2 que satisfaga: p(1) = 0, p(1) = 7, p(2) = 10 Como existe la derivada del polinomio p(x), quiere decir que el mtodo a utilizar es el de hermite X 1 1 2 P(x) 0 0 10

7 P[1,2] = 10

P[1,1,2]= 3

P[1,2] = 10 Por lo tanto P(x)= 7(x - 1) + 3(x - 1)2 P(x)= 3x2 + x 4 que satisface las condiciones dadas 2.- Sea P(x)= 3 + (x 1) + 1/3(x 1)(x 1.5) 2x(x 1)(x 1.5)x, Q(x) = 5/3 2/3(x 2) 5/3(x 2)(x 1.5)(x 2). Obtener las tablas de diferencias divididas que dan origen a P(x) y Q(x) respectivamente
Pgina 36

Lo que nos indica que los polinomios son iguales, entonces si evaluamos un punto P(x), ser igual que si lo evaluamos en Q(x) P(xi) = Q(xi), que pertenece i,i = {0,1,1.5,2} X 1 1.5 0 A X 2 0 1.5 b P(x) 3 P(1.5) P(0) P(a) Q(X) 5/3 Q(0) Q(1.5) Q(b)

1/2 P[1.5, 0] P[0, a]

1/3 P[1.5, 0, a]

-2

-2/3 Q[0, 1.5] Q[1.5, b]

-5/3 Q[0, 1.5, b]

-2

Si vemos las tablas, la de P(x), esta tiene los puntos {1, 1.5, 0, a} y la de Q(x) tiene {2, 0, 1.5, b} b= 1; Q(b=1)= 3 y a= 2; P(a=2)= 5/3

PROBLEMAS PROPUESTOS 1.- Se sabe que H4(X)= 4 + 3(x + 1) 2(x + 1)2 + 3/2(x + 1)2(x 1) (x 1)2 (x 1)2 es el polinomio de interpolacin de Hermite de cierta funcin f, basado en los datos f(-1), f(-1), f(1), f(1) y f(1) Sin evaluar H4(x) ni sus derivadas en -1 y 1, completar la tabla de diferencias divididas con repeticin utilizada en la construccin de H4(x) 2.- Probar que si g interpola a la funcin f en x0, x1, , xn-1 y h interpola a f x0, x1, , xn-1, xn en entonces a la funcin g(x) + (x0 x/ xn x0)(g(x) h(x)) interpola a f x0, x1, , xn-1, xn en notar que h y g no necesitan ser polinomios).

Pgina 37

METODO DE INTERPOLACION DE NEWTON El mtodo de Newton de diferencias divididas es otra forma de obtener el polinomio interpolador. En este mtodo el polinomio interpolador se escribe de la forma:

Y el algoritmo proporciona una regla para obtener los coeficientes a0, a1,..., an. Imponiendo que el polinomio interpolador pase por los puntos de interpolacin obtenemos:

De estas ecuaciones, es obvio que a0 depende slo de x0, a1 de x0 y x1 y as sucesivamente. Introducimos la nueva notacin:

Restando las dos primeras ecuaciones obtenemos:

Restando la segunda y la tercera ecuacin obtenemos:

Podemos proceder de igual modo para demostrar que:

Aunque la forma ms cmoda es por induccin construimos un polinomio de grado n definido por:

Relacionando nuestro polinomio interpolador, la ecuacin estara dada por:

Pgina 38

Relacin que es el origen del nombre de diferencias divididas para los coecientes an. Podemos por lo tanto escribir el polinomio interpolador como:

Y la formula de aproximacin de f(x) queda en la siguiente forma:

f (x0), como se ve de la primera ecuacin. Restando las dos primeras ecuaciones obtenemos PROBLEMAS RESUELTOS 1. Se desea interpolar los siguientes datos mediante el polinomio de Newton para x = 5.2.

Primero, calculamos la tabla de diferencias divididas:

Ahora evaluamos el polinomio de Newton:

Pgina 39

PROBLEMAS PROPUESTOS 1.-Da los siguientes datos de las temperaturas (en C ) Entre las 8.00 am a 8.00 pm. el 10 de mayo de 2005, en Kanpur: Tiempo 8 a.m. Temperatura 30 37 12 horas 43 38 16:00 20:00

Obtener polinomio de interpolacin de Newton hacia atrs de grado para calcular la temperatura en Kanpur en ese da a las 5.00 pm. 2.-La velocidad de un tren, que corre entre dos estaciones se mide a diferentes distancias de la estacin de partida. Si x es la distancia en km de la estacin de partida, a continuacin v(x), la velocidad (en km/hr ) Del tren en la distancia x est dada por la siguiente tabla: x v (x) 0 0 50 60 100 80 150 110 200 90 250 0

Encontrar la velocidad aproximada del tren en el punto medio entre las dos estaciones.

Pgina 40

CODIGO FUENTE PROGRAMA DE METODO DE NEWTON # include <iostream.h> # include <stdlib.h> # include <string.h> # include <stdio.h> # include <conio.h> # include <math.h> const int max_size=13; int n=0; int top=-1; int choice=0; long double xn[max_size]={0}; long double px[max_size]={0}; long double dd_table[max_size][max_size]={0}; char Non_linear_equation[100]={NULL}; char Stack[30][30]={NULL}; char Postfix_expression[30][30]={NULL}; void push(const char *); void convert_infix_expression_to_postfix_expression(const char *); const char* pop( ); const long double evaluate_postfix_expression(const long double); void show_screen( ); void clear_screen( ); void get_input( ); void construct_dd_table( ); void show_dd_table( ); void compute_newtons_dd_interpolation_polynomial( ); void estimate_pnx( ); int main( ) { clrscr( ); textmode(C4350); show_screen( ); get_input( ); construct_dd_table( ); show_dd_table( ); compute_newtons_dd_interpolation_polynomial( ); estimate_pnx( ); return 0; }
Pgina 41

void show_screen( ) { textbackground(1); cprintf(" Newton's Divided Difference Interpolation Formula "); textbackground(8); for(int count=0;count<42;count++) cprintf("* *"); gotoxy(1,46); cprintf("********************************************************************************"); gotoxy(1,2); } void clear_screen( ) { for(int count=0;count<37;count++) { gotoxy(3,8+count); cout<<" } gotoxy(1,2); } void push(const char* Operand) { if(top==(max_size-1)) { cout<<"Error : Stack is full."<<endl; cout<<"\n Press any key to exit."; getch( ); exit(0); } else { top++; strcpy(Stack[top],Operand); } } const char* pop( ) { char Operand[40]={NULL}; if(top==-1) { cout<<"Error : Stack is empty."<<endl; cout<<"\n Press any key to exit.";
Pgina 42

";

getch( ); exit(0); } else { strcpy(Operand,Stack[top]); strset(Stack[top],NULL); top--; } return Operand; } void convert_infix_expression_to_postfix_expression(const char* Expression) { char Infix_expression[100]={NULL}; char Symbol_scanned[30]={NULL}; push("("); strcpy(Infix_expression,Expression); strcat(Infix_expression,"+0)"); int flag=0; int count_1=0; int count_2=0; int equation_length=strlen(Infix_expression); if(Infix_expression[0]=='(') flag=1; do { strset(Symbol_scanned,NULL); if(flag==0) { int count_3=0; do { Symbol_scanned[count_3]=Infix_expression[count_1]; count_1++; count_3++; } while(count_1<=equation_length && Infix_expression[count_1]!='(' && Infix_expression[count_1]!='+' && Infix_expression[count_1]!='-' && Infix_expression[count_1]!='*' && Infix_expression[count_1]!='/' && Infix_expression[count_1]!='^' && Infix_expression[count_1]!=')'); flag=1; }
Pgina 43

else if(flag==1) { Symbol_scanned[0]=Infix_expression[count_1]; count_1++; if(Infix_expression[count_1]!='(' && Infix_expression[count_1]!='^' && Infix_expression[count_1]!='*' && Infix_expression[count_1]!='/' && Infix_expression[count_1]!='+' && Infix_expression[count_1]!='-' && Infix_expression[count_1]!=')') flag=0; if(Infix_expression[count_1-1]=='(' && (Infix_expression[count_1]=='-' || Infix_expression[count_1]=='+')) flag=0; } if(strcmp(Symbol_scanned,"(")==0) push("("); else if(strcmp(Symbol_scanned,")")==0) { while(strcmp(Stack[top],"(")!=0) { strcpy(Postfix_expression[count_2],pop( )); count_2++; } pop( ); } else if(strcmp(Symbol_scanned,"^")==0 || strcmp(Symbol_scanned,"+")==0 || strcmp(Symbol_scanned,"-")==0 || strcmp(Symbol_scanned,"*")==0 || strcmp(Symbol_scanned,"/")==0) { if(strcmp(Symbol_scanned,"^")==0) { } else if(strcmp(Symbol_scanned,"*")==0 || strcmp(Symbol_scanned,"/")==0) { while(strcmp(Stack[top],"^")==0 || strcmp(Stack[top],"*")==0 || strcmp(Stack[top],"/")==0) { strcpy(Postfix_expression[count_2],pop( ));
Pgina 44

count_2++; } } else if(strcmp(Symbol_scanned,"+")==0 || strcmp(Symbol_scanned,"-")==0) { while(strcmp(Stack[top],"(")!=0) { strcpy(Postfix_expression[count_2],pop( )); count_2++; } } push(Symbol_scanned); } else { strcat(Postfix_expression[count_2],Symbol_scanned); count_2++; } } while(strcmp(Stack[top],NULL)!=0); strcat(Postfix_expression[count_2],"="); count_2++; } const long double evaluate_postfix_expression(const long double x) { long double function_value=0; int count_1=-1; char Symbol_scanned[30]={NULL}; do { count_1++; strcpy(Symbol_scanned,Postfix_expression[count_1]); if(strcmp(Symbol_scanned,"^")==0 || strcmp(Symbol_scanned,"*")==0 ||
Pgina 45

strcmp(Symbol_scanned,"/")==0 || strcmp(Symbol_scanned,"+")==0 || strcmp(Symbol_scanned,"-")==0) { char Result[30]={NULL}; char Operand[2][30]={NULL}; strcpy(Operand[0],pop( )); strcpy(Operand[1],pop( )); long double operand[2]={0}; long double result=0; char *endptr; for(int count_2=0;count_2<2;count_2++) { int flag=0; if(Operand[count_2][0]=='-') { int length=strlen(Operand[count_2]); for(int count_3=0;count_3<(length-1);count_3++) Operand[count_2][count_3]=Operand[count_2][(count_3+1)]; Operand[count_2][count_3]=NULL; flag=1; } if(strcmp(Operand[count_2],"x")==0) operand[count_2]=x; else if(strcmp(Operand[count_2],"e")==0) operand[count_2]=2.718282; else if(strcmp(Operand[count_2],"sinx")==0) operand[count_2]=sinl(x); else if(strcmp(Operand[count_2],"cosx")==0) operand[count_2]=cosl(x); else if(strcmp(Operand[count_2],"tanx")==0) operand[count_2]=tanl(x);
Pgina 46

else if(strcmp(Operand[count_2],"lnx")==0) operand[count_2]=logl(x); else if(strcmp(Operand[count_2],"logx")==0) operand[count_2]=log10l(x); else operand[count_2]=strtod(Operand[count_2],&endptr); if(flag) operand[count_2]*=-1; } switch(Symbol_scanned[0]) { case '^' : result=powl(operand[1],operand[0]); break; case '*' : result=operand[1]*operand[0]; break; case '/' : result=operand[1]/operand[0]; break; case '+' : result=operand[1]+operand[0]; break; case '-' : result=operand[1]-operand[0]; break; } gcvt(result,25,Result); push(Result); } else if(strcmp(Symbol_scanned,"=")!=0) push(Symbol_scanned); } while(strcmp(Symbol_scanned,"=")!=0); char Function_value[30]={NULL}; char *endptr; strcpy(Function_value,pop( )); function_value=strtod(Function_value,&endptr);
Pgina 47

return function_value; } void get_input( ) { do { clear_screen( ); gotoxy(6,9); cout<<"Number of Distinct Data Points :"; gotoxy(6,10); cout<<""; gotoxy(27,13); cout<<"[ min. n = 2 | max. n = 12 ]"; gotoxy(6,12); cout<<"Enter the max. number of distinct data points = n = "; cin>>n; if(n<2 || n>12) { gotoxy(12,25); cout<<"Error : Wrong Input. Press <Esc> to exit or any other key"; gotoxy(12,26); cout<<" to try again."; n=int(getche( )); if(n==27) exit(0); } } while(n<2 || n>12); gotoxy(6,19); cout<<"Input Mode :"; gotoxy(6,20); cout<<""; gotoxy(8,23);
Pgina 48

cout<<"Press : "; gotoxy(10,25); cout<<"- 'Y' or <Enter> to enter function"; gotoxy(10,27); cout<<"- 'N' or <Any other key> to enter values of the function"; gotoxy(8,30); cout<<"Enter your choice : "; char Choice=NULL; Choice=getch( ); if(Choice=='y' || Choice=='Y' || int(Choice)==13) { choice=1; gotoxy(28,30); cout<<"Y"; } else { gotoxy(28,30); cout<<"N"; } gotoxy(25,43); cout<<"Press any key to continue..."; getch( ); if(choice) { clear_screen( ); gotoxy(6,11); cout<<"Non-Linear Function :"; gotoxy(6,12); cout<<""; gotoxy(6,37); cout<<"Note : Write the function with proper Braces ( ) e.g; 2x+3 as (2*x)+3";
Pgina 49

gotoxy(6,40); cout<<"Available Operators : ^ (raised to power) , * , / , + , -"; gotoxy(6,42); cout<<"Available Operands : x , e , sinx , cosx , tanx , lnx , logx ,"; gotoxy(6,44); cout<<"

n = any number";

gotoxy(6,14); cout<<"Enter the Function : f(x) = "; cin>>Non_linear_equation; convert_infix_expression_to_postfix_expression(Non_linear_equation); } clear_screen( ); gotoxy(6,9); cout<<"Data Points & Values of Function :"; gotoxy(6,10); cout<<""; gotoxy(25,12); cout<<""; gotoxy(25,13); cout<<" x

f(x)

";

gotoxy(25,14); cout<<""; gotoxy(25,15); cout<<"

";

for(int count_1=0;count_1<n;count_1++) { gotoxy(25,(wherey( )+1)); cout<<" "; gotoxy(25,(wherey( )+1)); cout<<" }


Pgina 50

";

gotoxy(25,(wherey( )+1)); cout<<""; gotoxy(25,16); for(int count_2=0;count_2<n;count_2++) { gotoxy(27,wherey( )); cin>>xn[count_2]; if(choice) { dd_table[0][count_2]=evaluate_postfix_expression(xn[count_2]); gotoxy(43,(wherey( )-1)); cout<<dd_table[0][count_2]; } else { gotoxy(43,(wherey( )-1)); cin>>dd_table[0][count_2]; } if(choice) gotoxy(25,(wherey( )+2)); else gotoxy(25,(wherey( )+1)); } gotoxy(25,43); cout<<"Press any key to continue..."; getch( ); }

void construct_dd_table( ) { for(int count_1=1;count_1<n;count_1++) { for(int count_2=count_1;count_2<n;count_2++) { long double fx1=dd_table[(count_1-1)][(count_2-1)]; long double fx2=dd_table[(count_1-1)][count_2]; long double x1=xn[(count_2-count_1)];
Pgina 51

long double x2=xn[count_2]; dd_table[count_1][count_2]=((fx2-fx1)/(x2-x1)); } } }

void show_dd_table( ) { clear_screen( ); gotoxy(4,10); cout<<"Divided Difference Table :"; gotoxy(4,11); cout<<""; gotoxy(4,13); cout<<""; gotoxy(4,14); cout<<" x

f(x)

";

gotoxy(4,15); cout<<""; gotoxy(4,16); cout<<" int x_cord=4; int y_cord=17; for(int count_1=0;count_1<n;count_1++) { gotoxy(x_cord,y_cord); cout<<" "; gotoxy(x_cord,(y_cord+1)); cout<<" "; gotoxy((x_cord+2),y_cord); cout<<xn[count_1]; gotoxy((x_cord+11),y_cord); cout<<dd_table[0][count_1];
Pgina 52

";

y_cord+=2; } gotoxy(x_cord,y_cord); cout<<""; x_cord=28; int count_2=0; for(int count_3=1;count_3<n;count_3++) { gotoxy(x_cord,13); cout<<""; gotoxy(x_cord,14); cout<<""; gotoxy(x_cord,15); cout<<""; gotoxy(x_cord,16); cout<<""; gotoxy(x_cord,y_cord); cout<<""; gotoxy((x_cord+6),14); cout<<count_3; if(count_3==1) cout<<"st"; else if(count_3==2) cout<<"nd"; else if(count_3==3) cout<<"rd"; else cout<<"th"; y_cord=17; for(int count_4=0;count_4<n;count_4++) { gotoxy(x_cord,y_cord);
Pgina 53

cout<<""; gotoxy(x_cord,(y_cord+1)); cout<<""; if(count_4>=count_3) { gotoxy((x_cord+2),(y_cord-count_3)); cout<<dd_table[count_3][count_4]; } y_cord+=2; } x_cord+=16; count_2++; if((count_2%3)==0 && count_3<(n-1)) { gotoxy(x_cord,13); cout<<""; gotoxy(x_cord,14); cout<<""; gotoxy(x_cord,15); cout<<""; gotoxy(x_cord,16); cout<<""; gotoxy(x_cord,y_cord); cout<<""; y_cord=17; for(int count_5=0;count_5<n;count_5++) { gotoxy(x_cord,y_cord); cout<<""; gotoxy(x_cord,(y_cord+1)); cout<<""; y_cord+=2; }
Pgina 54

gotoxy(30,44); cout<<"Press any key to continue..."; getch( ); y_cord=13; x_cord=28; for(int count_6=0;count_6<=(n+2);count_6++) { gotoxy(x_cord,y_cord); cout<<" "; gotoxy(x_cord,(y_cord+1)); cout<<" y_cord+=2; } y_cord-=2; count_2=0; count_3--; } } gotoxy(x_cord,13); cout<<""; gotoxy(x_cord,14); cout<<""; gotoxy(x_cord,16); cout<<""; y_cord=17; for(int count_6=0;count_6<n;count_6++) { gotoxy(x_cord,y_cord); cout<<""; gotoxy(x_cord,(y_cord+1)); cout<<""; y_cord+=2; }
Pgina 55

";

gotoxy(x_cord,15); cout<<""; gotoxy(x_cord,y_cord); cout<<""; gotoxy(30,44); cout<<"Press any key to continue..."; getch( ); } void compute_newtons_dd_interpolation_polynomial( ) { for(int count_1=0;count_1<n;count_1++) xn[count_1]=(xn[count_1]*(-1)); px[0]=dd_table[0][0]; for(int count_2=1;count_2<n;count_2++) { long double fx[max_size]={0}; fx[0]=xn[0]; fx[1]=1; for(int count_3=0;count_3<(count_2-1);count_3++) { fx[(count_3+2)]=1; for(int count_4=(1+count_3);count_4>0;count_4--) { fx[count_4]*=xn[(count_3+1)]; fx[count_4]+=fx[(count_4-1)]; } fx[0]*=xn[(count_3+1)]; } for(int count_5=0;count_5<(count_2+1);count_5++) fx[count_5]*=dd_table[count_2][count_2]; for(int count_6=0;count_6<(count_2+1);count_6++) px[count_6]+=fx[count_6]; } }
Pgina 56

void estimate_pnx( ) { clear_screen( ); gotoxy(6,10); cout<<"Newton's Divided Difference Interpolation Formula :"; gotoxy(6,11); cout<<""; gotoxy(10,13); cout<<"P"<<(n-1)<<"(x) = "; for(int count_1=(n-1);count_1>=0;count_1--) { if(count_1==(n-1) && n>2) cout<<px[count_1]<<" x"<<count_1; else if(count_1>1) cout<<fabs(px[count_1])<<" x"<<count_1; else if(count_1==1) cout<<fabs(px[count_1])<<" x"; else if(count_1==0) cout<<fabs(px[count_1]); if(wherex( )>=70) gotoxy(30,(wherey( )+2)); if(count_1>0) { if(px[(count_1-1)]>0) cout<<" + "; else cout<<" - "; } if(wherex( )>=70) gotoxy(30,(wherey( )+2)); } gotoxy(6,19); cout<<"Estimation of Pn(x) :";
Pgina 57

gotoxy(6,20); cout<<""; char Choice=NULL; long double x=0; long double pnx=0; do { Choice=NULL; x=0; pnx=0; gotoxy(10,22); cout<<"Enter the value of x = "; cin>>x; pnx=px[0]; pnx+=(px[1]*x); for(int count_2=2;count_2<n;count_2++) { long double temp=x; for(int count_3=1;count_3<count_2;count_3++) temp*=x; pnx+=(px[count_2]*temp); } gotoxy(10,26); cout<<"The estimated value of P"<<(n-1)<<"("<<x<<") = "<<pnx; if(choice) { long double fx=0; fx=evaluate_postfix_expression(x); gotoxy(10,28); cout<<"The Actual value of f"<<"("<<x<<") = "<<fx; gotoxy(10,30); cout<<"Absolute Error = E(abs) = "<<fabs((fx-pnx));
Pgina 58

} gotoxy(15,40); cout<<"Press <Esc> to exit, 'V' to view D.D. Table again"; gotoxy(25,42); cout<<"or any other key to continue..."; Choice=getch( ); if(int(Choice)!=27 && Choice!='v' && Choice!='V') { gotoxy(10,22); cout<<" "; gotoxy(10,26); cout<<" gotoxy(10,28); cout<<" gotoxy(10,30); cout<<" gotoxy(15,40); cout<<" gotoxy(25,42); cout<<" } else if(Choice=='v' || Choice=='V') { show_dd_table( ); estimate_pnx( ); } else if(int(Choice)==27) exit(0); } while(1); }

";

";

";

";

";

Pgina 59

CONCLUSIONES Luego de haber estudiado a profundidad este tema o herramienta para resolver sistemas de ecuaciones, se concluye que para resolver estos sistemas de ecuaciones lineales existen diferentes mtodos, pero depender del gusto de cada persona elegir uno en especfico. Sin embargo, muchas veces la eleccin no ser arbitraria, pues cada mtodo tiene sus ventajas y sus desventajas. Algunos mtodos son ms exactos, otros ms fciles de programar, otros ms cortos, etc. Para ser capaces de elegir un mtodo apropiado, lo primero que se necesita es comprender cmo se desarrolla cada uno de estos procesos. El mtodo de interpolacin , es una herramienta muy utilizada en el mbito laboral, debido a que gracias a sus procesos de aproximacin, en muchos casos se pueden restablecer datos perdidos u extraviados de diversas bases de datos, tales como el control de pedidos en un almacn, o los ingresos y egresos que una sucursal de una panadera puede tener. Luego de la elaboracin de este reporte, ya se tiene una buena base y el conocimiento del tema para poder comenzar a programar en la computadora estos procesos. Como se mencion en la introduccin, el mtodo estudiado en este trabajo es ideal para programarlos por computadora, pues son iterativos y muy largos. Trabajar esto en papel podra resultar extremadamente largo y tedioso. Por ello son mtodos ideales para trabajarlos en computadora. GLOSARIO DE TERMINOS Interpolacin: En el subcampo matemtico del anlisis numrico, se denomina interpolacin a la obtencin de nuevos puntos partiendo del conocimiento de un conjunto discreto de puntos. En ingeniera y algunas ciencias es frecuente disponer de un cierto nmero de puntos obtenidos por muestreo o a partir de un experimento y pretender construir una funcin que los ajuste. Interpolacin: En el subcampo matemtico del anlisis numrico, se denomina interpolacin a la obtencin de nuevos puntos partiendo del conocimiento de un conjunto discreto de puntos. Matriz: En matemticas, una matriz es una tabla bidimensional de nmeros consistente en cantidades abstractas que pueden sumarse y multiplicarse. Las matrices se utilizan para describir sistemas de ecuaciones lineales, realizar un seguimiento de los coeficientes de una aplicacin lineal y registrar los datos que
Pgina 60

dependen de varios parmetros. Las matrices se describen en el campo de la teora de matrices. Pueden sumarse, multiplicarse y descomponerse de varias formas, lo que tambin las hace un concepto clave en el campo del lgebra lineal. Ecuacin: Una ecuacin es una igualdad matemtica entre dos expresiones algebraicas, denominadas miembros, en las que aparecen valores conocidos o datos, y desconocidos o incgnitas, relacionados mediante operaciones matemticas. Los valores conocidos pueden ser nmeros, coeficientes o constantes; y tambin variables cuya magnitud se haya establecido como resultado de otras operaciones. Las incgnitas, representadas generalmente por letras, constituyen los valores que se pretende hallar. Polinomio: En matemticas , se le llama polinomio a la suma de varios monomios. Un monomio es un producto de un coeficiente y una variable elevado a un nmero natural, que se llama el exponente del monomio. Ortogonal: En matemticas, el trmino ortogonalidad (del griego orthos recto y gona ngulo) es una generalizacin de la nocin geomtrica de perpendicularidad. Cifra Significativa: Todas las cifras excepto el cero Ecuacin cuadrtica: Ecuacin de segundo grado o cuadrtica se expresa mediante la relacin ax2 + bx + c = 0, donde a es distinto de 0. Ecuacin cbica: Las ecuaciones de tercer grado o cbicas son del tipo ax3 + bx2 + cx +d = 0, donde a es distinto de 0. Ecuacin curtica: Las ecuaciones de cuarto grado o curticas, ax4 + bx3 + cx2 + dx + e = 0, para a distinto de 0. Ecuacin Diferencial: Ecuacin que contiene derivadas. Evaluar: Valorar una cosa

Pgina 61

BIBLIOGRAFIA *http://translate.googleusercontent.com/translate_c?hl=es&langpair=en%7Ces&rurl =translate.google.com.mx&u=http://wiki.answers.com/Q/Write_a_c_programme_to _perform_newton's_divided_difference_formula&usg=ALkJrhgLdAlkYeStlxc3JFwW cKuBqsRJcg *www.cpp4u.com/c%2B%2B/source%2520code/math.html *http://recursostic.educacion.es/descartes/web/materiales_didacticos/Interpolacion/ interpolacion_1.htm * http://www.uv.es/diazj/cn_tema5.pdf * http://www.mty.itesm.mx/dtie/deptos/cb/cb00854-1/Apuntes/interpol.pdf *http://www.uam.es/personal_pdi/ciencias/barcelo/cnumerico/recursos/interpolacio n.html *http://highered.mcgrawhill.com/sites/dl/free/9701061144/507265/chapra_metodos _5e_capitulo_muestra_c18.pdf * http://www.tonahtiu.com/notas/metodos/gs_ejercicio_06.htm *http://es.wikipedia.org/wiki/Factorizaci%C3%B3n_LU *http://www.uam.es/personal_pdi/ciencias/barcelo/cnumerico/recursos/interpolacio n.html *http://www.uhu.es/cristobal.garcia/descargas/AnalisisNumericoITema3.pdf *http://mna.wikidot.com/interppolin#toc9 *http://translate.google.com.mx/translate?hl=es&langpair=en%7Ces&u=http://jeanpierre.moreau.pagesperso-orange.fr/c_function.html * C. Chapra, S.; P. Canale, R. Mtodos Numricos para Ingenieros. (3 ed.). McGrawHill. *http://construccionuv.bligoo.cl/media/users/9/471845/files/38587/INTERPOLACIO N_NUMERICA.pdf * http://rinconmatematico.com/foros/index.php?topic=5149.0

Pgina 62