Data Analysis Mathematics Linear Algebra Statistics
Version 8.1

Supports .NET 7.0 and earlier. Try it for free with our fully functional 30-day trial version.

QuickStart Samples

# Basic Integration QuickStart Sample (C#)

Illustrates the basic numerical integration classes in C#.

```using System;

namespace Extreme.Numerics.QuickStart.CSharp
{
// The numerical integration classes reside in the
// Extreme.Mathematics.Calculus namespace.
using Extreme.Mathematics.Calculus;
// Function delegates reside in the Extreme.Mathematics
// namespace.
using Extreme.Mathematics;
using Extreme.Mathematics.Algorithms;

/// <summary>
/// Illustrates the basic use of the numerical integration
/// classes in the Extreme.Mathematics.Calculus namespace of the Extreme
/// Optimization Mathematics Library for .NET.
/// </summary>
class BasicIntegration
{
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
// Numerical integration algorithms fall into two
// This QuickStart Sample illustrates the use of
// the non-adaptive numerical integrators.
//
// All numerical integration classes derive from
// NumericalIntegrator. This abstract base class
// defines properties and methods that are shared
// by all numerical integration classes.

//
// The integrand
//

// The function we are integrating must be
// provided as a Func<double, double>. For more
// FunctionDelegates QuickStart sample.
Func<double, double> f = Math.Sin;
// Variable to hold the result:
double result;

//
// SimpsonIntegrator
//

// The simplest numerical integration algorithm
// is Simpson's rule.
SimpsonIntegrator simpson = new SimpsonIntegrator();
// You can set the relative or absolute tolerance
// to which to evaluate the integral.
simpson.RelativeTolerance = 1e-5;
// You can select the type of tolerance using the
// ConvergenceCriterion property:
simpson.ConvergenceCriterion =
ConvergenceCriterion.WithinRelativeTolerance;
// The Integrate method performs the actual
// integration:
result = simpson.Integrate(f, 0, 2);
Console.WriteLine("sin(x) on [0,2]");
Console.WriteLine("Simpson integrator:");
// The result is also available in the Result
// property:
Console.WriteLine("  Value: {0}", simpson.Result);
// To see whether the algorithm ended normally,
// inspect the Status property:
Console.WriteLine("  Status: {0}", simpson.Status);
// You can find out the estimated error of the result
// through the EstimatedError property:
Console.WriteLine("  Estimated error: {0}", simpson.EstimatedError);
// The number of iterations to achieve the result
// is available through the IterationsNeeded property.
Console.WriteLine("  Iterations: {0}", simpson.IterationsNeeded);
// The number of function evaluations is available
// through the EvaluationsNeeded property.
Console.WriteLine("  Function evaluations: {0}", simpson.EvaluationsNeeded);

//
// Gauss-Kronrod Integration
//

// Gauss-Kronrod integrators also use a fixed point
// scheme, but with certain optimizations in the
// choice of points where the integrand is evaluated.

// The NonAdaptiveGaussKronrodIntegrator uses a
// succession of 10, 21, 43, and 87 point rules
// to approximate the integral.
nagk.Integrate(Math.Sin, 0, 2);
Console.WriteLine("  Value: {0}", nagk.Result);
Console.WriteLine("  Status: {0}", nagk.Status);
Console.WriteLine("  Estimated error: {0}", nagk.EstimatedError);
Console.WriteLine("  Iterations: {0}", nagk.IterationsNeeded);
Console.WriteLine("  Function evaluations: {0}", nagk.EvaluationsNeeded);

//
// Romberg Integration
//

// Romberg integration combines Simpson's Rule
// with a scheme to accelerate convergence.
// This algorithm is useful for smooth integrands.
RombergIntegrator romberg = new RombergIntegrator();
result = romberg.Integrate(Math.Sin, 0, 2);
Console.WriteLine("Romberg integration:");
Console.WriteLine("  Value: {0}", romberg.Result);
Console.WriteLine("  Status: {0}", romberg.Status);
Console.WriteLine("  Estimated error: {0}", romberg.EstimatedError);
Console.WriteLine("  Iterations: {0}", romberg.IterationsNeeded);
Console.WriteLine("  Function evaluations: {0}", romberg.EvaluationsNeeded);

// However, it breaks down if the integration
// algorithm contains singularities or
// discontinuities.
//
// The AdaptiveIntegrator can handle this type
// of integrand, and many other difficult cases.
// See the AdvancedIntegration QuickStart sample
// for details.
result = romberg.Integrate(x => x <= 0.0 ? 0.0 : Math.Pow(x,-0.9) * Math.Log(1/x),
0.0, 1.0);
Console.WriteLine("Romberg on hard integrand:");
Console.WriteLine("  Value: {0}", romberg.Result);
Console.WriteLine("  Actual value: 100");
Console.WriteLine("  Status: {0}", romberg.Status);
Console.WriteLine("  Estimated error: {0}", romberg.EstimatedError);
Console.WriteLine("  Iterations: {0}", romberg.IterationsNeeded);
Console.WriteLine("  Function evaluations: {0}", romberg.EvaluationsNeeded);

Console.Write("Press Enter key to exit...");
}

/// <summary>
/// Function that will cause difficulties to the
/// simplistic integration algorithms.
/// </summary>
private static double HardIntegrand(double x)
{
// This is put in because some integration rules
// evaluate the function at x=0.
if (x <= 0)
return 0;
return Math.Pow(x,-0.9) * Math.Log(1/x);
}
}
}```