Ejercicios raíces de funciones

Instituto Politécnico NacionalEscuela 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 NacionalEscuela 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 e− x−x 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.5a) 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: \n\tf(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,"\nC\tXr\t 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%d\t%f\t%f",c,Xr,Er);

}while(Er>error && c<=ciclos);

operacion();

fprintf(ap,"\n\nXr = %f",Xr);

fprintf(ap,"\nEr = %f",Er);

fprintf(ap,"\nEv = %f",Ev);

printf("\n\n");

system("pause");

}

float f(float x){

return -0.5*pow(x,2)+2.5*x+4.5;

}

void pide_datos(){

printf("\n\nRango definido por a=5 y b=10");

printf("\nEl numero de iteraciones es de 3 ");

printf("\n\nTolerancia = ");

scanf("%f",&error);

}

void operacion(){

float x1,x2;

printf("\n\nCon 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("\n\tLa 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 – 2a) 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: \n\tf(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,"\nC\tXr\t Er\n");

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("\n\n");

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("\n\nCuantos 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: \n\tf(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 x\n");

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("\n\n\tQuieres volver a intentarlo 1. Si 2. No R= ");

scanf("%f",&op);

}while(op>=1);

printf("\n\n");

system("pause");

}

float f(float x){

return -2.75*pow(x,3)+18*pow(x,2)-21*x-12;

}

void pide_datos(){

printf("\n\nRango 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: \n\t 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("\n\n");

system("pause");

}

float f(float x){

return sin(x)-pow(x,2);

}

void pide_datos(){

printf("\n\nRango 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("\n\tSustituyend 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)/xa) Analiticamenteb) Graficamentec) 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: \n\tf(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("\n\n");

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("\n\nTolerancia = ");

scanf("%f",&error);

}

void operacion(){

printf("\n\nDe forma analitica sabemos que x es 8/3 o 2.666666667\n");

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("\n\ncuantos ciclos crees convenientes ? = ");


}

int main(){

system("cls");

printf("Este programa calcula la raiz de 18\n");

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("\n\n");

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("\n\tSustituyendo Xr obtenemos %f",op);

}

int main(){

system("cls");

printf("Este programa calcula la raiz positiva mas pequeña de \n\t x^2*|cos(x^-0.5)| = 5\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("\n\n");

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 = 80a) En forma analíticab) 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 \n\t x^3.5 = 80 \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("\n\n");

system("pause");

}

Ejercicio No.9

La velocidad de un paracaidista está dada por:

V =gmc

¿)

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


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,"\n\nMasa = %f kg",Xr);


fclose(ap);


fflush(ap);

printf("\n\n");

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− Q2

g∗A3∗B=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,"\nC\tXr");

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%i\tXr = %f",c,Xr);

fprintf(ap,"\n%i\t%f",c,Xr);


printf("\n\nXr = %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,"\nC\tXr");

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%i\tXr = %f",c,Xr);

fprintf(ap,"\n%i\t%f",c,Xr);


printf("\n\nProfundidad = %f m^3/s",Xr);

fprintf(ap,"\n\nXr = %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 Trapezoidal\n");

printf("Por el metodo grafico con Gnuplot");

printf(" Elija sumetodo:\n1.Biseccion\n2.Secante\nR= ");

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("\n\n");

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 = πh [3 R−h]

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%i\tXr = %f Er = %f",c,Xr,Er);

fprintf(ap,"\n%i\t%f\t%f",c,Xr,Er);


printf("\n\nXr = %f ",Xr);

fprintf(ap,"\n\nXr = %f ",Xr);

fprintf(ap,"\n\nEr = %f ",Er);

fclose(ap);


fflush(ap);

}

int main(){

int op2;

do{

system("cls");

printf("Este programa calcula la profundidad de un tanque dada la ecuacion\n");

mostrar();

secante();

c=0;

printf("\nQuieres volver a intentarlo 1.Si 0.No \nR= ");

scanf("%d",&op2);

}while(op2>=1);

printf("\n\n");

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("\nC\tXr\t Er");

do{

Xr=((b+a)/2);


Xr_1=Xr;

c++;

if(f(a)*f(Xr)<0)

b=Xr;

else

a=Xr;

printf("\n%d\t%f\t%f",c,Xr,Er);


printf("\n\nXr = %f\n\n",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("\nC\tXr\t 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%d\t%f\t%f",c,Xr,Er);


printf("\n\nXr = %f\n\n",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

Ejercicios raíces de funciones

Engineering

Transcript of Ejercicios raíces de funciones