# C# Integration Example

← All NMath Code Examples

```using System;

using CenterSpace.NMath.Core;

namespace CenterSpace.NMath.Core.Examples.CSharp
{
/// <summary>
/// A .NET example in C# showing how to create integrator objects for greater control
/// over how numerical integration is performed.
/// </summary>
class IntegrationExample
{

static double MyFunction( double x )
{
return Math.Sqrt( x );
}

static void Main( string[] args )
{
Console.WriteLine();

Console.WriteLine( "Known exact integral of f from 1 to 4 = 4.6666666...\n" );

// As shown in the OneVariableFunctionExample, the Integrate() method
// on OneVariableFunction computes the integral of a function over a
// given interval.
var d = new Func<double, double>( MyFunction );
OneVariableFunction f = d;
Console.WriteLine( "Estimate using default Romberg integrator = {0}",
f.Integrate( 1, 4 ) );

// To perform integration, every OneVariableFunction has an IIntegrator
// object associated with it. NMath Core integration classes such as
// RombergIntegrator and GaussKronrodIntegrator implement the IIntegrator
// interface. The default integrator for a OneVariableFunction is an instance
// of RombergIntegrator.

// Instances of class RombergIntegrator compute successive Romberg
// approximations of increasing order until the estimated error in the
// approximation is less than a specified error tolerance, or until the
// maximum order is reached. To achieve greater control over how integration
// is performed, you can instantiate your own RombergIntegrator.
var romberg = new RombergIntegrator();

// The Tolerance property gets and sets the error tolerance used in computing
// integrals. MaximumOrder gets and sets the maximum order.
romberg.Tolerance = 1e-10;
romberg.MaximumOrder = 20;

// The Integrate() method on RombergIntegrator accepts a
// OneVariableFunction and an interval over which to integrate.
Console.WriteLine( "Estimate using customized Romberg integrator = {0}",
romberg.Integrate( f, 1, 4 ) );

// After computing an estimate, a RombergIntegrator holds a record of
// the iteration process. Read-only properties are provided for accessing
// this information.
Console.WriteLine( "Order of estimate = {0}", romberg.Order );
Console.WriteLine( "Error estimate = {0}", romberg.RombergErrorEstimate );

// ToleranceMet gets a boolean value indicating whether or not the error
// estimate for the integral approximation is less than the tolerance.
if ( romberg.ToleranceMet )
{
Console.WriteLine( "The estimate is within the error tolerance.\n" );
}
else
{
Console.WriteLine( "The estimate is NOT within the error tolerance.\n" );
}

// Tableau gets the entire matrix of successive approximations
// computed while computing a Romberg estimate. The rows are the order
// of approximation. The columns are the level of approximation.
// The first column contains the trapezoidal approximations,
// the second column the Simpson’s rule approximations, the third
// column the Boole’s rule approximations, and so on, up to the Order
// of the approximation just computed.
Console.WriteLine( "Romberg Tableau:" );
Console.WriteLine( romberg.Tableau.ToTabDelimited( "F5" ) );

// The automatic GaussKronrodIntegrator class uses Gauss-Kronrod rules with
// increasing number of points. Approximation ends when the estimated error
// is less than a specified error tolerance, or when the maximum number of
// points is reached. The Gauss-Kronrod method is especially suited for
// non-singular oscillating integrands.
var gk = new GaussKronrodIntegrator();
Console.WriteLine( "\nEstimate using Gauss-Kronrod automatic integrator = {0}",
gk.Integrate( f, 1, 4 ) );

// NMath Core also includes Gauss-Kronrod classes for different numbers of
// Kronrod points (2n+1, beginning with a Gauss 10-point rule). For instance,
// GaussKronrod21Integrator approximates integrals using the Gauss 10-point
// and the Kronrod 21-point rule.
var gk21 = new GaussKronrod21Integrator();
Console.WriteLine( "Estimate using Gauss-Kronrod 21 integrator = {0}",
gk21.Integrate( f, 1, 4 ) );

Console.WriteLine();
Console.WriteLine( "Press Enter Key" );