Basic Integration in Visual Basic QuickStart Sample

Illustrates the basic numerical integration classes in Visual Basic.

This sample is also available in: C#, F#, IronPython.

Overview

This QuickStart sample demonstrates how to use the basic numerical integration classes in Numerics.NET.

The sample shows how to use three different non-adaptive numerical integration algorithms:

• Simpson’s Rule - A simple and widely used integration method
• Gauss-Kronrod Integration - An optimized fixed-point scheme using carefully chosen evaluation points
• Romberg Integration - A method that combines Simpson’s Rule with convergence acceleration

For each integration method, the sample demonstrates:

• How to configure the integrator (tolerances, convergence criteria)
• How to perform the actual integration
• How to access results and diagnostic information (error estimates, iteration counts)
• The strengths and limitations of each method

The sample concludes by showing how simpler integration methods can break down when dealing with difficult integrands that have singularities or discontinuities, setting up the motivation for using adaptive integration methods covered in other samples.

The code

Option Infer On

' The numerical integration classes reside in the
' Numerics.NET.Calculus namespace.
Imports Numerics.NET.Calculus
' Function delegates reside in the Numerics.NET
' namespace.
Imports Numerics.NET

' Illustrates the use of the Newton-Raphson equation solver
' in the Numerics.NET.EquationSolvers namespace of Numerics.NET.
Module BasicIntegration

    Sub Main()
        ' The license is verified at runtime. We're using
        ' a 30 day trial key here. For more information, see
        '     https://numerics.net/trial-key
        Numerics.NET.License.Verify("your-trial-key-here")

        ' Numerical integration algorithms fall into two
        ' main categories: adaptive and non-adaptive.
        ' 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(Of Double, Double). For more
        ' information about this delegate, see the
        ' Functions QuickStart sample.
        Dim f As Func(Of Double, Double) = AddressOf Math.Sin
        ' Variable to hold the result:
        Dim result As Double

        '
        ' SimpsonIntegrator
        '

        ' The simplest numerical integration algorithm
        ' is Simpson's rule.
        Dim simpson As New SimpsonIntegrator()
        ' You can set the relative or absolute tolerance
        ' to which to evaluate the integral.
        simpson.RelativeTolerance = 0.00001
        ' 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, 5)
        Console.WriteLine("sin(x) on [0,2]")
        Console.WriteLine("Simpson integrator:")
        ' The result is also available in the Result
        ' property:
        Console.WriteLine($"  Value: {simpson.Result}")
        ' To see whether the algorithm ended normally,
        ' inspect the Status property:
        Console.WriteLine($"  Status: {simpson.Status}")
        ' You can find out the estimated error of the result
        ' through the EstimatedError property:
        Console.WriteLine($"  Estimated error: {simpson.EstimatedError}")
        ' The number of iterations to achieve the result
        ' is available through the IterationsNeeded property.
        Console.WriteLine($"  Iterations: {simpson.IterationsNeeded}")
        ' The number of function evaluations is available
        ' through the EvaluationsNeeded property.
        Console.WriteLine($"  Function evaluations: {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.
        Dim nagk As New NonAdaptiveGaussKronrodIntegrator()
        nagk.Integrate(f, 0, 5)
        Console.WriteLine("Non-adaptive Gauss-Kronrod rule:")
        Console.WriteLine($"  Value: {nagk.Result}")
        Console.WriteLine($"  Status: {nagk.Status}")
        Console.WriteLine($"  Estimated error: {nagk.EstimatedError}")
        Console.WriteLine($"  Iterations: {nagk.IterationsNeeded}")
        Console.WriteLine($"  Function evaluations: {nagk.EvaluationsNeeded}")

        '
        ' Romberg Integration
        '

        ' Romberg integration combines Simpson's Rule
        ' with a scheme to accelerate convergence.
        ' This algorithm is useful for smooth integrands.
        Dim romberg As New RombergIntegrator()
        result = romberg.Integrate(f, 0, 5)
        Console.WriteLine("Romberg integration:")
        Console.WriteLine($"  Value: {romberg.Result}")
        Console.WriteLine($"  Status: {romberg.Status}")
        Console.WriteLine($"  Estimated error: {romberg.EstimatedError}")
        Console.WriteLine($"  Iterations: {romberg.IterationsNeeded}")
        Console.WriteLine($"  Function evaluations: {romberg.EvaluationsNeeded}")

        ' However, it breaks down if the integration
        ' algorithm contains singularities or
        ' discontinuities.
        f = AddressOf HardIntegrand
        result = romberg.Integrate(f, 0, 1)
        Console.WriteLine("Romberg on hard integrand:")
        Console.WriteLine($"  Value: {romberg.Result}")
        Console.WriteLine("  Actual value: 100")
        Console.WriteLine($"  Status: {romberg.Status}")
        Console.WriteLine($"  Estimated error: {romberg.EstimatedError}")
        Console.WriteLine($"  Iterations: {romberg.IterationsNeeded}")
        Console.WriteLine($"  Function evaluations: {romberg.EvaluationsNeeded}")

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

    ' Function that will cause difficulties to the
    ' simplistic integration algorithms.
    Private Function HardIntegrand(x As Double) As Double
        ' This is put in because some integration rules
        ' evaluate the function at x=0.
        If (x <= 0) Then
            Return 0
        End If
        Return Math.Pow(x, -0.9) * Math.Log(1 / x)
    End Function

End Module