Imprimir.docx
This document was uploaded by user and they confirmed that they have the permission to share it. If you are author or own the copyright of this book, please report to us by using this DMCA report form. Report DMCA
Overview
Download & View Imprimir.docx as PDF for free.
More details
- Words: 1,416
- Pages: 10
SECANTE #include
{x2=(x1-((x0-x1)/(fun(x0)-fun(x1))*fun(x1)));
#include
printf ("%f \n",x2);
#include
Ea=(fabs (x1-x2));
using namespace std;
x0=x1;
float fun (float x);
x1=x2;
int main() {
}
float error=0.00001,x0,x1,x2,Ea;
printf ("la raiz es:%f \n",x2);
printf ("Metodo de la Secante\n");
return 0;
printf ("Digite el primer valor ");
}
scanf ("%f",&x0);
float fun(float x)
printf ("Digite el segundo valor ");
{float f;
scanf ("%f",&x1);
f=x*x-4;
Ea=error+1;
return f;
while (Ea>error)
}
RAICES MULTIPLES #include #include <stdlib.h>
cout<<" - RAICES MULTIPLES "<<endl;
#include <math.h>
cout<<"Digite la aproximacion inicial : "; cin>>*po;
using namespace std;
cout<<"Digite el numero de iteraciones : "; cin>>*N;
using std::cout; using std::endl;
void newton_generalizado(double , int); double eval_funcion(double); double eval_derfuncion(double); double eval_segderfuncion(double); /************************** *************************** **************************/
while(*N<=2)
cout<<"La cantidad de iteraciones debe ser positiva (>2) "<<endl;
}
t2 = ef * esdf ; // f(po) * f''(po)
t4 = t3 - t2 ; // [f'(po)]^2 [f(po) * f''(po)] c = t1 / t4 ; // [f(po) * f'(po)] / [f'(po)]^2 - [f(po) * f''(po)] p = po - c;
//el "paso 3"
efp = eval_funcion(p);
} /************************** *************************** **************************/ void newton_generalizado(double po, int N) {
{
double TOL=0.00000001 , ef=0.0 , edf=0.0, Er=0.0 , p=0.0 , c=0.0 , efp=0.0;
int vn;
t1 = ef * edf ; // f(po) * f'(po)
cout<<"Digite el numero de iteraciones : "; cin>>*N;
main()
double vpo;
esdf = eval_segderfuncion(po);
t3 = edf * edf; // [f'(po)]^2
{ void lecturas(double* , int*);
edf = eval_derfuncion(po);
lecturas(&vpo , &vn);
double esdf = 0.0, t1=0.0 , t2=0.0 , t3=0.0 , t4=0.0;
newton_generalizado(vpo , vn);
int i = 1 ; //el "paso 1"
}
cout.precision(10);
/************************** *************************** ************************/
cout<<"\n"<<"\t-- po -- "<<"\t -p -- "<<"\t -- f(p) -- "<<"\t-- Er -- ";
Er = (p - po)/p; if(Er<0) Er=Er*(-1); //esto es para ayudar al paso 4
//Para mostrar resultados iteracion a iteracion
cout<<"\n"<<<"\t"<<po<<"\t"<
//el "paso 4" if(Er
//el "paso 5" //el "paso 2"
void lecturas(double *po , int *N)
while(i <= N)
{
{ ef = eval_funcion(po);
i = i + 1;
//el "paso 6" redefinicion de po
po = p;
a2 = 8*z;
r = a1 - a2 + a3 + a4 - a5 - 32;
}
r = a1 - a2;
return r;
return r;
}
//el "paso 7" if((i>N)||(Er>TOL)) {cout<<"\nEl metodo fracaso despues de "<
} double eval_derfuncion(double z) double eval_segderfuncion(double y)
{
{
double r=0.0, a1 = 0.0, a2 = 0.0, a3= 0.0, a4=0.0;
double r=0.0, a1 = 0.0;
a1 = 6*pow(z,5);
/************************** *************************** **************************/
a1 = 12*y*y;
a2 = 60*pow(z,3);
r = a1 - 8;
a3 = 42*pow(z,2);
//EJEMPLO
return r;
a4 = 72*z;
}
r = a1 - a2 + a3 + a4 - 24;
double eval_funcion(double v)
return r;
{
}
double r=0.0 , a1 = 0.0, a2 = 0.0;
//EJEMPLO 2
a1 = pow(v,4);
/*
a2 = 4*v*v;
double eval_funcion(double v)
r = a1 - a2 + 4;
{
return r;
double r=0.0 , a1 = 0.0, a2 = 0.0, a3= 0.0, a4=0.0, a5=0.0;
}
a1 = pow(v,6); double eval_derfuncion(double z)
a2 = 15*pow(v,4);
{
a3 = 14*pow(v,3);
double r=0.0, a1 = 0.0, a2 = 0.0;
a4 = 36*pow(v,2);
a1 = 4*z*z*z;
a5 = 24*v;
*/
double eval_segderfuncion(double y) { double r = 0.0 , a1 = 0.0, a2 = 0.0, a3 = 0.0; a1 = 30*pow(y,4); a2 = 180*pow(y,2); a3 = 84*y; r = a1 - a2 + a3 + 72; return r; }
S.E.P.
S.E.S.
Tec N.M.
INSTITUTO TECNOLÓGICO DE TOLUCA PROGRAMACIONES DE METODOS NUMERICOS CALIF. : ______ CARRERA: ING. MECATRÓNICA MATERIA: METODOS NUEMERICOS GRUPO: 187701 PROFESOR: OSORIO DE JESUS NAYELY ALUMNO: ALMARAZ MEDINA JOSE HILARIO
TOLUCA, MÉX. A 27 DE FEBRERO DE 2019
PUNTO FIJO #include <stdio.h> #include <math.h> #define e 2.718281828
scanf("%lf", &TOL);
}
printf("Numero maximo de iteraciones: ");
else{
scanf("%d", &N);
//paso 5
//paso 1
double fun (double);
i++;
i = 1; main (){
y el resultado se da en la 6ta. iteracion*/
P0 = P;
//paso 2
/*Para resolver la funcion siguiente x = 2 e^x + x^2/3 con N = 10 o mas iteraciones TOL = 0.001 P0 =0
//paso 6
OK = 1;
int i, N, OK;
P = fun (P0);
b = fabs(P - P0);
printf ("Metodo Punto Fijo\n");
printf("Numero de iteraciones N = %d\n", i);
printf("Tolerancia TOL:
printf("\n\nEl metodo fallo con un numero de iteraciones N = %d\n\n", N);
//paso 4
printf("Solucion aproximada P = %12.8f\n", P);
");
if(OK == 1)
//paso 3
if(b < TOL){
scanf ("%lf", &P0);
//paso 7
1){
printf("Antes de continuar, cambia la funcion para un nuevo prblema\n");
printf("Aproximacion inicial P0: ");
}
while(i <= N && OK ==
printf("%d\t%12.8f\n", i, P); double P0,TOL,P,b;
}
printf("\n\nI\t\tP\n");
return 0; }//cambia la funcion para un nuevo problema double fun(double x){ double a; a = (2 - pow (e, x) + x*x)/3; return a; }
printf("Tolerancia TOL = %5.11f\n\n", TOL); OK = 0;
PUNTO FIJO
NEWTON-RAPHSON
RAICES MULTIPLES
SECANTE
NEWTON-RAPHSON #include #include // setprecision
cout << setprecision(PRECISION); // Se establece la precisión
#include
cout << "\nCalculo de las raices de una funcion aplicando el metodo de Newton - Raphson\n";
#define PRECISION 10 #define MAX_ITERACIONES 100 #define INTERVALOS 6
cout << "\nIngrese el intervalo inicial [a,b]:" << endl;
// Se ingresa el intervalo
using namespace std;
cout << "\na = "; cin >> a;
void tabula(double a, double b, int intervalos); // Muestra un # tabulado de intervalos
cout << "b = ";
double f(double x); // Retorna el valor de la función evaluada en x double f_derivada(double x); // Retorna la derivada de la función evaluada en x
cin >> b;
// Se tabulan los valores de f para INTERVALOS intervalos tabula(a, b, INTERVALOS);
int main() {
// Se pide elegir una aproximación
double a;
inicial
double b; double tolerancia;
// Tolerancia
double x0; // Primera aproximación
cout << "\nEscoja el punto inicial adecuado: x0 = "; cin >> x0;
double x1; // Siguiente aproximación double error; // Diferencia entre dos aproximaciones sucesivas: x1 - x0 int iteracion; // # de iteraciones bool converge = true;
// Se pide ingresar la tolerancia cout << "Tolerancia = "; cin >> tolerancia;
// Iteraciones
cout << "x" << iteracion << " = " << x1 << "\n"
// Se imprimen los valores de la primera aproximación cout << "\nAproximacion inicial:\n";
<< "f(x" << iteracion << ") = " << f(x1) << "\n" << "f'(x" << iteracion << ") = " << f_derivada(x1) << "\n"
cout << "x0 = " << x0 << "\n" << "f(x0) = " << f(x0) << "\n" << "f'(x0) = " << f_derivada(x0) << endl;
iteracion = 1;
<< "error = " << error << endl;
// La diferencia entre dos aproximaciones sucesivas es también conocida como error. // La condición de terminación consiste en que que el error debe ser <= que la tolerancia dada
do {
if (iteracion > MAX_ITERACIONES) {
// Si se cumple la condición de terminación, se ha encontrado la raiz aproximada buscada.
converge = false; // Se sobrepasó la máxima cantidad de iteraciones permitidas
if (error <= tolerancia) { // Condición de terminación
break;
converge = true; break;
} else { x1 = x0 - f(x0) / f_derivada(x0); // Cálculo de la siguiente aproximación
// Si no se cumple el criterio de terminación, se pasa a la siguiente iteración
error = fabs(x1 - x0); // El error es la diferencia entre dos aproximaciones sucesivas
} else { x0 = x1; iteracion++;
// Se imprimen los valores de la siguiente aproximación x1, f(x1), f_derivada(x1), error
} }
cout << "\nIteracion #" << iteracion << endl;
} while (1);
} // Respuesta final if (converge) { cout << "\n\nPara una tolerancia de " << tolerancia << " la raiz de f es: " << x1 << endl;
double f(double x) { return x * exp(cos(x)) / 1.5 - 1; //return exp(-x) + 3 * x - 3; }
} else { cout << "\n\nSe sobrepasó la máxima cantidad de iteraciones permitidas" << endl;
double f_derivada(double x) {
}
return exp(cos(x)) * (1 - x * sin(x)) / 1.5;
cin.get(); cin.get(); return 0; }
void tabula(double a, double b, int intervalos) { int puntos = intervalos + 1;
double ancho = (b - a) / intervalos;
cout << "\n\tx\t\tf(x) " << endl; for (int i = 0; i < puntos; i++) { cout << "\t" << a << "\t\t" << f(a) << endl; a = a + ancho; }
//return -1 * exp(-x) + 3; }
{x2=(x1-((x0-x1)/(fun(x0)-fun(x1))*fun(x1)));
#include
printf ("%f \n",x2);
#include
Ea=(fabs (x1-x2));
using namespace std;
x0=x1;
float fun (float x);
x1=x2;
int main() {
}
float error=0.00001,x0,x1,x2,Ea;
printf ("la raiz es:%f \n",x2);
printf ("Metodo de la Secante\n");
return 0;
printf ("Digite el primer valor ");
}
scanf ("%f",&x0);
float fun(float x)
printf ("Digite el segundo valor ");
{float f;
scanf ("%f",&x1);
f=x*x-4;
Ea=error+1;
return f;
while (Ea>error)
}
RAICES MULTIPLES #include
cout<<" - RAICES MULTIPLES "<<endl;
#include <math.h>
cout<<"Digite la aproximacion inicial : "; cin>>*po;
using namespace std;
cout<<"Digite el numero de iteraciones : "; cin>>*N;
using std::cout; using std::endl;
void newton_generalizado(double , int); double eval_funcion(double); double eval_derfuncion(double); double eval_segderfuncion(double); /************************** *************************** **************************/
while(*N<=2)
cout<<"La cantidad de iteraciones debe ser positiva (>2) "<<endl;
}
t2 = ef * esdf ; // f(po) * f''(po)
t4 = t3 - t2 ; // [f'(po)]^2 [f(po) * f''(po)] c = t1 / t4 ; // [f(po) * f'(po)] / [f'(po)]^2 - [f(po) * f''(po)] p = po - c;
//el "paso 3"
efp = eval_funcion(p);
} /************************** *************************** **************************/ void newton_generalizado(double po, int N) {
{
double TOL=0.00000001 , ef=0.0 , edf=0.0, Er=0.0 , p=0.0 , c=0.0 , efp=0.0;
int vn;
t1 = ef * edf ; // f(po) * f'(po)
cout<<"Digite el numero de iteraciones : "; cin>>*N;
main()
double vpo;
esdf = eval_segderfuncion(po);
t3 = edf * edf; // [f'(po)]^2
{ void lecturas(double* , int*);
edf = eval_derfuncion(po);
lecturas(&vpo , &vn);
double esdf = 0.0, t1=0.0 , t2=0.0 , t3=0.0 , t4=0.0;
newton_generalizado(vpo , vn);
int i = 1 ; //el "paso 1"
}
cout.precision(10);
/************************** *************************** ************************/
cout<<"\n"<<"\t-- po -- "<<"\t -p -- "<<"\t -- f(p) -- "<<"\t-- Er -- ";
Er = (p - po)/p; if(Er<0) Er=Er*(-1); //esto es para ayudar al paso 4
//Para mostrar resultados iteracion a iteracion
cout<<"\n"<<<"\t"<<po<<"\t"<
//el "paso 4" if(Er
//el "paso 5" //el "paso 2"
void lecturas(double *po , int *N)
while(i <= N)
{
{ ef = eval_funcion(po);
i = i + 1;
//el "paso 6" redefinicion de po
po = p;
a2 = 8*z;
r = a1 - a2 + a3 + a4 - a5 - 32;
}
r = a1 - a2;
return r;
return r;
}
//el "paso 7" if((i>N)||(Er>TOL)) {cout<<"\nEl metodo fracaso despues de "<
} double eval_derfuncion(double z) double eval_segderfuncion(double y)
{
{
double r=0.0, a1 = 0.0, a2 = 0.0, a3= 0.0, a4=0.0;
double r=0.0, a1 = 0.0;
a1 = 6*pow(z,5);
/************************** *************************** **************************/
a1 = 12*y*y;
a2 = 60*pow(z,3);
r = a1 - 8;
a3 = 42*pow(z,2);
//EJEMPLO
return r;
a4 = 72*z;
}
r = a1 - a2 + a3 + a4 - 24;
double eval_funcion(double v)
return r;
{
}
double r=0.0 , a1 = 0.0, a2 = 0.0;
//EJEMPLO 2
a1 = pow(v,4);
/*
a2 = 4*v*v;
double eval_funcion(double v)
r = a1 - a2 + 4;
{
return r;
double r=0.0 , a1 = 0.0, a2 = 0.0, a3= 0.0, a4=0.0, a5=0.0;
}
a1 = pow(v,6); double eval_derfuncion(double z)
a2 = 15*pow(v,4);
{
a3 = 14*pow(v,3);
double r=0.0, a1 = 0.0, a2 = 0.0;
a4 = 36*pow(v,2);
a1 = 4*z*z*z;
a5 = 24*v;
*/
double eval_segderfuncion(double y) { double r = 0.0 , a1 = 0.0, a2 = 0.0, a3 = 0.0; a1 = 30*pow(y,4); a2 = 180*pow(y,2); a3 = 84*y; r = a1 - a2 + a3 + 72; return r; }
S.E.P.
S.E.S.
Tec N.M.
INSTITUTO TECNOLÓGICO DE TOLUCA PROGRAMACIONES DE METODOS NUMERICOS CALIF. : ______ CARRERA: ING. MECATRÓNICA MATERIA: METODOS NUEMERICOS GRUPO: 187701 PROFESOR: OSORIO DE JESUS NAYELY ALUMNO: ALMARAZ MEDINA JOSE HILARIO
TOLUCA, MÉX. A 27 DE FEBRERO DE 2019
PUNTO FIJO #include <stdio.h> #include <math.h> #define e 2.718281828
scanf("%lf", &TOL);
}
printf("Numero maximo de iteraciones: ");
else{
scanf("%d", &N);
//paso 5
//paso 1
double fun (double);
i++;
i = 1; main (){
y el resultado se da en la 6ta. iteracion*/
P0 = P;
//paso 2
/*Para resolver la funcion siguiente x = 2 e^x + x^2/3 con N = 10 o mas iteraciones TOL = 0.001 P0 =0
//paso 6
OK = 1;
int i, N, OK;
P = fun (P0);
b = fabs(P - P0);
printf ("Metodo Punto Fijo\n");
printf("Numero de iteraciones N = %d\n", i);
printf("Tolerancia TOL:
printf("\n\nEl metodo fallo con un numero de iteraciones N = %d\n\n", N);
//paso 4
printf("Solucion aproximada P = %12.8f\n", P);
");
if(OK == 1)
//paso 3
if(b < TOL){
scanf ("%lf", &P0);
//paso 7
1){
printf("Antes de continuar, cambia la funcion para un nuevo prblema\n");
printf("Aproximacion inicial P0: ");
}
while(i <= N && OK ==
printf("%d\t%12.8f\n", i, P); double P0,TOL,P,b;
}
printf("\n\nI\t\tP\n");
return 0; }//cambia la funcion para un nuevo problema double fun(double x){ double a; a = (2 - pow (e, x) + x*x)/3; return a; }
printf("Tolerancia TOL = %5.11f\n\n", TOL); OK = 0;
PUNTO FIJO
NEWTON-RAPHSON
RAICES MULTIPLES
SECANTE
NEWTON-RAPHSON #include
cout << setprecision(PRECISION); // Se establece la precisión
#include
cout << "\nCalculo de las raices de una funcion aplicando el metodo de Newton - Raphson\n";
#define PRECISION 10 #define MAX_ITERACIONES 100 #define INTERVALOS 6
cout << "\nIngrese el intervalo inicial [a,b]:" << endl;
// Se ingresa el intervalo
using namespace std;
cout << "\na = "; cin >> a;
void tabula(double a, double b, int intervalos); // Muestra un # tabulado de intervalos
cout << "b = ";
double f(double x); // Retorna el valor de la función evaluada en x double f_derivada(double x); // Retorna la derivada de la función evaluada en x
cin >> b;
// Se tabulan los valores de f para INTERVALOS intervalos tabula(a, b, INTERVALOS);
int main() {
// Se pide elegir una aproximación
double a;
inicial
double b; double tolerancia;
// Tolerancia
double x0; // Primera aproximación
cout << "\nEscoja el punto inicial adecuado: x0 = "; cin >> x0;
double x1; // Siguiente aproximación double error; // Diferencia entre dos aproximaciones sucesivas: x1 - x0 int iteracion; // # de iteraciones bool converge = true;
// Se pide ingresar la tolerancia cout << "Tolerancia = "; cin >> tolerancia;
// Iteraciones
cout << "x" << iteracion << " = " << x1 << "\n"
// Se imprimen los valores de la primera aproximación cout << "\nAproximacion inicial:\n";
<< "f(x" << iteracion << ") = " << f(x1) << "\n" << "f'(x" << iteracion << ") = " << f_derivada(x1) << "\n"
cout << "x0 = " << x0 << "\n" << "f(x0) = " << f(x0) << "\n" << "f'(x0) = " << f_derivada(x0) << endl;
iteracion = 1;
<< "error = " << error << endl;
// La diferencia entre dos aproximaciones sucesivas es también conocida como error. // La condición de terminación consiste en que que el error debe ser <= que la tolerancia dada
do {
if (iteracion > MAX_ITERACIONES) {
// Si se cumple la condición de terminación, se ha encontrado la raiz aproximada buscada.
converge = false; // Se sobrepasó la máxima cantidad de iteraciones permitidas
if (error <= tolerancia) { // Condición de terminación
break;
converge = true; break;
} else { x1 = x0 - f(x0) / f_derivada(x0); // Cálculo de la siguiente aproximación
// Si no se cumple el criterio de terminación, se pasa a la siguiente iteración
error = fabs(x1 - x0); // El error es la diferencia entre dos aproximaciones sucesivas
} else { x0 = x1; iteracion++;
// Se imprimen los valores de la siguiente aproximación x1, f(x1), f_derivada(x1), error
} }
cout << "\nIteracion #" << iteracion << endl;
} while (1);
} // Respuesta final if (converge) { cout << "\n\nPara una tolerancia de " << tolerancia << " la raiz de f es: " << x1 << endl;
double f(double x) { return x * exp(cos(x)) / 1.5 - 1; //return exp(-x) + 3 * x - 3; }
} else { cout << "\n\nSe sobrepasó la máxima cantidad de iteraciones permitidas" << endl;
double f_derivada(double x) {
}
return exp(cos(x)) * (1 - x * sin(x)) / 1.5;
cin.get(); cin.get(); return 0; }
void tabula(double a, double b, int intervalos) { int puntos = intervalos + 1;
double ancho = (b - a) / intervalos;
cout << "\n\tx\t\tf(x) " << endl; for (int i = 0; i < puntos; i++) { cout << "\t" << a << "\t\t" << f(a) << endl; a = a + ancho; }
//return -1 * exp(-x) + 3; }
More Documents from "Lalo Almaraz"
Imprimir.docx
June 2020 6
Krilov.docx
June 2020 2
Krilov.docx
June 2020 4
Noticias (2019).docx
June 2020 5