FIXED-POINT METHOD
Fixed Point

The idea behind the fixed point method is very simple: to find the solutions of a given nonlinear function f(x) = 0, it is possible to rearrange f(x)= 0 into the form x = g(x), where g(x) denotes a function of x. Then, simply start with an initial guess, x₀ and apply the iteration process:

For example, to find solutions for the following nonlinear equation:

There are several ways to rewrite the above equation into the form x = g(x). For example, it is possible to rearrange the above equation into the following form:

Or can be rearranged as:

BIRGE-VIETA METHOD
Birge Vieta Method

The Birge-Vieta method is also an iterative method for finding real roots of the nth degree polynomial equation f(x) = P_n(x) = 0 of the form

If x₁ is a real root of P_n(x) = 0, then

is a reduced (n - 1)th degree polynomial of the form

If x₁ is any approximation to the true root, then

Where R is the residue which is a function of x₁. It is possible to get the following relations by comparing the coefficients of P_n(x) and (x - x₁) Q_n-1(x) + R:

Also note that P_n(x₁) = Q_n-1(x₁).

Birge-Vieta uses up to a point the Newton-Raphson technique (please refer to Newton-Raphson method) to find the roots of the polynomials. Together this algorithm is known as the Birge-Vieta method.

Now one can use the above coefficients and the Newton-Raphson iteration to find the roots of the polynomials. This algorithm is known as the Birge-Vieta method.

IMPLEMENTATION
Birge-Vieta Method

We wrote a static method, BirgeVieta and added to our Nonlinear system class library(class code not shown).

           public static double[] BirgeVieta(double[] a, double x0, int nOrder, int nRoots,
              int nIterations, double tolerance)r />
           {
              double x = x0;
              double[] roots = new double[nRoots];
              double[] a1 = new double[nOrder + 1];
              double[] a2 = new double[nOrder + 1];
              double[] a3 = new double[nOrder + 1];
              for (int j = 0; j <= nOrder; j++)
                  a1[j] = a[j];
              double delta = 10 * tolerance;
              int i = 1, n = nOrder + 1, nroot = 0;
              while (i++ < nIterations && n > 1)
              {
                  double x1 = x;
                  a2[n-1] = a1[n-1];
                  a3[n-1] = a1[n-1];
                  for (int j = n - 2; j > 0; j--)
                  {
                    a2[j] = a1[j] + x1 * a2[j + 1];
                    a3[j] = a2[j] + x1 * a3[j + 1];
                  }
                  a2[0] = a1[0] + x1 * a2[1];
                  delta = a2[0] / a3[1];
                  x -= delta;
                  if (Math.Abs(delta) < tolerance)
                  {
                    i = 1;
                    n--;
                    roots[nroot] = x;
                    nroot++;
                    for (int j = 0; j < n; j++)
                    {
                      a1[j] = a2[j + 1];
                      if (n == 2)
                      {
                        n--;
                        roots[nroot] = -a1[0];
                        nroot++;
                    }
                  }
              }
           }
           return roots;
        }

This method takes coefficients of the polynomial as input:

Although we don't show the method in its entirety and discuss its internal components, while using this method, one can also specify an initial guess x₀, order of the polynomial, number of roots, maximum number of iterations, and tolerance.

Testing the Birge Vieta Method

Solve the following nonlinear equation:

The initial values were set to x₀ = 0.0, order of the polynomial = 3, number of roots = 3, tolerance = 0.0001, and the maximum number of iterations = 1000.

In order to test the nonlinear function defined above, a new method TestBirgeVieta() has been added and executed:

Results are shown in screen below.