Data Analysis Mathematics Linear Algebra Statistics
New Version 7.0!  QuickStart Samples

# Advanced Integration QuickStart Sample (Visual Basic)

Illustrates more advanced numerical integration using the AdaptiveIntegrator class in Visual Basic.

```Option Infer On

' The numerical integration classes reside in the
' Extreme.Mathematics.Calculus namespace.
Imports Extreme.Mathematics.Calculus
' Function delegates reside in the Extreme.Mathematics
' namespace.
Imports Extreme.Mathematics

Namespace Extreme.Numerics.QuickStart.VB
' Illustrates the more advanced use of the
' classes in the Extreme.Mathematics.Calculus namespace of the Extreme
' Optimization Numerical Libraries for .NET.

Sub Main()
' Numerical integration algorithms fall into two
' 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 Func(Of Double, Double). For more
' Functions QuickStart sample.
'
' The functions used in this sample are defined at
' the end of this file.
Dim f1 As Func(Of Double, Double) = AddressOf Integrand2
Dim f2 As Func(Of Double, Double) = AddressOf Integrand3
Dim f3 As Func(Of Double, Double) = AddressOf Integrand4
' Variable to hold the result:
Dim result As Double
' Construct an instance of the integrator class:

'
'

' 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 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 = IntegrationRule.CreateGaussKronrod15PointRule()

' 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 = 0.00000001
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.EvaluationsNeeded)

'
' 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.EvaluationsNeeded)

'
' 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.740748383471445")
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.EvaluationsNeeded)

Console.Write("Press Enter key to exit...")
End Sub

' Function to integrate over [-inf, +inf]
Private Function Integrand2(ByVal x As Double) As Double
Return Math.Exp(-x - x * x)
End Function

' Function with singularities on the boundaries
' of the integration interval
Private Function Integrand3(ByVal x As Double) As Double
Return Math.Pow(x, -0.9) * Math.Log(1 / x)
End Function

' Function with singularities inside the interval,
' at 1 and Sqrt(2)
Private Function Integrand4(ByVal x As Double) As Double
Return x * x * x * _
Math.Log(Math.Abs((x * x - 1) * (x * x - 2)))
End Function

End Module

End Namespace```