BisectionSolver<T> Class

public sealed class BisectionSolver<T> : RootBracketingSolver<T>
where T : Object, INumber<T>

Public NotInheritable Class BisectionSolver(Of T As {Object, INumber(Of T)})
	Inherits RootBracketingSolver(Of T)

generic<typename T>
where T : Object, INumber<T>
public ref class BisectionSolver sealed : public RootBracketingSolver<T>

[<SealedAttribute>]
type BisectionSolver<'T when 'T : Object and INumber<'T>> = 
    class
        inherit RootBracketingSolver<'T>
    end

Inheritance

Object  →  ManagedIterativeAlgorithm<T, T, SolutionReport<T, T>>  →  IterativeAlgorithm<T>  →  EquationSolver<T>  →  RootBracketingSolver<T>  →  BisectionSolver<T>

Type Parameters

T

Use the BisectionSolver class to solve a simple non-linear equation if you have an interval that includes a root with certainty, and when you only need a rough approximation of the root. If you need higher accuracy, other algorithms are more efficient. TOMS algorithm 748 is the method of choice for these situations.

BisectionSolver inherits from RootBracketingSolver, which in turn inherits from IterativeAlgorithm<T>. All properties of IterativeAlgorithm<T> are available. The AbsoluteTolerance and RelativeTolerance properties set the desired precision as specified by the ConvergenceCriterion property. The default value for both tolerances is SqrtEpsilon (roughly 10^-8). MaxIterations sets the maximum number of iterations.

The TargetFunction property is a function of one variable that specifies the function we want to find a root for. The LowerBound and UpperBound properties specify the bounds of the bracketing interval. The target function must have a different sign at each end of this interval.

The Solve() method performs the actual approximation of the root. This method returns the best approximation that was found. The AlgorithmStatus property indicates whether the algorithm was successful. The EstimatedError property gives an upper bound for the difference between the approximated and the actual root.

The bisection method is the simplest of the root bracketing algorithms. It works by dividing the bracketing interval into two equal parts in each iteration. Not taking into account round-off error, the number of iterations needed to achieve a certain accuracy can be estimated easily as the base 2 logarithm of the relative accuracy. It takes about 10 iterations to gain three digits in accuracy.

Reference