# Algorithms_in_C++: numerical_methods/midpoint_integral_method.cpp File Reference

Loading...
Searching...
No Matches
midpoint_integral_method.cpp File Reference

A numerical method for easy approximation of integrals More...

`#include <cassert>`
`#include <cmath>`
`#include <cstdint>`
`#include <cstdlib>`
`#include <functional>`
`#include <iostream>`
`#include <map>`
Include dependency graph for midpoint_integral_method.cpp:

## Namespaces

namespace | numerical_methods
| for assert
namespace | midpoint_rule
| Functions for the Midpoint Integral method implementation.

## Functions

double | numerical_methods::midpoint_rule::midpoint (const std::int32_t N, const double h, const double a, const std::function< double(double)> &func)
| Main function for implementing the Midpoint Integral Method implementation. More...
double | numerical_methods::midpoint_rule::f (double x)
| A function f(x) that will be used to test the method. More...
double | numerical_methods::midpoint_rule::g (double x)
| A function g(x) that will be used to test the method. More...
double | numerical_methods::midpoint_rule::k (double x)
| A function k(x) that will be used to test the method. More...
double | numerical_methods::midpoint_rule::l (double x)
| A function l(x) that will be used to test the method. More...
static void | test (std::int32_t N, double h, double a, double b, bool used_argv_parameters)
| Self-test implementations. More...
int | main (int argc, char **argv)
| Main function. More...

## Detailed Description

A numerical method for easy approximation of integrals

The idea is to split the interval into N of intervals and use as interpolation points the xi for which it applies that xi = x0 + i*h, where h is a step defined as h = (b-a)/N where a and b are the first and last points of the interval of the integration [a, b].

We create a table of the xi and their corresponding f(xi) values and we evaluate the integral by the formula: I = h * {f(x0+h/2) + f(x1+h/2) + ... + f(xN-1+h/2)}

Arguments can be passed as parameters from the command line argv[1] = N, argv[2] = a, argv[3] = b. In this case if the default values N=16, a=1, b=3 are changed then the tests/assert are disabled.

Author
  ggkogkou

## Function Documentation

## f()

double numerical_methods::midpoint_rule::f | ( | double | x | ) |

A function f(x) that will be used to test the method.

Parameters

  x | The independent variable xi

Returns
  the value of the dependent variable yi = f(xi) = sqrt(xi) + ln(xi)

{ return std::sqrt(x) + std::log(x); }
std::log
T log(T... args)
std::sqrt
T sqrt(T... args)
Here is the call graph for this function:

## g()

double numerical_methods::midpoint_rule::g | ( | double | x | ) |

A function g(x) that will be used to test the method.

Parameters

  x | The independent variable xi

Returns
  the value of the dependent variable yi = g(xi) = e^(-xi) * (4 - xi^2)

{ return std::exp(-x) * (4 - std::pow(x, 2)); }
std::exp
T exp(T... args)
std::pow
T pow(T... args)
Here is the call graph for this function:

## k()

double numerical_methods::midpoint_rule::k | ( | double | x | ) |

A function k(x) that will be used to test the method.

Parameters

  x | The independent variable xi

Returns
  the value of the dependent variable yi = k(xi) = sqrt(2*xi^3 + 3)

{ return std::sqrt(2 * std::pow(x, 3) + 3); }
Here is the call graph for this function:

## l()

double numerical_methods::midpoint_rule::l | ( | double | x | ) |

A function l(x) that will be used to test the method.

Parameters

  x | The independent variable xi

Returns
  the value of the dependent variable yi = l(xi) = xi + ln(2*xi + 1)

{ return x + std::log(2 * x + 1); }
Here is the call graph for this function:

## main()

int main | ( | int | argc,
|  | char ** | argv
| ) |  |

Main function.

Parameters

  argc | commandline argument count (ignored)
  argv | commandline array of arguments (ignored)

Returns
  0 on exit

Number of intervals to divide the integration interval.

MUST BE EVEN

Starting and ending point of the integration in

the real axis

Step, calculated by a, b and N

{
std::int32_t N =
16; /// Number of intervals to divide the integration interval.
/// MUST BE EVEN
double a = 1, b = 3; /// Starting and ending point of the integration in
/// the real axis
double h = NAN; /// Step, calculated by a, b and N
bool used_argv_parameters =
false; // If argv parameters are used then the assert must be omitted
// for the test cases
// Get user input (by the command line parameters or the console after
// displaying messages)
if (argc == 4) {
N = std::atoi(argv[1]);
a = std::atof(argv[2]);
b = std::atof(argv[3]);
// Check if a<b else abort
assert(a < b && "a has to be less than b");
assert(N > 0 && "N has to be > 0");
if (N < 4 || a != 1 || b != 3) {
used_argv_parameters = true;
}
std::cout << "You selected N=" << N << ", a=" << a << ", b=" << b
<< std::endl;
} else {
std::cout << "Default N=" << N << ", a=" << a << ", b=" << b
<< std::endl;
}
// Find the step
h = (b - a) / N;
test(N, h, a, b, used_argv_parameters); // run self-test implementations
return 0;
}
std::atof
T atof(T... args)
std::atoi
T atoi(T... args)
std::cout
test
void test()
Definition: caesar_cipher.cpp:100
data_structures::sparse_table::N
constexpr uint32_t N
A struct to represent sparse table for min() as their invariant function, for the given array A....
Definition: sparse_table.cpp:47
std::endl
T endl(T... args)
h
int h(int key)
Definition: hash_search.cpp:45
std::int32_t
Here is the call graph for this function:

## midpoint()

double numerical_methods::midpoint_rule::midpoint | ( | const std::int32_t | N,
|  | const double | h,
|  | const double | a,
|  | const std::function< double(double)> & | func
| ) |  |

Main function for implementing the Midpoint Integral Method implementation.

Parameters

  N | is the number of intervals
  h | is the step
  a | is x0
  func | is the function that will be integrated

Returns
  the result of the integration

{
std::map<int, double>
data_table; // Contains the data points, key: i, value: f(xi)
double xi = a; // Initialize xi to the starting point x0 = a
// Create the data table
// Loop from x0 to xN-1
double temp = NAN;
for (std::int32_t i = 0; i < N; i++) {
temp = func(xi + h / 2); // find f(xi+h/2)
data_table.insert(
std::pair<std::int32_t, double>(i, temp)); // add i and f(xi)
xi += h; // Get the next point xi for the next iteration
}
// Evaluate the integral.
// Remember: {f(x0+h/2) + f(x1+h/2) + ... + f(xN-1+h/2)}
double evaluate_integral = 0;
for (std::int32_t i = 0; i < N; i++) evaluate_integral += data_table.at(i);
// Multiply by the coefficient h
evaluate_integral *= h;
// If the result calculated is nan, then the user has given wrong input
// interval.
assert(!std::isnan(evaluate_integral) &&
"The definite integral can't be evaluated. Check the validity of "
"your input.\n");
// Else return
return evaluate_integral;
}
std::map::at
T at(T... args)
std::map::insert
T insert(T... args)
std::isnan
T isnan(T... args)
std::map
std::pair
Here is the call graph for this function:

## test()

static void test | ( | std::int32_t | N,
|  | double | h,
|  | double | a,
|  | double | b,
|  | bool | used_argv_parameters
| ) |  |

static

Self-test implementations.

Parameters

  N | is the number of intervals
  h | is the step
  a | is x0
  b | is the end of the interval
  used_argv_parameters | is 'true' if argv parameters are given and 'false' if not

{
// Call midpoint() for each of the test functions f, g, k, l
// Assert with two decimal point precision
double result_f = numerical_methods::midpoint_rule::midpoint(
N, h, a, numerical_methods::midpoint_rule::f);
assert((used_argv_parameters || (result_f >= 4.09 && result_f <= 4.10)) &&
"The result of f(x) is wrong");
std::cout << "The result of integral f(x) on interval [" << a << ", " << b
<< "] is equal to: " << result_f << std::endl;
double result_g = numerical_methods::midpoint_rule::midpoint(
N, h, a, numerical_methods::midpoint_rule::g);
assert((used_argv_parameters || (result_g >= 0.27 && result_g <= 0.28)) &&
"The result of g(x) is wrong");
std::cout << "The result of integral g(x) on interval [" << a << ", " << b
<< "] is equal to: " << result_g << std::endl;
double result_k = numerical_methods::midpoint_rule::midpoint(
N, h, a, numerical_methods::midpoint_rule::k);
assert((used_argv_parameters || (result_k >= 9.06 && result_k <= 9.07)) &&
"The result of k(x) is wrong");
std::cout << "The result of integral k(x) on interval [" << a << ", " << b
<< "] is equal to: " << result_k << std::endl;
double result_l = numerical_methods::midpoint_rule::midpoint(
N, h, a, numerical_methods::midpoint_rule::l);
assert((used_argv_parameters || (result_l >= 7.16 && result_l <= 7.17)) &&
"The result of l(x) is wrong");
std::cout << "The result of integral l(x) on interval [" << a << ", " << b
<< "] is equal to: " << result_l << std::endl;
}
numerical_methods::midpoint_rule::midpoint
double midpoint(const std::int32_t N, const double h, const double a, const std::function< double(double)> &func)
Main function for implementing the Midpoint Integral Method implementation.
Definition: midpoint_integral_method.cpp:52
Here is the call graph for this function: