# 9.83 UnivariatePolynomial¶

The domain constructor UnivariatePolynomial (abbreviated UP) creates domains of univariate polynomials in a specified variable. For example, the domain UP(a1,POLY FRAC INT) provides polynomials in the single variable a1 whose coefficients are general polynomials with rational number coefficients.

Restriction:

FriCAS does not allow you to create types where UnivariatePolynomial is contained in the coefficient type of Polynomial. Therefore, UP(x,POLY INT) is legal but POLY UP(x,INT) is not.

.

UP(x,INT) is the domain of polynomials in the single variable x with integer coefficients.

```
(p,q) : UP(x,INT)
```

Void

```
p := (3*x-1)^2 * (2*x + 8)
```

18x3+60x2-46x+8 |

_{Type: UnivariatePolynomial(x,Integer)}

```
q := (1 - 6*x + 9*x^2)^2
```

81x4-108x3+54x2-12x+1 |

_{Type: UnivariatePolynomial(x,Integer)}

The usual arithmetic operations are available for univariate polynomials.

```
p^2 + p*q
```

1458x7+3240x6-7074x5+10584x4-9282x3+4120x2-878x+72 |

_{Type: UnivariatePolynomial(x,Integer)}

The operation leadingCoefficientleadingCoefficientUnivariatePolynomial extracts the coefficient of the term of highest degree.

```
leadingCoefficient p
```

18 |

_{Type: PositiveInteger}

The operation degreedegreeUnivariatePolynomial returns the degree of the polynomial. Since the polynomial has only one variable, the variable is not supplied to operations like degreedegreeUnivariatePolynomial.

```
degree p
```

3 |

_{Type: PositiveInteger}

The reductum of the polynomial, the polynomial obtained by subtracting the term of highest order, is returned by reductumreductumUnivariatePolynomial.

```
reductum p
```

60x2-46x+8 |

_{Type: UnivariatePolynomial(x,Integer)}

The operation gcdgcdUnivariatePolynomial computes the greatest common divisor of two polynomials.

```
gcd(p,q)
```

9x2-6x+1 |

_{Type: UnivariatePolynomial(x,Integer)}

The operation lcmlcmUnivariatePolynomial computes the least common multiple.

```
lcm(p,q)
```

162x5+432x4-756x3+408x2-94x+8 |

_{Type: UnivariatePolynomial(x,Integer)}

The operation resultantresultantUnivariatePolynomial computes the resultant of two univariate polynomials. In the case of p and q, the resultant is 0 because they share a common root.

```
resultant(p,q)
```

0 |

_{Type: NonNegativeInteger}

To compute the derivative of a univariate polynomial with respect to its variable, use DDUnivariatePolynomial.

```
D p
```

54x2+120x-46 |

_{Type: UnivariatePolynomial(x,Integer)}

Univariate polynomials can also be used as if they were functions. To evaluate a univariate polynomial at some point, apply the polynomial to the point.

```
p(2)
```

300 |

_{Type: PositiveInteger}

The same syntax is used for composing two univariate polynomials, i.e. substituting one polynomial for the variable in another. This substitutes q for the variable in p.

```
p(q)
```

9565938x12-38263752x11+70150212x10-77944680x9+58852170x8-32227632x7+13349448x6-4280688x5+1058184x4-192672x3+23328x2-1536x+40 |

_{Type: UnivariatePolynomial(x,Integer)}

This substitutes p for the variable in q.

```
q(p)
```

8503056x12+113374080x11+479950272x10+404997408x9-1369516896x8-626146848x7+2939858712x6-2780728704x5+1364312160x4-396838872x3+69205896x2-6716184x+279841 |

_{Type: UnivariatePolynomial(x,Integer)}

To obtain a list of coefficients of the polynomial, use coefficientscoefficientsUnivariatePolynomial.

```
l := coefficients p
```

[18,60,-46,8] |

_{Type: List Integer}

From this you can use gcdgcdUnivariatePolynomial and reducereduceList to compute the content of the polynomial.

```
reduce(gcd,l)
```

2 |

_{Type: PositiveInteger}

Alternatively (and more easily), you can just call contentcontentUnivariatePolynomial.

```
content p
```

2 |

_{Type: PositiveInteger}

Note that the operation coefficientscoefficientsUnivariatePolynomial omits the zero coefficients from the list. Sometimes it is useful to convert a univariate polynomial to a vector whose i-th position contains the degree i-1 coefficient of the polynomial.

```
ux := (x^4+2*x+3)::UP(x,INT)
```

x4+2x+3 |

_{Type: UnivariatePolynomial(x,Integer)}

To get a complete vector of coefficients, use the operation vectorisevectoriseUnivariatePolynomial, which takes a univariate polynomial and an integer denoting the length of the desired vector.

```
vectorise(ux,5)
```

[3,2,0,0,1] |

_{Type: Vector Integer}

It is common to want to do something to every term of a polynomial, creating a new polynomial in the process.

This is a function for iterating across the terms of a polynomial, squaring each term.

```
squareTerms(p) == reduce(+,[t^2 for t in monomials p])
```

Void

Recall what p looked like.

```
p
```

18x3+60x2-46x+8 |

_{Type: UnivariatePolynomial(x,Integer)}

We can demonstrate squareTerms on p.

```
squareTerms p
```

```
Compiling function squareTerms with type
UnivariatePolynomial(x,Integer) ->
UnivariatePolynomial(x,Integer)
```

324x6+3600x4+2116x2+64 |

_{Type: UnivariatePolynomial(x,Integer)}

When the coefficients of the univariate polynomial belong to a field,For example, when the coefficients are rational numbers, as opposed to integers. The important property of a field is that non-zero elements can be divided and produce another element. The quotient of the integers 2 and 3 is not another integer. it is possible to compute quotients and remainders.

```
(r,s) : UP(a1,FRAC INT)
```

Void

```
r := a1^2 - 2/3
```

a12-23 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

```
s := a1 + 4
```

a1+4 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

When the coefficients are rational numbers or rational expressions, the operation quoquoUnivariatePolynomial computes the quotient of two polynomials.

```
r quo s
```

a1-4 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

The operation remremUnivariatePolynomial computes the remainder.

```
r rem s
```

463 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

The operation dividedivideUnivariatePolynomial can be used to return a record of both components.

```
d := divide(r, s)
```

[quotient=a1-4,remainder=463] |

_{Type: Record( quotient: UnivariatePolynomial(a1,Fraction Integer),}
remainder: UnivariatePolynomial(a1,Fraction Integer))

Now we check the arithmetic!

```
r - (d.quotient * s + d.remainder)
```

0 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

It is also possible to integrate univariate polynomials when the coefficients belong to a field.

```
integrate r
```

13a13-23a1 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

```
integrate s
```

12a12+4a1 |

_{Type: UnivariatePolynomial(a1,Fraction Integer)}

One application of univariate polynomials is to see expressions in terms of a specific variable.

We start with a polynomial in a1 whose coefficients are quotients of polynomials in b1 and b2.

```
t : UP(a1,FRAC POLY INT)
```

Void

Since in this case we are not talking about using multivariate polynomials in only two variables, we use Polynomial. We also use Fraction because we want fractions.

```
t := a1^2 - a1/b2 + (b1^2-b1)/(b2+3)
```

a12-1b2a1+b12-b1b2+3 |

_{Type: UnivariatePolynomial(a1,Fraction Polynomial Integer)}

We push all the variables into a single quotient of polynomials.

```
u : FRAC POLY INT := t
```

a12b22+(b12-b1+3a12-a1)b2-3a1b22+3b2 |

_{Type: Fraction Polynomial Integer}

Alternatively, we can view this as a polynomial in the variable This is a mode-directed conversion: you indicate as much of the structure as you care about and let FriCAS decide on the full type and how to do the transformation.

```
u :: UP(b1,?)
```

1b2+3b12-1b2+3b1+a12b2-a1b2 |

_{Type: UnivariatePolynomial(b1,Fraction Polynomial Integer)}

See ugProblemFactorPage in Section ugProblemFactorNumber for a discussion of the factorization facilities in FriCAS for univariate polynomials. For more information on related topics, see ugIntroVariablesPage in Section ugIntroVariablesNumber , ugTypesConvertPage in Section ugTypesConvertNumber , PolynomialXmpPage , MultivariatePolynomialXmpPage , and DistributedMultivariatePolynomialXmpPage .