שיטת אברת'
מימושים תכנותיים של השיטה

מימוש השיטה בשפת התכנות פייתון:
# Implementation of Aberth's method in Python, written by Jonathan.

from numpy import linspace
from math import sin,cos,pi
from typing import Callable

def random_approximations(coefficients):
 """ הפעולה מחזירה רשימה של קירובים התחלתיים, בהתאם לרשימת המקדמים אשר היא מקבלת"""
    n = len(coefficients) - 1
    radius = abs(coefficients[-1] / coefficients[0]) ** (1 / n)
    return [complex(radius * cos(angle), radius * sin(angle)) for angle in linspace(0, 2 * pi, n)]

def negligible_complex(expression: complex, epsilon:float)->bool:
    """ הפעולה מחזירה האם מספר מרוכב כה קטן כך שהוא זניח וניתן להחשיבו כ-0"""
    return abs(expression.real) < epsilon and abs(expression.imag) < epsilon

def aberth_method(f_0: Callable, f_1: Callable, coefficients, epsilon=0.000001, nmax=100000):
    """ הפעולה מקבלת את הפונקציה, את נגזרתה, ואת המקדמים של הפונקציה. בנוסף מקבלת אפסילון אשר קובע את ההפרש שלפיו מחשיבים מספר כזניח ואת מספר האיטרציות המקסימלי"""
    try:
        random_guesses = random_approximations(coefficients)
        for n in range(nmax):
            offsets = []
            for k, zk in enumerate(random_guesses):
                m = f_0(zk) / f_1(zk)  # save it as m, so it won't be calculated many times
                sigma = sum(1 / (zk - zj) for j, zj in enumerate(random_guesses) if k != j and zk != zj)
                denominator = 1 - m * sigma
                offsets.append(m / denominator)
            random_guesses = [approximation - offset for approximation, offset in zip(random_guesses, offsets)]
            if all(negligible_complex(f_0(guess), epsilon) for guess in random_guesses):
                break
        return set(random_guesses)
    except ValueError:
        return set()
מימוש של השיטה בשפת C++ :
// Implementation of Aberth-Ehrlich Method in C++, by Jonathan.
#include <iostream>
#include <vector>
#include <complex>
#include <cmath>

using std::vector;
using std::complex;

const int PI = 3.141592653589793;

vector<complex<float>> initial_approximations(vector<float> coefficients){
    // Generating the initial approximations that will converge to the roots.
    unsigned int n = coefficients.size();
    float radius =  std::sqrt(std::abs(coefficients[n-1] /  coefficients[0])); // the radius of the circle in the complex plane
    vector<complex<float>> initials;
    float angle;
    for(size_t k=0; k<n-1 ; ++k){
        angle = 2*PI*k /n;
        initials.push_back(complex<float>{radius*std::cos(angle),radius*std::sin(angle)});
    }
    return initials;
}

vector<complex<float>> aberth_method(complex<float>(*f_0)(complex<float>),complex<float> (*f_1)(complex<float>),
                                         vector<float>coefficients,float epsilon=0.00001,int nmax=100000){
    vector<complex<float>> initials = initial_approximations(coefficients);
    unsigned int n = coefficients.size(); // the number of coefficients
    complex<float> offsets[n-1]; // array of complex numbers that represents the differences between the approximations and the solutions
    complex<float> y,y_tag,m,sum;
    complex<float> one = complex<float>{1,0};
    bool all_converged;
    for(size_t iteration = 0; iteration < nmax ; ++iteration){ // Continue with this loop until convergence
        all_converged = true; // assuming that all of the roots have converged
        for(size_t i = 0; i<n-1 && all_converged ; ++i){ // checking if the roots have converged
                y = f_0(initials[i]); 
                if(y.real() > epsilon || y.imag() > epsilon){
                    all_converged = false;}
        }
        if(all_converged){return initials;} // if the roots have converged, return them
        // otherwise, continue with the algorithm.
        for(size_t k = 0 ; k < n-1 ; ++k){ // create n offsets, and subtract each offset from the corresponding approximation.
            y = f_0(initials[k]); // 
            y_tag = f_1(initials[k]);
            m = y/y_tag;
            sum = 0;
            for(size_t j = 0; j < n-1 ; ++j){ // computing the result of the sigma in the denominator of the formula 
            // for computing the offsets
                if(j == k || initials[k] == initials[j]){ // avoid dividing by 0 in later  
                    continue;}
                sum += one/(initials[k]-initials[j]);
            }
            offsets[k] = m / (one - m * sum);
            initials[k] -= offsets[k]; // subtract the current offset from the approximation
        }
        
    }
    printf("WARNING: it's highly likely the initial values haven't converged sufficiently to the solutions\n");
    return initials;

}
בדרך כלל, לאלגוריתם אברת' ארליך יש סיבוכיות זמן ריצה של  O(m*n^{2}), כאשר  n הוא מספר השורשים שיש למצוא, ו  m הוא מספר האיטרציות המקסימלי ללולאה החיצונית, כפי שמתואר בדוגמה שלעיל. לפיכך, ככל שהשיטה נדרשת למצוא יותר שורשים, כך זמן הריצה שלה גדל.  בתחומים מדעיים שונים עולה לעיתים הצורך למצוא את השורשים של משוואה פולינומית בעלת מספר גדול של שורשים במהירות רבה. לכן, חוקרים שונים פיתחו אלגוריתמים מקביליים ואסינכרונים יעילים , אשר מצליחים לגרום להפחתה של זמן הריצה באמצעות שימוש יעיל בו זמני במספר משאבי חומרה ( מעבדים, מעבדים גרפיים, וכו' ) ו/או מספר תהליכים אשר מריצים מספר גדול של תהליכונים.