INSTITUTO POLITECNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERIA MECANICA

Y ELECTRICA CULHUACAN

METODOS NUMERICOS

BALDERRAMA LOPEZ JAVIER

Batería de ejercicios

2SM13
Castro Medina Pablo Antonio
8.1

#include <iostream>

#include <cmath>

double func(double x) {

return x*exp(x*x);

double rectangularRule(double a, double b, double h) {

double sum = 0.0;

for (double x = a + (h / 2); x <= b; x += h) {

sum += func(x) * h;

return sum;

int main() {

double a, b, h;

double realValue = 10.87312731; // Valor real de la integral

// Ingresa los límites de integración y el tamaño de paso (h)

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese el tamaño de paso (h): ";

std::cin >> h;
 // Calcula la integral usando el método de los rectángulos y muestra el resultado

double result = rectangularRule(a, b, h);

std::cout << "Resultado de la integral: " << result << std::endl;

// Calcula el error porcentual

double error = std::abs((realValue - result) / realValue) * 100.0;

std::cout << "Error porcentual: " << error << "%" << std::endl;

return 0;

8.2

#include <iostream>

#include <cmath>

double funcion(double x)

return x*exp(x*x);

double formulaTrapezoidal(double a, double b, double h)

int n = static_cast<int>((b - a) / h);

double integral = 0.5 * (funcion(a) + funcion(b));

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

double x_i = a + i * h;

integral += funcion(x_i);
 }

integral *= h;

return integral;

int main()

double a = 0.0;

double b = 2.0;

double h = 0.10;

double valorIntegral = formulaTrapezoidal(a, b, h);

double h_previo = h / 2.0;

double valorIntegralPrevio = formulaTrapezoidal(a, b, h_previo);

double ValorReal = 26.79907502;

double errorAproximacionPorcentual = std::abs((ValorReal - valorIntegral) / ValorReal) *

100;

printf("\nValor de la integral: %f\n", valorIntegral);

printf("\nError de aproximacion porcentual respecto al valor previo: %f \n",

errorAproximacionPorcentual);

return 0;

8.3

b)

#include <iostream>

#include <cmath>

double funcion(double x)
{

return x*x*x;

double formulaTrapezoidal(double a, double b, double h)

int n = static_cast<int>((b - a) / h);

double integral = 0.5 * (funcion(a) + funcion(b));

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

double x_i = a + i * h;

integral += funcion(x_i);

integral *= h;

return integral;

int main()

double a = 0.0;

double b = 4.0;

double h = 0.2;

double valorIntegral = formulaTrapezoidal(a, b, h);

double h_previo = h / 2.0;

double valorIntegralPrevio = formulaTrapezoidal(a, b, h_previo);

double ValorReal = 64;

 double errorAproximacionPorcentual = std::abs((ValorReal - valorIntegral) / ValorReal) *
100;

printf("\nValor de la integral: %f\n", valorIntegral);

printf("\nError de aproximacion porcentual respecto al valor previo: %f \n",

errorAproximacionPorcentual);

return 0;

a)

#include <iostream>

#include <cmath>

double func(double x) {

return x*x*x;

double rectangularRule(double a, double b, double h) {

double sum = 0.0;

for (double x = a + (h / 2); x <= b; x += h) {

sum += func(x) * h;

return sum;

int main() {

double a, b, h;

double realValue = 64;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;
 std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese el (h): ";

std::cin >> h;

double result = rectangularRule(a, b, h);

std::cout << "Resultado de la integral: " << result << std::endl;

double error = std::abs((realValue - result) / realValue) * 100.0;

std::cout << "Error porcentual: " << error << "%" << std::endl;

return 0;

8.4

#include <iostream>

#include <cmath>

double funcion(double x)

return 3/x;
}

double formulaTrapezoidal(double a, double b, double h)

int n = static_cast<int>((b - a) / h);

double integral = 0.5 * (funcion(a) + funcion(b));

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

double x_i = a + i * h;

integral += funcion(x_i);

integral *= h;

return integral;

int main()

double a = 1.0;

double b = 4.0;

double h = 0.2;

double valorIntegral = formulaTrapezoidal(a, b, h);

double h_previo = h / 2.0;

double valorIntegralPrevio = formulaTrapezoidal(a, b, h_previo);

double ValorReal = 4.158883083;

double errorAproximacionPorcentual = std::abs((ValorReal - valorIntegral) / ValorReal) *

100;

printf("\nValor de la integral: %f\n", valorIntegral);

 printf("\nError de aproximacion porcentual respecto al valor previo: %f \n",
errorAproximacionPorcentual);

return 0;

8.5

#include <iostream>

#include <cmath>

double func(double x) {

return 3/x;

double rectangularRule(double a, double b, double h) {

double sum = 0.0;

for (double x = a + (h / 2); x <= b; x += h) {

sum += func(x) * h;

return sum;

int main() {

double a, b, h;

double realValue = 4.158883083;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;
 std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese el (h): ";

std::cin >> h;

double result = rectangularRule(a, b, h);

std::cout << "Resultado de la integral: " << result << std::endl;

double error = std::abs((realValue - result) / realValue) * 100.0;

std::cout << "Error porcentual: " << error << "%" << std::endl;

return 0;

8.6

#include <iostream>

#include <iomanip>

#include <cmath>

double func(double x)

return x * exp(x * x);

double simpsonOneThird(double a, double b, double h)

int n = static_cast<int>((b - a) / h);

double sum = func(a) + func(b);

for (int i = 1; i < n; i += 2) {

 double x_i = a + i * h;

sum += 4 * func(x_i);

for (int i = 2; i < n - 1; i += 2) {

double x_i = a + i * h;

sum += 2 * func(x_i); }

return (h / 3) * sum;}

int main() {

double a, b, h, valor_real;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese (h): ";

std::cin >> h;

std::cout << "Ingrese el valor real de la integral: ";

std::cin >> valor_real;

double result = simpsonOneThird(a, b, h);

double error_porcentual = 100 * std::abs(result - valor_real) / valor_real;

std::cout << std::fixed << std::setprecision(6);

std::cout << "Resultado de la integral: " << result << std::endl;

std::cout << "Valor real de la integral: " << valor_real << std::endl;

std::cout << "Error porcentual: " << error_porcentual << "%" << std::endl;

return 0;

}
8.7

#include <iostream>

#include <iomanip>

#include <cmath>

double func(double x)

return sin(x);

double simpsonOneThird(double a, double b, double h)

int n = static_cast<int>((b - a) / h);

double sum = func(a) + func(b);

for (int i = 1; i < n; i += 2) {

double x_i = a + i * h;

sum += 4 * func(x_i);

for (int i = 2; i < n - 1; i += 2) {

double x_i = a + i * h;

sum += 2 * func(x_i); }

return (h / 3) * sum;}

int main() {

double a, b, h, valor_real;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese (h): ";

std::cin >> h;
 std::cout << "Ingrese el valor real de la integral: ";

std::cin >> valor_real;

double result = simpsonOneThird(a, b, h);

double error_porcentual = 100 * std::abs(result - valor_real) / valor_real;

std::cout << std::fixed << std::setprecision(6);

std::cout << "\n\nResultado de la integral: " << result << std::endl;

std::cout << "Valor real de la integral: " << valor_real << std::endl;

std::cout << "Error porcentual: " << error_porcentual << "%" << std::endl;

return 0;

8.8

#include <stdio.h>

#include <math.h>

double func(double x) {

return sin(x); }

double simpsonThreeEighth(double a, double b, int n) {

double h = (b - a) / n;

double sum = func(a) + func(b);

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

double x_i = a + i * h;

if (i % 3 == 0) {

sum += 2 * func(x_i);

} else {

sum += 3 * func(x_i); }}

return (3 * h / 8) * sum;}

int main() {

double a, b;

int n;
 double valor_real;

printf("Ingrese el valor de a: ");

scanf("%lf", &a);

printf("Ingrese el valor de b: ");

scanf("%lf", &b);

printf("Ingrese el numero de subintervalos (debe ser multiplo de 3): ");

scanf("%d", &n);

if (n % 3 != 0) {

printf("El numero de subintervalos debe ser multiplo de 3.\n");

return 1; }

printf("Ingrese el valor real de la integral: ");

scanf("%lf", &valor_real);

double result = simpsonThreeEighth(a, b, n);

double error_porcentual = 100 * fabs(result - valor_real) / fabs(valor_real);

printf("\n\nResultado de la integral: %f\n", result);

printf("\nError porcentual: %f%%\n", error_porcentual);

return 0;

8.9

8.10

#include <stdio.h>

#include <math.h>

double func(double x) {

return 3/x;

double simpsonThreeEighth(double a, double b, double h) {

int n = static_cast<int>((b - a) / h);

 double sum = func(a) + func(b);

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

double x_i = a + i * h;

if (i % 3 == 0) {

sum += 2 * func(x_i);

} else {

sum += 3 * func(x_i);}}

return (3 * h / 8) * sum;}

int main() {

double a, b, h;

double valor_real;

printf("Ingrese el valor de a: ");

scanf("%lf", &a);

printf("Ingrese el valor de b: ");

scanf("%lf", &b);

printf("Ingrese el incremento de integracion (h): ");

scanf("%lf", &h);

if (h <= 0) {

printf("El incremento de integracion (h) debe ser mayor que cero.\n");

return 1; }

printf("Ingrese el valor real de la integral: ");

scanf("%lf", &valor_real);

double result = simpsonThreeEighth(a, b, h);

double error_porcentual = 100 * fabs(result - valor_real) / fabs(valor_real);

printf("\n\nResultado de la integral: %f\n", result);

printf("\nError porcentual: %f%%\n", error_porcentual);

return 0;

}
8.11

#include <cstdio>

#include <cmath>

double func(double x) {

return x*x*x -2*x*x+3*x-6;}

double simpsonOneThird(double a, double b, double h) {

int n = static_cast<int>((b - a) / h);

double sum = func(a) + func(b);

for (int i = 1; i < n; i += 2) {

double x_i = a + i * h;

sum += 4 * func(x_i);}

for (int i = 2; i < n - 1; i += 2) {

double x_i = a + i * h;

sum += 2 * func(x_i);}

return (h / 3) * sum;}

int main() {

double a1 = 0, b1 = 1, h1 = 0.10;

double a2 = 1, b2 = 2, h2 = 0.25;

double a3 = 2, b3 = 3, h3 = 0.50;

double valor_real1 = simpsonOneThird(a1, b1, h1);

double valor_real2 = simpsonOneThird(a2, b2, h2);

double valor_real3 = simpsonOneThird(a3, b3, h3);

double result = valor_real1 + valor_real2 + valor_real3;

double error_global = 100 * std::abs(result - (valor_real1 + valor_real2 + valor_real3)) /

(valor_real1 + valor_real2 + valor_real3);
 printf("Resultado de la integral: %.6f\n", result);

printf("Valor real de la integral (tramo 1): %.6f\n", valor_real1);

printf("Valor real de la integral (tramo 2): %.6f\n", valor_real2);

printf("Valor real de la integral (tramo 3): %.6f\n", valor_real3);

printf("Error global: %.6f%%\n", error_global);

return 0;

8.12

#include <iostream>

#include <cmath>

#include <vector>

double func(double x) {

return x*x*x - x*x;}

double trapezoidalRule(double a, double b, int n) {

double h = (b - a) / n;

double sum = (func(a) + func(b)) / 2.0;

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

double x_i = a + i * h;

sum += func(x_i);}

return h * sum;}

double rombergIntegration(double a, double b, double tolerance) {

int maxIterations = 100;

std::vector<std::vector<double>> rombergTable(maxIterations + 1,
std::vector<double>(maxIterations + 1, 0.0));

for (int k = 0; k <= maxIterations; ++k) {

rombergTable[k][0] = trapezoidalRule(a, b, pow(2, k));

 for (int j = 1; j <= k; ++j) {

rombergTable[k][j] = (pow(4, j) * rombergTable[k][j - 1] - rombergTable[k - 1][j - 1]) /

(pow(4, j) - 1); }

if (k > 0 && std::abs(rombergTable[k][k] - rombergTable[k - 1][k - 1]) < tolerance) {

return rombergTable[k][k]; } }

std::cerr << "El algoritmo de Romberg no convergió en " << maxIterations << " iteraciones." <<
std::endl;

return rombergTable[maxIterations][maxIterations];}

int main() {

double a, b, tolerance, valor_real;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese la tolerancia deseada: ";

std::cin >> tolerance;

std::cout << "Ingrese el valor real de la integral: ";

std::cin >> valor_real;

double result = rombergIntegration(a, b, tolerance);

double error_porcentual = 100 * std::abs(result - valor_real) / valor_real;

std::cout << "Resultado de la integral: " << result << std::endl;

std::cout << "Error porcentual: " << error_porcentual << "%" << std::endl;

return 0;

8.13

#include <iostream>

#include <cmath>

#include <vector>

double func(double x) {

return sin(x)- cos(x);}

double trapezoidalRule(double a, double b, int n) {

double h = (b - a) / n;

double sum = (func(a) + func(b)) / 2.0;

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

double x_i = a + i * h;

sum += func(x_i);}

return h * sum;}

double rombergIntegration(double a, double b, double tolerance) {

int maxIterations = 100;

std::vector<std::vector<double>> rombergTable(maxIterations + 1,
std::vector<double>(maxIterations + 1, 0.0));

for (int k = 0; k <= maxIterations; ++k) {

rombergTable[k][0] = trapezoidalRule(a, b, pow(2, k));

for (int j = 1; j <= k; ++j) {

rombergTable[k][j] = (pow(4, j) * rombergTable[k][j - 1] - rombergTable[k - 1][j - 1]) /

(pow(4, j) - 1); }

if (k > 0 && std::abs(rombergTable[k][k] - rombergTable[k - 1][k - 1]) < tolerance) {

return rombergTable[k][k]; } }

std::cerr << "El algoritmo de Romberg no convergió en " << maxIterations << " iteraciones." <<
std::endl;

return rombergTable[maxIterations][maxIterations];}

int main() {

double a, b, tolerance, valor_real;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese la tolerancia deseada: ";

std::cin >> tolerance;

std::cout << "Ingrese el valor real de la integral: ";

 std::cin >> valor_real;

double result = rombergIntegration(a, b, tolerance);

double error_porcentual = 100 * std::abs(result - valor_real) / valor_real;

std::cout << "Resultado de la integral: " << result << std::endl;

std::cout << "Error porcentual: " << error_porcentual << "%" << std::endl;

return 0;

8.14

#include <iostream>

#include <iomanip>

#include <cmath>

double func(double x)

return sin(x)- cos(x);

double simpsonOneThird(double a, double b, double h)

int n = static_cast<int>((b - a) / h);

double sum = func(a) + func(b);

for (int i = 1; i < n; i += 2) {

double x_i = a + i * h;

sum += 4 * func(x_i);

for (int i = 2; i < n - 1; i += 2) {

double x_i = a + i * h;

sum += 2 * func(x_i); }
 return (h / 3) * sum;}

int main() {

double a, b, h, valor_real;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese (h): ";

std::cin >> h;

std::cout << "Ingrese el valor real de la integral: ";

std::cin >> valor_real;

double result = simpsonOneThird(a, b, h);

double error_porcentual = 100 * std::abs(result - valor_real) / valor_real;

std::cout << std::fixed << std::setprecision(6);

std::cout << "\n\nResultado de la integral: " << result << std::endl;

std::cout << "Error porcentual: " << error_porcentual << "%" << std::endl;

return 0;

8.15

8.16

#include <iostream>

#include <cmath>

using namespace std;

double funcion(double x) {
 return 4 / x;

double gaussLegendre3(double a, double b) {

const double weights[] = {5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0};

const double nodes[] = {-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)};

double result = 0.0;

for (int i = 0; i < 3; ++i) {

double x_mapped = 0.5 * (b - a) * nodes[i] + 0.5 * (a + b);

result += weights[i] * funcion(x_mapped); }

result *= 0.5 * (b - a);

return result;}

int main() {

double a, b;

cout << "Ingrese el limite inferior (a): ";

cin >> a;

cout << "Ingrese el limite superior (b): ";

cin >> b;

double realValue;

cout << "Ingrese el valor real de la integral: ";

cin >> realValue;

double integral = gaussLegendre3(a, b);

double errorPercent = fabs((realValue - integral) / realValue) * 100;

cout << "Aproximacion de la integral: " << integral << endl;

cout << "Error porcentual: " << errorPercent << "%" << endl;

return 0;
}

8.17

#include <iostream>

#include <iomanip>

#include <cmath>

double func(double x)

return 4/x;

double simpsonOneThird(double a, double b, double h) {

int n = static_cast<int>((b - a) / h);

double sum = func(a) + func(b);

for (int i = 1; i < n; i += 2) {

double x_i = a + i * h;

sum += 4 * func(x_i);

for (int i = 2; i < n - 1; i += 2) {

double x_i = a + i * h;

sum += 2 * func(x_i); }

return (h / 3) * sum;}

int main() {

double a, b, h, valor_real;

std::cout << "Ingrese el valor de a: ";

std::cin >> a;

std::cout << "Ingrese el valor de b: ";

std::cin >> b;

std::cout << "Ingrese (h): ";

std::cin >> h;
 std::cout << "Ingrese el valor real de la integral: ";

std::cin >> valor_real;

double result = simpsonOneThird(a, b, h);

double error_porcentual = 100 * std::abs(result - valor_real) / valor_real;

std::cout << std::fixed << std::setprecision(6);

std::cout << "\n\nResultado de la integral: " << result << std::endl;

std::cout << "Error porcentual: " << error_porcentual << "%" << std::endl;

return 0;

8.18 (el error es 0 porque el valor original de la integral es el mismo que el del cálculo)

#include <iostream>

#include <cmath>

using namespace std;

double funcion(double x) {

return x*x*x*x - 2*x*x*x + 6;

double gaussLegendre4(double a, double b) {

const double weights[] = {0.3478548451, 0.6521451549, 0.6521451549, 0.3478548451};

const double nodes[] = {-0.8611363116, -0.3399810436, 0.3399810436, 0.8611363116};

double result = 0.0;

for (int i = 0; i < 4; ++i) {

double x_mapped = 0.5 * (b - a) * nodes[i] + 0.5 * (a + b);

result += weights[i] * funcion(x_mapped);

 }

result *= 0.5 * (b - a);

return result;

int main() {

double a, b;

cout << "Ingrese el limite inferior (a): ";

cin >> a;

cout << "Ingrese el limite superior (b): ";

cin >> b;

double integral = gaussLegendre4(a, b);

cout << "Aproximacion de la integral: " << integral << endl;

return 0;

8.19

8.20

8.21 (solo me agarra bien en el cel)

#include <iostream>

#include <cmath>

#include <iomanip>

using namespace std;

// Función a integrar

double funtion(double x) {

// Coloca tu función aquí

return x/sqrt(1-x*x);

// Cuadratura de Gauss-Chebyshev con 3 puntos base en el intervalo [-1, 1]

double gaussChebyshev(int n) {

// Nodos y pesos para Gauss-Chebyshev con n puntos base

// (Puedes encontrar estos valores en tablas o calcularlos)

// Aquí se proporciona un ejemplo para n = 3

double nodes[3] = {0.7071067812, 0, -0.7071067812};

double weights[3] = {1.0471975512, 1.0471975512, 1.0471975512};

double result = 0.0;

// Cálculo de la integral numérica

for (int i = 0; i < n; ++i) {

result += weights[i] *funtion(nodes[i]);

return result;

int main() {

int n = 3; // Puedes ajustar el número de puntos de Gauss-Chebyshev según sea necesario

double integralResult = gaussChebyshev(n);

 // Mostrar el resultado

cout << "Resultado de la integral: " << setprecision(8) << integralResult << endl;

return 0;

8.22

8.23 (solo me agarra bien en el cel)

#include <iostream>

#include <cmath>

#include <iomanip>

using namespace std;

// Función a integrar

double function(double x) {

// Coloca tu función aquí

return x * exp(-x * x);

// Cuadratura de Gauss-Hermite con 3 puntos base

double gaussHermite3() {

// Nodos y pesos para Gauss-Hermite con 3 puntos base

// (Puedes encontrar estos valores en tablas o calcularlos)

// Aquí se proporciona un ejemplo

double nodes[3] = {-1.2247448714, 0.0, 1.2247448714};

double weights[3] = {0.2954089751, 1.1816359006, 0.2954089751};

double result = 0.0;

 // Cálculo de la integral numérica

for (int i = 0; i < 3; ++i) {

result += weights[i] * function(nodes[i]);

return result;

int main() {

double integralResult = gaussHermite3();

// Mostrar el resultado

cout << "Resultado de la integral: " << setprecision(8) << integralResult << endl;

return 0;