Análisis numérico IPN

Instituto Politécnico
Nacional
Escuela Superior de Ingeniería
Mecánica y Eléctrica
Departamento de Ingeniería en Control y
Automatización
Análisis numérico
Profesor: José Antonio Sixto Berrocal
Alumno: Jiménez Torres Marco Antonio

Instituto Politécnico Nacional
Escuela Superior de Ingeniería
Mecánica y Eléctrica
Departamento de Ingeniería en Control y
Automatización
Ejercicios raíces de funciones
CALIFICACION

Introducción:
El Análisis numérico es la técnica con la que es posible formular problemas de tal
forma que puedan resolverse usando operaciones aritméticas, para ello se hace
uso de diferentes herramientas, una de ellas es la computadora, ya que nos facilita
el uso de desarrollo de datos.
Pero ¿Para qué usar el análisis numérico?
Una gran cantidad de problemas a los que se enfrenta la ingeniería son de
características donde no es fácil disponer de los métodos analíticos o ecuaciones
que lleven a una solución exacta. Dichos problemas generalmente involucran
derivadas, integrales, ecuaciones diferenciales, raíces de funciones, etc.
El análisis numérico toma importancia ya que en la búsqueda de soluciones el
procedimiento para encontrar la respuesta necesita la utilización de procesos
iterados que no se pueden resolver en un número finito de datos.
En pocas palabras, estos métodos se aplican cuando es necesario encontrar el
valor numérico de un problema matemático y los procedimientos analíticos son
ineficaces de dar una respuesta.
Un ejemplo de aplicación de los métodos numéricos es encontrar raíces de
funciones. Antes de que aparecieran las computadoras había una serie de
métodos que servían para encontrar raíces de funciones como la formula general
o formula cuadrática. Aunque existen muchas ecuaciones que se prestan para
esta ecuación hay otras que no, como esta que aparenta ser sencilla no se puede
resolver por métodos analíticos 𝑒−𝑥
− 𝑥 donde la única alternativa es una técnica
de solución aproximada como el método gráfico.
Ya que el método grafico presenta algunas dificultades o no es muy práctico
existen otros tipos de métodos que nos llevaran a la solución más cercana a la
real como son:
 Método de la bisección
 Método de la regla falsa
 Método de la tangente
 Método de la tangente mejorada
Aunque las raíces de funciones pertenecen a otro contexto, generalmente
aparecen en la rama de diseño en la ingeniería. Las ecuaciones matemáticas o los
modelos derivados de estos principios se emplean en la predicción de variables
dependientes en función de variables independientes y de los parámetros.

Desarrollo:
En base a la programación estructurada se realizaran una serie de ejercicios
aplicando el método de la bisección y de la regla falsa o secante para encontrar
raíces de funciones.
Ejercicios No.1
 Determine las raíces reales de f(x) = -0.5x2 +2.5x + 4.5
a) Gráficamente.
b) Empleando la formula cuadrática.
c) Usando el método de la bisección con tres iteraciones para determinar
la raíz mas grande. Emplee como valores iniciales a=5 y b=10 calcule
el error estimado Er y el error verdadero Ev.
float f(float x);
void pide_datos();
void operacion();
int c=0,ciclos=2;
float Er,Xr,Xr_1=0,error,a=5,b=10,Ev;
int main(){
system("cls");
printf("Este programa calcula la raiz mas grande de la funcion: ntf(x) = -0.5x^2
+ 2.5x + 4.5 nCon un total de tres iteraciones");
printf(" por el metodo de la biseccion.nDe igual forma por la formula cuadratica
y el metodo grafico con GNUPLOT n");
FILE *ap;
ap=fopen("datos.txt","w");
fprintf(ap,"nCtXrt Er");

pide_datos();
do{
Xr=(a+b)/2;
Er=fabs((Xr-Xr_1)/Xr);
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
fprintf(ap,"n%dt%ft%f",c,Xr,Er);
}while(Er>error && c<=ciclos);
operacion();
fprintf(ap,"nnXr = %f",Xr);
fprintf(ap,"nEr = %f",Er);
fprintf(ap,"nEv = %f",Ev);
printf("nn");
system("pause");
}
float f(float x){
return -0.5*pow(x,2)+2.5*x+4.5;
}
void pide_datos(){
printf("nnRango definido por a=5 y b=10");
printf("nEl numero de iteraciones es de 3 ");

printf("nnTolerancia = ");
scanf("%f",&error);
}
void operacion(){
float x1,x2;
printf("nnCon la formula cuadratica es:n");
x1=((-2.5+sqrt(15.25))/-1);
x2=((-2.5-sqrt(15.25))/-1);
printf("tLa primer raiz es %f",x1);
printf("ntLa segunda raiz es %f",x2);
Ev=fabs(x2-Xr);
system("gnuplot config.gp");
}
En este algoritmo podemos apreciar que el
programa tiene como tarea entregar por
medio del método de la bisección, la
formula cuadrática y el método grafico la
solución de la ecuación planteada.
El algoritmo hace uso de tres funciones de
usuario, un apuntador de tipo FILE que nos
servirá para abrir un documento de tipo .txt
y un ciclo do while que permite el uso para encontrar la solución más cercana a la
real.
El programa muestra una leyenda con sus funciones y sus condiciones iniciales
para después pedir valores al usuario en este caso la tolerancia que ser permitida
para encontrar la raíz. Después de introducir la tolerancia realizara su tarea e
imprimirá los valores en el documento .txt y proseguirá a graficar nuestra función.
Ejercicio No.2

 Determine las raíces reales de f(x) = 5x3 – 5x2 +6x – 2
a) Graficamente
b) Utilizando el método de la bisección para localizar la raíz más pqueña.
Use los valores iniciales a=0 y b=1 iterando hasta que el Er sea menor
de error =10%
float f(float x);
void pide_datos();
int c=0,ciclos;
float Er,Xr,Xr_1=0,error=0.1,a=0,b=1,Ev;
int main(){
system("cls");
printf("Este programa calcula la raiz real de la funcion: ntf(x) = 5x^3 - 5x^2
+ 6x -2 nCon una tolerancia del 0.1");
printf(" por el metodo de la biseccion y el metodo grafico con GNUPLOT
n");
FILE *ap;
fprintf(ap,"nCtXrt Ern");
pide_datos();
do{
Xr=(a+b)/2;
Xr_1=Xr;

c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
printf("nXr = %f",Xr);
fclose(ap);
printf("nn");
system("pause");
}
float f(float x){
return 5*pow(x,3)-5*pow(x,2)+6*x-2;
}
void pide_datos(){

printf("nCon una tolerancia del 10% ");
printf("nnCuantos ciclos cree convenientes? = ");
scanf("%d",&ciclos);
}
Nuevamente se presenta el caso de encontrar la raíz de una función donde la
única diferencia es que en este se plantea la tolerancia o el “error” que debe tener
el método en la búsqueda de la respuesta. Este programa al calcular la raíz de la
función con un intervalo definido no es indispensable realizar un control para la
repetición del mismo.
Ejercicio No.3
 Calcule las raíces de f(x) = -12 -21x +18x2 -2.75x3
a) Graficamente.
b) Empleando el método de la falsa posición con un valor de error
correspondiente a tres cifras significativas para determinar la raíz mas
pequeña.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
float f(float x);
void pide_datos();
int c=0,ciclos,op;

float Er,Xr,Xr_1=0,error,a,b;
int main(){
do{
system("cls");
printf("Este programa calcula las raices reales de la funcion: ntf(x) = -2.75x^3 +
18x^2 - 21x - 12 n");
printf(" por el metodo de la regla falsa y el metodo grafico con GNUPLOT n");
printf("nRecuerde que esta funcion toca 3 puntos del eje xn");
printf("nPara encontrar primer raiz se suguiere un rango de [-5:0]nSegunda
[0:3]tercera de [3:5]");
FILE *ap;
pide_datos();
do{
Xr=((a*f(b)-b*f(a))/(f(b)-f(a)));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;

fclose(ap);
fflush(ap);
printf("nntQuieres volver a intentarlo 1. Si 2. No R= ");
scanf("%f",&op);
}while(op>=1);
printf("nn");
system("pause");
}
float f(float x){
return -2.75*pow(x,3)+18*pow(x,2)-21*x-12;
}
void pide_datos(){
printf("nnRango definido por: ");
printf("nA = ");
scanf("%f",&a);

printf("nB = ");
scanf("%f",&b);
printf("nSe suguiere una tolerancia de tres cifras significativas ");
scanf("%f",&error);
}
La particularidad de este programa es que nos da la opción de repetir el proceso
cuantas veces las necesitamos, de igual forma que los anteriores, este muestra
una leyenda con sus funciones y al ser una función de grado tres toca tres veces
el eje de las x por eso recomienda algunos dominios para encontrar las raíces de
otro modo el usuario puede escoger el de su preferencia, como podemos observar
la falsa posición es un método similar a la bisección pero con un menor número de
iteraciones que realmente son útiles al momento de realizar grandes cálculos.
Ejercicio No.4
 Localice la primera raíz no trivial de sen(x) = x2, donde x esta en radianes.
Use una técnica gráfica y bisección con un intervalo inicial de 0.5 y 1. Haga
el cálculo hasta que Er sea menor a 0.02. realice también una prueba de
error sustituyendo la respuesta final en la ecuación original.
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
int c=0,ciclos;
float Xr,Xr_1=0,Er,error=0.02,a=0.5,b=1;
void pide_datos();
float f(float x);

void operacion();
int main(){
system("cls");
printf("Este programa calcula las raices reales de la funcion: nt sin(x) = x^2
n");
printf(" por el metodo de la biseccion y el metodo grafico con GNUPLOT n");
FILE *ap;
pide_datos();
do{
Xr=((a*f(b)-b*f(a))/(f(b)-f(a)));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;

fclose(ap);
operacion();
printf("nn");
system("pause");
}
float f(float x){
return sin(x)-pow(x,2);
}
void pide_datos(){
printf("nnRango definido por a= 0.5 y b= 1 ");
printf("nCon una tolerancia de 0.02 ");
}
void operacion(){
float resp;
resp=sin(Xr)-pow(Xr,2);
printf("ntSustituyend Xr obtenemos %f",resp);
}

Para este programa los valores del rango ya están predeterminados los cuales son
0.5 y 1, Esta ecuación también toca al eje de las x en 0 pero eso la covierte en la
ecuación trivial, si nos basamos en el método grafico encontraremos que un poco
a la derecha de esa raíz se encuentra otra la cual entra perfecto en el intervalo
mencionado.
Este programa trabaja con el método de la falsa posición dando un mejor
rendimiento y un menor número de iteraciones.
Ejercicio No.5
 Determine la raíz real de f(x) = (0.8-0.3x)/x
a) Analiticamente
b) Graficamente
c) Empleando valores tres iteaciones en el método de la falsa posición con
valores iniciales de 1 a 3. Calcule el error aproximado Er y el valor
verdadero en cada iteración.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
float f(float x);
void pide_datos();
void operacion();
int c=0,ciclos=2;
float Er,Xr=0,Xr_1=0,error,a=1,b=3,Ev;
int main(){

system("cls");
printf("Este programa calcula la raiz de la funcion: ntf(x) = (0.8 - 0.3x)/x nCon
un total de tres iteraciones");
printf(" por el metodo de la regla falsa.ny el metodo grafico con GNUPLOT n");
FILE *ap;
pide_datos();
do{
Xr=((a*f(b)-b*f(a))/(f(b)-f(a)));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
operacion();

fprintf(ap,"nEv = %f",Ev);
printf("nn");
system("pause");
}
float f(float x){
return 0.8*pow(x,-1)-0.3;
}
void pide_datos(){
printf("nEl numero de iteraciones es de 3 ");
printf("nnTolerancia = ");
scanf("%f",&error);
}
void operacion(){
printf("nnDe forma analitica sabemos que x es 8/3 o 2.666666667n");
Ev=fabs(2.6666666-Xr);
}
Este programa tiene condiciones iniciales para encontrar nuestra raíz,
analíticamente sabemos que la raíz es ocho tercios o 2.666667 , al tener un
número muy pequeño de ciclos no se encuentra del todo la raíz y nos expulsa un
2.74 el cual nos indica que con un a iteración más lograríamos alcanzar un poco
más a la raíz.

Ejercicio No.6
 Calculela raíz cuadrada positiva de 18 usando el método de la falsa
posición con una tolerancia de 0.005 y empleando como rango a = 4 y b = 5
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int c=0,ciclos;
float Er,Xr,Xr_1=0,a=4,b=5,error=0.005;
float f(float x){
return pow(x,2)-18;
}
void pide_datos(){
printf("nEl Con una tolerancia de 0.005 ");
printf("nncuantos ciclos crees convenientes ? = ");
}
int main(){
system("cls");
printf("Este programa calcula la raiz de 18n");
printf("Por el metodo de la falsa pocision.ny el metodo grafico con GNUPLOT
n");
FILE *ap;

pide_datos();
do{
Xr=((a*f(b)-b*f(a))/(f(b)-f(a)));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
printf("nn");
system("pause");
}
Este programa nos muestra que no solo podemos encontrar raíces de funciones
complicadas o cuando los métodos analíticos son ineficientes , si no que se
aplican para todas las funciones ya sean reales o complejas.
Ejercicio No. 7

 Encuentre la raíz positiva más pequeña de la función (x esta en radianes)
x2|cos(x)| = 5 usando el método de la falsa posición. Para localizar el
intervalo donde se encuentra la raíz, grafique primero esta función para
valor de entre 0 y 5. Realice el cálculo hasta que Er sea menor a la
tolerancia de 0.01. Compruebe su respuesta final sustituyéndola en la
función original.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int c=0;ciclos;
float Xr,Er,Xr_1=0,error=0.01,a=0,b=5;
float f(float x){
return pow(x,2)*fabs(cos(sqrt(x)))-5;
}
void pide_datos(){
}
void ope(){
float op;
op=pow(Xr,2)*fabs(cos(sqrt(Xr)))-5;
printf("ntSustituyendo Xr obtenemos %f",op);
}

int main(){
system("cls");
printf("Este programa calcula la raiz positiva mas pequeña de nt x^2*|cos(x^-
0.5)| = 5n");
n");
FILE *ap;
pide_datos();
do{
Xr=((a*f(b)-b*f(a))/(f(b)-f(a)));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;

fclose(ap);
fflush(ap);
ope();
printf("nn");
system("pause");
}
En este programa pide primero calculara para el rango 0:5 y encontrar el rango
donde se encuentra la raíz y se observa que esta entre 3 y 4 pero en este caso
dejamos el rango predeterminado por el ejercicio.
Nuevamente usamos el método de la falsa posición y esperamos a que arroje los
resultados lo cual tarda un total de 6 iteraciones y cuando se sustituye se
determina que la raíz encontrada esta próxima al cero pero podría acercarse más
con más cifras significativas en la tolerancia. En este caso sustituyendo Xr la
función regresa un valor de -0.05 unidades.
Ejercicio No .8
 Determine la raíz real de x3.5 = 80
a) En forma analítica
b) Con el método de la falsa posición dentro de error = 0.0025, haga
elecciones iniciales de 2 a 5.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int c=0;ciclos;
float Xr,Er,Xr_1=0,error=0.025,a=2,b=5;
float f(float x){
return sqrt(pow(x,7))-80;
}
void pide_datos(){
}
int main(){
system("cls");
printf("Este programa calcula la raiz positiva mas pequeña de nt x^3.5 = 80
n");
n");
FILE *ap;
pide_datos();
do{
Xr=((a*f(b)-b*f(a))/(f(b)-f(a)));

Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
fclose(ap);
fflush(ap);
printf("nn");
system("pause");
}
Ejercicio No.9
 La velocidad de un paracaidista está dada por:
V =
𝑔𝑚
𝑐
(1 − 𝑒
−
𝑐
𝑚
𝑡
)

Utilice el método de la falsa posición para determinar la masa del
paracaidista a ciertas condiciones iniciales.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define v 35
#define g 9.8
#define t 9
#define C 15
int c=0,ciclos;
float Xr,Xr_1=0,Er,error=0.001,a,b;
float f(float x){
return ((v*C)/(g*(1-exp((-C/x)*t))))-x;
}
void pide_datos(){
printf("Rango dado por :n");
printf(" a = ");
scanf("%f",&a);
printf(" nb = ");
scanf("%f",&b);
printf("nTolerancia de 0.001 ");
printf("nNumero de ciclos: ");
scanf("%i",&ciclos);

}
int main(){
system("cls");
printf("Este programa calcula la masa de un paracaidista segun condiciones
iniciales n");
n");
pide_datos();
FILE *ap;
ap=fopen("Datos.txt","w");
do{
Xr=(((a*f(b)-b*f(a)))/(f(b)-f(a)));
Er=fabs((Xr-Xr_1)/(Xr));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
fprintf(ap,"n%i %f ",c,Xr);
printf("n%i MASA = %f ",c,Xr);

printf("nMasa = %f kg",Xr);
fprintf(ap,"nnMasa = %f kg",Xr);
fclose(ap);
fflush(ap);
printf("nn");
system("pause");
}
En este programa hacemos uso del método de la falsa posición donde podemos
encontrar la masa del paracaidista según las condiciones iniciales del coeficiente
de fricción, la velocidad, la gravedad, el tiempo y a su vez damos un rango en para
la masa ya que no existen masas negativas y un cuerpo no llega a los 200kg se
toma un rango de 1 a 200 kg dando como resultado una masa de 59.8kg en un
proceso de 6 iteraciones.
Ejercicio No. 10
 Por un canal trapezoidal fluye agua a una tasa de Q = 20 m3/s. La
profundidad crítica y para dicho canal satisface la ecuación
1 −
𝑄2
𝑔 ∗ 𝐴3
∗ 𝐵 = 0
Donde B = (3 + y) y A = (3y + y2/2)
Considere valores iniciales de 0.5 a 2.5 y que la tolerancia sea del 0.01
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define g 9.81
float f(float y){
float x,w,z,u,c;
u=pow(y,2)/2;
x=3*y+u;
w=pow(x,3);
z=w/(3+y);
c=400/g;
return z-c;
}
void mostrar(){
printf("nEl rango esta dado por a= 0.5 b= 2.5");
printf("nLa tolerancia esta dada por: 0.01");
printf("ncon un total de 3 ciclos");
}
void biseccion(){
int c=0,ciclos=100;
float Xr,Xr_1=0,Er,error=0.01,a=0.5,b=2.5;
FILE *ap;
fprintf(ap,"nCtXr");

do{
Xr=(a+b)/2;
Er=fabs((Xr-Xr_1/Xr));
Xr_1=Xr;
c++;
if((f(a)*f(Xr))<0)
b=Xr;
else
a=Xr;
printf("n%itXr = %f",c,Xr);
fprintf(ap,"n%it%f",c,Xr);
printf("nnXr = %f",Xr);
fclose(ap);
}
void secante(){
int c=0,ciclos=100;

float Xr=0,Xr_1=0,Er,error=0.01,a=0.5,b=2.5;
FILE *ap;
fprintf(ap,"nCtXr");
do{
Xr=(((a*f(b)-b*f(a)))/(f(b)-f(a)));
Xr_1=Xr;
c++;
if((f(a)*f(Xr))<0)
b=Xr;
else
a=Xr;
printf("n%itXr = %f",c,Xr);
fprintf(ap,"n%it%f",c,Xr);
printf("nnProfundidad = %f m^3/s",Xr);
fprintf(ap,"nnXr = %f m^3/s",Xr);
fclose(ap);

}
int main(){
int op,op2;
do{
system("cls");
printf("Este programa calcula La profundidad critica de un sistema
Trapezoidaln");
printf("Por el metodo grafico con Gnuplot");
printf(" Elija sumetodo:n1.Biseccionn2.SecantenR= ");
scanf("%d",&op);
switch(op){
case 1:
mostrar();
biseccion();
break;
case 2:
mostrar();
secante();
break;
default:

printf("No se encuentra opcion....");
break;
}
printf("nQuieres volver a intentarlo 1.Si 0.No nR= ");
scanf("%d",&op2);
}while(op2>=1);
printf("nn");
system("pause");
return 0;
}
En este programa hacemos uso de los dos métodos tanto el de la regla falsa como
el de la bisección donde podemos apreciar algunos cambios, uno de ellos es que
las variables son locales y las condiciones iniciales están ya definidas, el motivo
de ponerlas en modo local es que cuando el ciclo se repite la variable ya cambio
de valores y esto alteraría nuestro sistema. A su vez también hacemos uso del
método grafico que ayuda a concentrarnos en el punto crítico que toca la
ecuación.
Ejercicio No. 11
 Suponga que se desarrolla un tanque esférico para almacenar agua en un
país en desarrollo, el volumen del líquido que puede contener se calcula
con:
V =
𝜋ℎ[3𝑅−ℎ]
3
¿A qué profundidad debe llenarse el tanque para tener 30m3? Haga tres
iteraciones y determine el valor estimado
#include<stdio.h>
#include<stdlib.h>

#include<math.h>
int c=0,ciclos;
float Xr,Xr_1=0,Er,error,A,b;
float f(float y){
float x,w,z,u,c;
x=(30/(9-y));
w=pow(y,2);
z=M_PI*w;
return x-z;
}
void mostrar(){
printf("nEl rango esta dado por:");
printf("nA = ");
scanf("%f",&A);
printf("nB = ");
scanf("%f",&b);
printf("nLa tolerancia esta dada por: ");
scanf("%f",&error);
printf("nCuantos ciclos? ");
}
void secante(){

FILE *ap;
do{
Xr=(((A*f(b)-b*f(A)))/(f(b)-f(A)));
Xr_1=Xr;
c++;
if((f(A)*f(Xr))<0)
b=Xr;
else
A=Xr;
printf("n%itXr = %f Er = %f",c,Xr,Er);
fprintf(ap,"n%it%ft%f",c,Xr,Er);
printf("nnXr = %f ",Xr);
fprintf(ap,"nnXr = %f ",Xr);
fprintf(ap,"nnEr = %f ",Er);
fclose(ap);
fflush(ap);

}
int main(){
int op2;
do{
system("cls");
printf("Este programa calcula la profundidad de un tanque dada la
ecuacionn");
mostrar();
secante();
c=0;
printf("nQuieres volver a intentarlo 1.Si 0.No nR= ");
scanf("%d",&op2);
}while(op2>=1);
printf("nn");
system("pause");
return 0;
}
Este programa nuevamente presenta muchas características del anterior solo que
este esta seccionado por funciones de usuraio y tiene la capacidad de repetirse
cuantas veces quiera el usuario.
Ejercicio No.14

 Determine la raíz real de la función Ln(x2) = 0.7 por el método de la
bisección
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int c=0,ciclos=5;
float Xr,Er,error,Xr_1=0,a,b;
float f(float x){
return (sqrt(exp(0.7))-x);
}
void pide_datos(){
printf("nDefine rango: ");
printf("na = ");
scanf("%f",&a);
printf("nb = ");
scanf("%f",&b);
printf("Determine la tolerancia = ");
scanf("%f",&error);
printf("El numero de iteraciones esta definido por 6");
}

int main(){
system("cls");
printf("Programa que calcula las raices reales de la ecuacion: Ln(x^2)=0.7");
pide_datos();
printf("nCtXrt Er");
do{
Xr=((b+a)/2);
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
printf("n%dt%ft%f",c,Xr,Er);
printf("nnXr = %fnn",Xr);
system("pause");
return 0;
}

Ejercicio No.15
 Determine la raíz real de la función Ln(x2) = 0.7 por el método de la
bisección
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int c=0,ciclos=5;
float Xr,Er,error,Xr_1=0,a,b;
float f(float x){
return (sqrt(exp(0.7))-x);
}
void pide_datos(){
printf("nDefine rango: ");
printf("na = ");
scanf("%f",&a);
printf("nb = ");
scanf("%f",&b);
printf("Determine la tolerancia = ");
scanf("%f",&error);
printf("El numero de iteraciones esta definido por 6");

}
int main(){
system("cls");
printf("Programa que calcula las raices reales de la ecuacion: Ln(x^2)=0.7");
pide_datos();
printf("nCtXrt Er");
do{
Xr=((a*f(b))-(b*f(a)))/(f(b)-f(a));
Xr_1=Xr;
c++;
if(f(a)*f(Xr)<0)
b=Xr;
else
a=Xr;
printf("n%dt%ft%f",c,Xr,Er);
printf("nnXr = %fnn",Xr);
system("pause");
return 0;}

Conclusión:
Después de realizar los algoritmos podemos darnos cuenta de que el uso de los
métodos numéricos facilitan el proceso de encontrar raíces de funciones las
cuales no siempre se pueden encontrar por métodos analíticos, en este caso se
hizo uso de la programación estructurada pero podríamos también hacer uso de la
programación orientada a objetos para realizar un código más completo y más
fácil para el programador.
También se puede empezar a notar la importancia que estos tienen en las
aplicaciones de la ingeniería, ya que en muchos casos nos encontraremos con
funciones de este tipo.
Queda claro el uso de estos métodos para encontrar raíces de funciones y a su
vez destacar la importancia que tiene GNUPLOT ya que ayuda al usuario y al
programador encontrar los parámetros más cercanos o evitar unos cuantos
cálculos y corrobóralos después con la aplicación.
Bibliografía:
 Métodos numéricos para ingenieros, Steven C.Chapra, Raymond P.
Canale, McGraw-Hill, Mexico 1988.
 http://aprendeenlinea.udea.edu.co/lms/moodle/course/view.php?id=229

Análisis numérico IPN

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Análisis numérico IPN

Similar a Análisis numérico IPN (20)

Último

Último (20)

Análisis numérico IPN