Extreme Optimization >
QuickStart Samples >
Advanced Integration QuickStart Sample (C#)
Extreme Optimization QuickStart Samples
Advanced Integration QuickStart Sample (C#)
Illustrates more advanced numerical integration (quadrature) using the AdaptiveIntegrator
class (Extreme.Mathematics.Calculus namespace) in C#.
VB.NET code
Back to QuickStart Samples
using System;
namespace Extreme.Mathematics.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;
/// <summary>
/// Illustrates the more advanced use of the
/// AdaptiveGaussKronrodIntegrator numerical integrator class
/// classes in the Extreme.Mathematics.Calculus namespace.
/// </summary>
class AdvancedIntegration
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
// Numerical integration algorithms fall into two
// main categories: adaptive and non-adaptive.
// This QuickStart Sample illustrates the use of
// the adaptive numerical integrator implemented by
// the AdaptiveIntegrator class. This class is the
// most advanced of the numerical integration
// classes.
//
// 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 RealFunction. For more
// information about this delegate, see the
// FunctionDelegates QuickStart sample.
//
// The functions used in this sample are defined at
// the end of this file.
RealFunction f1 =
new RealFunction(Integrand2);
RealFunction f2 =
new RealFunction(Integrand3);
RealFunction f3 =
new RealFunction(Integrand4);
// Variable to hold the result:
double result;
// Construct an instance of the integrator class:
AdaptiveIntegrator integrator =
new AdaptiveIntegrator();
//
// Adaptive integrator basics
//
// All the properties and methods defined by the
// NumericalIntegrator base class are available.
// See the BasicIntegration QuickStart Sample
// for details. The AdaptiveIntegrator class defines
// the following additional properties:
//
// The IntegrationRule property gets or sets the
// integration rule that is to be used for
// integrating subintervals. It can be any
// object derived from IntegrationRule.
//
// For convenience, a series of Gauss-Kronrod
// integration rules of order 15, 21, 31, 41, 51,
// and 61 have been provided.
integrator.IntegrationRule =
new GaussKronrodIntegrator15();
// The UseExtrapolation property specifies whether
// precautions should be taken for singularities
// in the integration interval.
integrator.UseExtrapolation = false;
// Finally, the Singularities property allows you
// to specify singularities or discontinuities
// inside the integration interval. See the
// sample below for details.
//
// Integration over infinite intervals
//
integrator.AbsoluteTolerance = 1e-8;
integrator.ConvergenceCriterion =
ConvergenceCriterion.WithinAbsoluteTolerance;
// The Integrate method performs the actual
// integration. To integrate over an infinite
// interval, simply use either or both of
// double.PositiveInfinity and
// double.NegativeInfinity as bounds:
result = integrator.Integrate(f1,
double.NegativeInfinity, double.PositiveInfinity);
Console.WriteLine("Exp(-x^2-x) on [-inf,inf]");
Console.WriteLine(" Value: {0}", integrator.Result);
// To see whether the algorithm ended normally,
// inspect the Status property:
Console.WriteLine(" Status: {0}",
integrator.Status);
Console.WriteLine(" Estimated error: {0}",
integrator.EstimatedError);
Console.WriteLine(" Iterations: {0}",
integrator.IterationsNeeded);
Console.WriteLine(" Function evaluations: {0}",
integrator.FunctionEvaluationsNeeded);
//
// Functions with singularities at the end points
// of the integration interval.
//
// Thanks to the adaptive nature of the algorithm,
// special measures can be taken to accelerate
// convergence near singularities. To enable this
// acceleration, set the Singularities property
// to true.
integrator.UseExtrapolation = true;
// We'll use the function that gives the Romberg
// integrator in the BasicIntegration QuickStart
// sample trouble.
integrator.Integrate(f2, 0, 1);
Console.WriteLine("Singularities on boundary:");
Console.WriteLine(" Value: {0}", integrator.Result);
Console.WriteLine(" Exact value: 100");
Console.WriteLine(" Status: {0}",
integrator.Status);
Console.WriteLine(" Estimated error: {0}",
integrator.EstimatedError);
// Where Romberg integration failed after 1,000,000
// function evaluations, we find the correct answer
// to within tolerance using only 135 function
// evaluations!
Console.WriteLine(" Iterations: {0}",
integrator.IterationsNeeded);
Console.WriteLine(" Function evaluations: {0}",
integrator.FunctionEvaluationsNeeded);
//
// Functions with singularities or discontinuities
// inside the interval.
//
integrator.UseExtrapolation = true;
// We will pass an array containing the interior
// singularities to the integrator through the
// Singularities property:
integrator.SetSingularities(1, Math.Sqrt(2));
integrator.Integrate(f3, 0, 3);
Console.WriteLine("Singularities inside the interval:");
Console.WriteLine(" Value: {0}", integrator.Result);
Console.WriteLine(" Exact value: 52.740748383471444998");
Console.WriteLine(" Status: {0}",
integrator.Status);
Console.WriteLine(" Estimated error: {0}",
integrator.EstimatedError);
Console.WriteLine(" Iterations: {0}",
integrator.IterationsNeeded);
Console.WriteLine(" Function evaluations: {0}",
integrator.FunctionEvaluationsNeeded);
Console.Write("Press Enter key to exit...");
Console.ReadLine();
}
/// <summary>
/// Function to integrate over [-inf, +inf]
/// </summary>
private static double Integrand2(double x)
{
return Math.Exp(-x-x*x);
}
/// <summary>
/// Function with singularities on the boundaries
/// of the integration interval
/// </summary>
private static double Integrand3(double x)
{
return Math.Pow(x,-0.9) * Math.Log(1/x);
}
/// <summary>
/// Function with singularities inside the interval,
/// at 1 and Sqrt(2)
/// </summary>
private static double Integrand4(double x)
{
return x*x*x * Math.Log(Math.Abs((x*x-1) * (x*x - 2)));
}
}
}
Copyright 2004-2007,
Extreme Optimization. All rights reserved.
Extreme Optimization, Complexity made simple, M#, and M
Sharp are trademarks of ExoAnalytics Inc.
Microsoft, Visual C#, Visual Basic, Visual Studio, and Visual
Studio.NET are registered trademarks of Microsoft Corporation