
RootOf




The function RootOf is a placeholder for representing one, many, or all of the roots of an equation in one variable. In particular, it is the standard representation for Maple algebraic numbers, algebraic functions
, and finite fields. Maple 18 includes a number of improvements to make it easier to work with.
RootOfs often appear as the result of a call to solve. This happens when solve cannot find an explicit solution for the solution of a nonalgebraic equation in one variable.
>

solve( cos(x^2) = 2*cos(x)+x, x );

 (1) 
Alternatively, they may be built directly as an abstract representation of a number that satisfies a certain equation:
 (2) 
A standard interaction with RootOf is to ask for an exact or floatingpoint approximation of one or more values represented by the RootOf function. To convert roots representing algebraic numbers to floatingpoint values (by default the principal root is chosen), use evalf:
 (3) 
To convert to radicals, use convert:
>

convert(RootOf(x^22), radical);

 (4) 
If the set of all roots is needed, use the allvalues command:
 (5) 
 (6) 
RootOfs can be specified using various selector types: numeric, interval, index, or label, as described in the following sections.

Numeric Selectors


The numeric selector is a numerical approximation to the desired root. In previous versions of Maple, evalf and allvalues used the numeric selector as a starting point for a Newton's method evaluation of the root. In Maple 18, the meaning of the numeric selector for RootOfs has been redefined and is more precise.
If is the value of the numerical approximation, and if the polynomial is univariate with rational coefficients, the closest among all the roots of the polynomial to is the one selected. As shown further below, if the approximation is ambiguous, an error will be raised by evalf or convert.
>

b := RootOf(x^32, x, 1.26);

 (1.1) 
 (1.2) 


Interval Selectors


The interval selector specifies a root within the interval. For Maple18, errors are now raised if there is not at least one root in the interval or bounding box, or if the bounding box is not wellspecified. The numbers should be given in the order of the lowerleft corner of the box to the upperright corner of the box (or the left and right endpoints, in the case of a real interval), otherwise, an error will be raised.
The polynomial contains two roots, as follows:
>

allvalues(RootOf(x^2x1, 1/2));

 (2.1) 
 (2.2) 
The interval is sufficient to select the positive root:
 (2.3) 
 (2.4) 
Errors when the interval is invalid:
>

RootOf(x^2x1, 1+2*I..2I);

Errors when the interval contains no root:
>

RootOf(x^2x1, 12*I..2I);



Index Selectors


The index selector specifies a root by its position according to a predefined ordering of the roots. Roots closer to the positive real line (approaching in a clockwise direction) have lower indices. Ties are broken by the rule that roots with lower absolute values have lower indices.
The following calculation demonstrates the index definition described above. The index of each root of a polynomial is plotted at the root's location in the complex plane.
>

poly := z*(z^81)*(z^82^8);

 (3.1) 
Show where the root with index = 5 is located:
>

convert(RootOf(poly, index=5), radical);

 (3.2) 
Now plot the locations of all the roots, identifying each by its index:
>

pts := evalf[2]([seq(RootOf(poly, index=i), i=1..17)]):

>

plots:display([seq(plots:textplot([op([Re, Im](pts[i])), i], font = ["Helvetica", "Bold", 12]), i=1..17)],axes=boxed, view=[2.5..2.5, 2.5..2.5], labels =[Re(z), Im(z)]);



Label Selectors


The label selector provides a way to specify that one root is the same or different than another, without actually determining a value for each root.
Roots with different labels are meant to be different, as demonstrated by the following:
>

alias( c=RootOf(z^3+1, z, label=A) ):

>

alias( d=RootOf(z^3+1, z, label=B) ):

 (4.1) 
 (4.2) 
Label selectors should not be used if the roots are algebraic and need to be evaluated numerically. For example, if the roots are known to be algebraic, then evalf or convert may evaluate two supposedly different roots to the same value:
 (4.3) 
 (4.4) 
In this case, an index, numeric, or interval selector should be used instead. The documentation has been updated to provide a warning about this situation.


Specificity of Selectors


The command evalf raises an error if the numeric or interval selector is not sufficiently specific.
>

e := RootOf(x^2x1, 5..5);

 (5.1) 
Error because there are multiple possible roots in the interval:
>

e := RootOf(x^2x1, 1/2);

 (5.2) 
Error because the numeric selector is equally distant from the two roots, so it is not sufficient to distinguish between them:


Converting Between Different Selectors


RootOfs can now be converted between different (nonlabel) selectors:
>

f := RootOf(x^3x1, index=1);

 (6.1) 
>

g := convert(f, RootOf, form = interval);

 (6.2) 
>

h := convert(g, RootOf, form = numeric);

 (6.3) 
>

convert(h, RootOf, form = index);

 (6.4) 
convert also raises an error when the specification of the root is ambiguous:
>

convert(RootOf(x^2x1, 1/2), RootOf, form = index);

>

convert(RootOf(x^2x2,2..2 ), RootOf, form=index);



Improvements in evalarelated Procedures


evalarelated procedures are improved as a side effect of the changes to RootOf.
Additionally, evalarelated functions, such as gcd, are now more careful:
>

r[1] := RootOf(_Z^22,0);

 (7.1) 
>

r[2] := RootOf(_Z^22,index = 1);

 (7.2) 
The numeric selector, , is not sufficient to distinguish whether is the positive or negative root. Therefore, the following gcd computation is ambiguous: if represents the positive root, then the GCD is , but if represents the negative root, then the GCD is 1. Hence an error is raised:


Indices Adjusted as Multiplicities Removed


Index selectors are now adjusted, if necessary, as multiplicities are removed from the defining polynomial:
>

RootOf(x^5x^2, index=4);

 (8.1) 

