# Algorithms_in_C++: math/integral_approximation.cpp File Reference

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

Compute integral approximation of the function using Riemann sum More...

`#include <cassert>`
`#include <cmath>`
`#include <functional>`
`#include <iostream>`
Include dependency graph for integral_approximation.cpp:

## Namespaces

namespace | math
| for std::rand

## Functions

double | math::integral_approx (double lb, double ub, const std::function< double(double)> &func, double delta=.0001)
| Computes integral approximation. More...
void | math::test_eval (double approx, double expected, double threshold)
| Wrapper to evaluate if the approximated value is within `.XX%` threshold of the exact value. More...
static void | test ()
int | main ()
| Main function. More...

## Detailed Description

Compute integral approximation of the function using Riemann sum

In mathematics, a Riemann sum is a certain kind of approximation of an integral by a finite sum. It is named after nineteenth-century German mathematician Bernhard Riemann. One very common application is approximating the area of functions or lines on a graph and the length of curves and other approximations. The sum is calculated by partitioning the region into shapes (rectangles, trapezoids, parabolas, or cubics) that form a region similar to the region being measured, then calculating the area for each of these shapes, and finally adding all of these small areas together. This approach can be used to find a numerical approximation for a definite integral even if the fundamental theorem of calculus does not make it easy to find a closed-form solution. Because the region filled by the small shapes is usually not the same shape as the region being measured, the Riemann sum will differ from the area being measured. This error can be reduced by dividing up the region more finely, using smaller and smaller shapes. As the shapes get smaller and smaller, the sum approaches the Riemann integral.

Author
  Benjamin Walton
  Shiqi Sheng

## Function Documentation

## main()

int main | ( | void |  | ) |

Main function.

Returns
  0 on exit

{
test(); // run self-test implementations
return 0;
}
test
void test()
Definition: caesar_cipher.cpp:100
Here is the call graph for this function:

## test()

static void test | ( |  | ) |

static

{
double test_1 = math::integral_approx(
3.24, 7.56, [](const double x) { return log(x) + exp(x) + x; });
std::cout << "Test Case 1" << std::endl;
std::cout << "function: log(x) + e^x + x" << std::endl;
std::cout << "range: [3.24, 7.56]" << std::endl;
std::cout << "value: " << test_1 << std::endl;
math::test_eval(test_1, 1924.80384023549, .001);
std::cout << "Test 1 Passed!" << std::endl;
std::cout << "=====================" << std::endl;
double test_2 = math::integral_approx(0.023, 3.69, [](const double x) {
return x * x + cos(x) + exp(x) + log(x) * log(x);
});
std::cout << "Test Case 2" << std::endl;
std::cout << "function: x^2 + cos(x) + e^x + log^2(x)" << std::endl;
std::cout << "range: [.023, 3.69]" << std::endl;
std::cout << "value: " << test_2 << std::endl;
math::test_eval(test_2, 58.71291345202729, .001);
std::cout << "Test 2 Passed!" << std::endl;
std::cout << "=====================" << std::endl;
double test_3 = math::integral_approx(
10.78, 24.899, [](const double x) { return x * x * x - x * x + 378; });
std::cout << "Test Case 3" << std::endl;
std::cout << "function: x^3 - x^2 + 378" << std::endl;
std::cout << "range: [10.78, 24.899]" << std::endl;
std::cout << "value: " << test_3 << std::endl;
math::test_eval(test_3, 93320.65915078377, .001);
std::cout << "Test 3 Passed!" << std::endl;
std::cout << "=====================" << std::endl;
double test_4 = math::integral_approx(
.101, .505,
[](const double x) { return cos(x) * tan(x) * x * x + exp(x); },
.00001);
std::cout << "Test Case 4" << std::endl;
std::cout << "function: cos(x)*tan(x)*x^2 + e^x" << std::endl;
std::cout << "range: [.101, .505]" << std::endl;
std::cout << "value: " << test_4 << std::endl;
math::test_eval(test_4, 0.566485986311631, .001);
std::cout << "Test 4 Passed!" << std::endl;
std::cout << "=====================" << std::endl;
double test_5 = math::integral_approx(
-1, 1, [](const double x) { return exp(-1 / (x * x)); });
std::cout << "Test Case 5" << std::endl;
std::cout << "function: e^(-1/x^2)" << std::endl;
std::cout << "range: [-1, 1]" << std::endl;
std::cout << "value: " << test_5 << std::endl;
math::test_eval(test_5, 0.1781477117815607, .001);
std::cout << "Test 5 Passed!" << std::endl;
}
std::cout
std::cos
T cos(T... args)
std::endl
T endl(T... args)
std::exp
T exp(T... args)
test_1
static void test_1()
Definition: heavy_light_decomposition.cpp:505
test_2
static void test_2()
Definition: heavy_light_decomposition.cpp:549
test_3
static void test_3()
Definition: heavy_light_decomposition.cpp:592
std::log
T log(T... args)
math::test_eval
void test_eval(double approx, double expected, double threshold)
Wrapper to evaluate if the approximated value is within .XX% threshold of the exact value.
Definition: integral_approximation.cpp:51
math::integral_approx
double integral_approx(double lb, double ub, const std::function< double(double)> &func, double delta=.0001)
Computes integral approximation.
Definition: integral_approximation.cpp:31
std::tan
T tan(T... args)