|
virtual int | IsA (const char *type) |
|
vtkPolynomialSolversUnivariate * | NewInstance () const |
|
void | PrintSelf (ostream &os, vtkIndent indent) |
|
vtkObject * | NewInstance () const |
|
virtual void | DebugOn () |
|
virtual void | DebugOff () |
|
bool | GetDebug () |
|
void | SetDebug (bool debugFlag) |
|
virtual void | Modified () |
|
virtual unsigned long | GetMTime () |
|
unsigned long | AddObserver (unsigned long event, vtkCommand *, float priority=0.0f) |
|
unsigned long | AddObserver (const char *event, vtkCommand *, float priority=0.0f) |
|
vtkCommand * | GetCommand (unsigned long tag) |
|
void | RemoveObserver (vtkCommand *) |
|
void | RemoveObservers (unsigned long event, vtkCommand *) |
|
void | RemoveObservers (const char *event, vtkCommand *) |
|
int | HasObserver (unsigned long event, vtkCommand *) |
|
int | HasObserver (const char *event, vtkCommand *) |
|
void | RemoveObserver (unsigned long tag) |
|
void | RemoveObservers (unsigned long event) |
|
void | RemoveObservers (const char *event) |
|
void | RemoveAllObservers () |
|
int | HasObserver (unsigned long event) |
|
int | HasObserver (const char *event) |
|
template<class U , class T > |
unsigned long | AddObserver (unsigned long event, U observer, void(T::*callback)(), float priority=0.0f) |
|
template<class U , class T > |
unsigned long | AddObserver (unsigned long event, U observer, void(T::*callback)(vtkObject *, unsigned long, void *), float priority=0.0f) |
|
template<class U , class T > |
unsigned long | AddObserver (unsigned long event, U observer, bool(T::*callback)(vtkObject *, unsigned long, void *), float priority=0.0f) |
|
int | InvokeEvent (unsigned long event, void *callData) |
|
int | InvokeEvent (const char *event, void *callData) |
|
int | InvokeEvent (unsigned long event) |
|
int | InvokeEvent (const char *event) |
|
const char * | GetClassName () const |
|
virtual void | Delete () |
|
virtual void | FastDelete () |
|
void | Print (ostream &os) |
|
virtual void | Register (vtkObjectBase *o) |
|
virtual void | UnRegister (vtkObjectBase *o) |
|
void | SetReferenceCount (int) |
|
void | PrintRevisions (ostream &) |
|
virtual void | PrintHeader (ostream &os, vtkIndent indent) |
|
virtual void | PrintTrailer (ostream &os, vtkIndent indent) |
|
int | GetReferenceCount () |
|
|
static vtkPolynomialSolversUnivariate * | New () |
|
static int | IsTypeOf (const char *type) |
|
static vtkPolynomialSolversUnivariate * | SafeDownCast (vtkObjectBase *o) |
|
static ostream & | PrintPolynomial (ostream &os, double *P, int degP) |
|
static int | LinBairstowSolve (double *c, int d, double *r, double &tolerance) |
|
static int | FerrariSolve (double *c, double *r, int *m, double tol) |
|
static int | TartagliaCardanSolve (double *c, double *r, int *m, double tol) |
|
static double * | SolveCubic (double c0, double c1, double c2, double c3) |
|
static double * | SolveQuadratic (double c0, double c1, double c2) |
|
static double * | SolveLinear (double c0, double c1) |
|
static int | SolveQuadratic (double *c, double *r, int *m) |
|
static int | SolveLinear (double c0, double c1, double *r1, int *num_roots) |
|
|
static int | HabichtBisectionSolve (double *P, int d, double *a, double *upperBnds, double tol) |
|
static int | HabichtBisectionSolve (double *P, int d, double *a, double *upperBnds, double tol, int intervalType) |
|
static int | HabichtBisectionSolve (double *P, int d, double *a, double *upperBnds, double tol, int intervalType, bool divideGCD) |
|
|
static int | SturmBisectionSolve (double *P, int d, double *a, double *upperBnds, double tol) |
|
static int | SturmBisectionSolve (double *P, int d, double *a, double *upperBnds, double tol, int intervalType) |
|
static int | SturmBisectionSolve (double *P, int d, double *a, double *upperBnds, double tol, int intervalType, bool divideGCD) |
|
|
static int | FilterRoots (double *P, int d, double *upperBnds, int rootcount, double diameter) |
|
|
static int | SolveCubic (double c0, double c1, double c2, double c3, double *r1, double *r2, double *r3, int *num_roots) |
|
|
static int | SolveQuadratic (double c0, double c1, double c2, double *r1, double *r2, int *num_roots) |
|
|
static void | SetDivisionTolerance (double tol) |
|
static double | GetDivisionTolerance () |
|
static int | IsTypeOf (const char *type) |
|
static vtkObject * | SafeDownCast (vtkObjectBase *o) |
|
static vtkObject * | New () |
|
static void | BreakOnError () |
|
static void | SetGlobalWarningDisplay (int val) |
|
static void | GlobalWarningDisplayOn () |
|
static void | GlobalWarningDisplayOff () |
|
static int | GetGlobalWarningDisplay () |
|
static int | IsTypeOf (const char *name) |
|
static vtkObjectBase * | New () |
|
polynomial solvers
vtkPolynomialSolversUnivariate provides solvers for univariate polynomial equations with real coefficients. The Tartaglia-Cardan and Ferrari solvers work on polynomials of fixed degree 3 and 4, respectively. The Lin-Bairstow and Sturm solvers work on polynomials of arbitrary degree. The Sturm solver is the most robust solver but only reports roots within an interval and does not report multiplicities. The Lin-Bairstow solver reports multiplicities.
For difficult polynomials, you may wish to use FilterRoots to eliminate some of the roots reported by the Sturm solver. FilterRoots evaluates the derivatives near each root to eliminate cases where a local minimum or maximum is close to zero.
- Thanks:
- Thanks to Philippe Pebay, Korben Rusek, David Thompson, and Maurice Rojas for implementing these solvers.
- Tests:
- vtkPolynomialSolversUnivariate (Tests)
Definition at line 57 of file vtkPolynomialSolversUnivariate.h.
Finds all REAL roots (within tolerance tol) of the d -th degree polynomial
in ]a[0] ; a[1]] using the Habicht sequence (polynomial coefficients are REAL) and returns the count nr. All roots are bracketed in the first ]upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). intervalType specifies the search interval as follows: 0 = 00 = ]a,b[ 1 = 10 = [a,b[ 2 = 01 = ]a,b] 3 = 11 = [a,b] This defaults to 0. The last non-zero item in the Habicht sequence is the gcd of P and P'. The parameter divideGCD specifies whether the program should attempt to divide by the gcd and run again. It works better with polynomials known to have high multiplicities. When divideGCD != 0 then it attempts to divide by the GCD, if applicable. This defaults to 0. Compared to the Sturm solver the Habicht solver is slower, although both are O(d^2). The Habicht solver has the added benefit that it has a built in mechanism to keep the leading coefficients of the result from polynomial division bounded above and below in absolute value. This will tend to keep the coefficients of the polynomials in the sequence from zeroing out prematurely or becoming infinite. Constructing the Habicht sequence is O(d^2) in both time and space. Warning: it is the user's responsibility to make sure the upperBnds array is large enough to contain the maximal number of expected roots. Note that nr is smaller or equal to the actual number of roots in ]a[0] ; a[1]] since roots within are lumped in the same bracket. array is large enough to contain the maximal number of expected upper bounds.
Finds all REAL roots (within tolerance tol) of the d -th degree polynomial
in ]a[0] ; a[1]] using the Habicht sequence (polynomial coefficients are REAL) and returns the count nr. All roots are bracketed in the first ]upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). intervalType specifies the search interval as follows: 0 = 00 = ]a,b[ 1 = 10 = [a,b[ 2 = 01 = ]a,b] 3 = 11 = [a,b] This defaults to 0. The last non-zero item in the Habicht sequence is the gcd of P and P'. The parameter divideGCD specifies whether the program should attempt to divide by the gcd and run again. It works better with polynomials known to have high multiplicities. When divideGCD != 0 then it attempts to divide by the GCD, if applicable. This defaults to 0. Compared to the Sturm solver the Habicht solver is slower, although both are O(d^2). The Habicht solver has the added benefit that it has a built in mechanism to keep the leading coefficients of the result from polynomial division bounded above and below in absolute value. This will tend to keep the coefficients of the polynomials in the sequence from zeroing out prematurely or becoming infinite. Constructing the Habicht sequence is O(d^2) in both time and space. Warning: it is the user's responsibility to make sure the upperBnds array is large enough to contain the maximal number of expected roots. Note that nr is smaller or equal to the actual number of roots in ]a[0] ; a[1]] since roots within are lumped in the same bracket. array is large enough to contain the maximal number of expected upper bounds.
Finds all REAL roots (within tolerance tol) of the d -th degree polynomial
in ]a[0] ; a[1]] using the Habicht sequence (polynomial coefficients are REAL) and returns the count nr. All roots are bracketed in the first ]upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). intervalType specifies the search interval as follows: 0 = 00 = ]a,b[ 1 = 10 = [a,b[ 2 = 01 = ]a,b] 3 = 11 = [a,b] This defaults to 0. The last non-zero item in the Habicht sequence is the gcd of P and P'. The parameter divideGCD specifies whether the program should attempt to divide by the gcd and run again. It works better with polynomials known to have high multiplicities. When divideGCD != 0 then it attempts to divide by the GCD, if applicable. This defaults to 0. Compared to the Sturm solver the Habicht solver is slower, although both are O(d^2). The Habicht solver has the added benefit that it has a built in mechanism to keep the leading coefficients of the result from polynomial division bounded above and below in absolute value. This will tend to keep the coefficients of the polynomials in the sequence from zeroing out prematurely or becoming infinite. Constructing the Habicht sequence is O(d^2) in both time and space. Warning: it is the user's responsibility to make sure the upperBnds array is large enough to contain the maximal number of expected roots. Note that nr is smaller or equal to the actual number of roots in ]a[0] ; a[1]] since roots within are lumped in the same bracket. array is large enough to contain the maximal number of expected upper bounds.
Finds all REAL roots (within tolerance tol) of the d -th degree polynomial P[0] X^d + ... + P[d-1] X + P[d] in ]a[0] ; a[1]] using Sturm's theorem ( polynomial coefficients are REAL ) and returns the count nr. All roots are bracketed in the first ]upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). intervalType specifies the search interval as follows: 0 = 00 = ]a,b[ 1 = 10 = [a,b[ 2 = 01 = ]a,b] 3 = 11 = [a,b] This defaults to 0. The last non-zero item in the Sturm sequence is the gcd of P and P'. The parameter divideGCD specifies whether the program should attempt to divide by the gcd and run again. It works better with polynomials known to have high multiplicities. When divideGCD != 0 then it attempts to divide by the GCD, if applicable. This defaults to 0. Constructing the Sturm sequence is O(d^2) in both time and space. Warning: it is the user's responsibility to make sure the upperBnds array is large enough to contain the maximal number of expected roots. Note that nr is smaller or equal to the actual number of roots in ]a[0] ; a[1]] since roots within are lumped in the same bracket. array is large enough to contain the maximal number of expected upper bounds.
Finds all REAL roots (within tolerance tol) of the d -th degree polynomial P[0] X^d + ... + P[d-1] X + P[d] in ]a[0] ; a[1]] using Sturm's theorem ( polynomial coefficients are REAL ) and returns the count nr. All roots are bracketed in the first ]upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). intervalType specifies the search interval as follows: 0 = 00 = ]a,b[ 1 = 10 = [a,b[ 2 = 01 = ]a,b] 3 = 11 = [a,b] This defaults to 0. The last non-zero item in the Sturm sequence is the gcd of P and P'. The parameter divideGCD specifies whether the program should attempt to divide by the gcd and run again. It works better with polynomials known to have high multiplicities. When divideGCD != 0 then it attempts to divide by the GCD, if applicable. This defaults to 0. Constructing the Sturm sequence is O(d^2) in both time and space. Warning: it is the user's responsibility to make sure the upperBnds array is large enough to contain the maximal number of expected roots. Note that nr is smaller or equal to the actual number of roots in ]a[0] ; a[1]] since roots within are lumped in the same bracket. array is large enough to contain the maximal number of expected upper bounds.
Finds all REAL roots (within tolerance tol) of the d -th degree polynomial P[0] X^d + ... + P[d-1] X + P[d] in ]a[0] ; a[1]] using Sturm's theorem ( polynomial coefficients are REAL ) and returns the count nr. All roots are bracketed in the first ]upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if anything went wrong (such as: polynomial does not have degree d, the interval provided by the other is absurd, etc.). intervalType specifies the search interval as follows: 0 = 00 = ]a,b[ 1 = 10 = [a,b[ 2 = 01 = ]a,b] 3 = 11 = [a,b] This defaults to 0. The last non-zero item in the Sturm sequence is the gcd of P and P'. The parameter divideGCD specifies whether the program should attempt to divide by the gcd and run again. It works better with polynomials known to have high multiplicities. When divideGCD != 0 then it attempts to divide by the GCD, if applicable. This defaults to 0. Constructing the Sturm sequence is O(d^2) in both time and space. Warning: it is the user's responsibility to make sure the upperBnds array is large enough to contain the maximal number of expected roots. Note that nr is smaller or equal to the actual number of roots in ]a[0] ; a[1]] since roots within are lumped in the same bracket. array is large enough to contain the maximal number of expected upper bounds.
Algebraically extracts REAL roots of the cubic polynomial with REAL coefficients X^3 + c[0] X^2 + c[1] X + c[2] and stores them (when they exist) and their respective multiplicities in the r and m arrays. Some numerical noise can be filtered by the use of a tolerance tol instead of equality with 0 (one can use, e.g., VTK_DBL_EPSILON). The main differences with SolveCubic are that (1) the polynomial must have unit leading coefficient, (2) complex roots are discarded upfront, (3) non-simple roots are stored only once, along with their respective multiplicities, and (4) some numerical noise is filtered by the use of relative tolerance instead of equality with 0. Returns the number of roots. In memoriam Niccolo Tartaglia (1500 - 1559), unfairly forgotten.
Solves a cubic equation when c0, c1, c2, And c3 Are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Roots and number of real roots are stored in user provided variables r1, r2, r3, and num_roots. Note that the function can return the following integer values describing the roots: (0)-no solution; (-1)-infinite number of solutions; (1)-one distinct real root of multiplicity 3 (stored in r1); (2)-two distinct real roots, one of multiplicity 2 (stored in r1 & r2); (3)-three distinct real roots; (-2)-quadratic equation with complex conjugate solution (real part of root returned in r1, imaginary in r2); (-3)-one real root and a complex conjugate pair (real root in r1 and real part of pair in r2 and imaginary in r3).