New Version 6.0!

Try it for free with our fully functional 60-day trial version.

Download now!

QuickStart Samples

Advanced Integration QuickStart Sample (Visual Basic)

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

C# code F# code IronPython code Back to QuickStart Samples

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 
    ' AdaptiveGaussKronrodIntegrator numerical integrator class
    ' classes in the Extreme.Mathematics.Calculus namespace of the Extreme
    ' Optimization Numerical Libraries for .NET.
    Module AdvancedIntegration

        Sub Main()
            ' 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 Func(Of Double, Double). For more
            ' information about this delegate, see the
            ' 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:
            Dim integrator As 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 = 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...")
            Console.ReadLine()
        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